/*

 * Copyright (C) 2015 Tobias Brunner

 * Copyright (C) 2014 Martin Willi

 *

 * Copyright (C) secunet Security Networks AG

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by the

 * Free Software Foundation; either version 2 of the License, or (at your

 * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.

 *

 * This program 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 General Public License

 * for more details.

 */

#include "vici_message.h"

#include "vici_builder.h"

#include <bio/bio_reader.h>

#include <bio/bio_writer.h>

#include <errno.h>

typedef struct private_vici_message_t private_vici_message_t;

/**

 * Private data of an vici_message_t object.

 */

struct private_vici_message_t {

  /**

   * Public vici_message_t interface.

   */

  vici_message_t public;

  /**

   * Message encoding

   */

  chunk_t encoding;

  /**

   * Free encoding during destruction?

   */

  bool cleanup;

  /**

   * Allocated strings we maintain for get_str()

   */

  linked_list_t *strings;

};

ENUM(vici_type_names, VICI_START, VICI_END,

  "start",

  "section-start",

  "section-end",

  "key-value",

  "list-start",

  "list-item",

  "list-end",

  "end"

);

/**

 * See header.

 */

bool vici_stringify(chunk_t chunk, char *buf, size_t size)

{

  if (!chunk_printable(chunk, NULL, 0))

  {

    return FALSE;

  }

  snprintf(buf, size, "%.*s", (int)chunk.len, chunk.ptr);

  return TRUE;

}

/**

 * See header.

 */

bool vici_verify_type(vici_type_t type, u_int section, bool list)

{

  if (list)

  {

    if (type != VICI_LIST_END && type != VICI_LIST_ITEM)

    {

      DBG1(DBG_ENC, "'%N' within list", vici_type_names, type);

      return FALSE;

    }

  }

  else

  {

    if (type == VICI_LIST_ITEM || type == VICI_LIST_END)

    {

      DBG1(DBG_ENC, "'%N' outside list", vici_type_names, type);

      return FALSE;

    }

  }

  if (type == VICI_SECTION_END && section == 0)

  {

    DBG1(DBG_ENC, "'%N' outside of section", vici_type_names, type);

    return FALSE;

  }

  if (type == VICI_END && section)

  {

    DBG1(DBG_ENC, "'%N' within section", vici_type_names, type);

    return FALSE;

  }

  return TRUE;

}

/**

 * Enumerator parsing message

 */

typedef struct {

  /* implements enumerator */

  enumerator_t public;

  /** reader to parse from */

  bio_reader_t *reader;

  /** section nesting level */

  int section;

  /** currently parsing list? */

  bool list;

  /** string currently enumerating */

  char name[257];

} parse_enumerator_t;

METHOD(enumerator_t, parse_enumerate, bool,

  parse_enumerator_t *this, va_list args)

{

  vici_type_t *out;

  chunk_t *value;

  char **name;

  uint8_t type;

  chunk_t data;

  VA_ARGS_VGET(args, out, name, value);

  if (!this->reader->remaining(this->reader) ||

    !this->reader->read_uint8(this->reader, &type))

  {

    *out = VICI_END;

    return TRUE;

  }

  if (!vici_verify_type(type, this->section, this->list))

  {

    return FALSE;

  }

  switch (type)

  {

    case VICI_SECTION_START:

      if (!this->reader->read_data8(this->reader, &data) ||

        !vici_stringify(data, this->name, sizeof(this->name)))

      {

        DBG1(DBG_ENC, "invalid '%N' encoding", vici_type_names, type);

        return FALSE;

      }

      *name = this->name;

      this->section++;

      break;

    case VICI_SECTION_END:

      this->section--;

      break;

    case VICI_KEY_VALUE:

      if (!this->reader->read_data8(this->reader, &data) ||

        !vici_stringify(data, this->name, sizeof(this->name)) ||

        !this->reader->read_data16(this->reader, value))

      {

        DBG1(DBG_ENC, "invalid '%N' encoding", vici_type_names, type);

        return FALSE;

      }

      *name = this->name;

      break;

    case VICI_LIST_START:

      if (!this->reader->read_data8(this->reader, &data) ||

        !vici_stringify(data, this->name, sizeof(this->name)))

      {

        DBG1(DBG_ENC, "invalid '%N' encoding", vici_type_names, type);

        return FALSE;

      }

      *name = this->name;

      this->list = TRUE;

      break;

    case VICI_LIST_ITEM:

      if (!this->reader->read_data16(this->reader, value))

      {

        DBG1(DBG_ENC, "invalid '%N' encoding", vici_type_names, type);

        return FALSE;

      }

      break;

    case VICI_LIST_END:

      this->list = FALSE;

      break;

    case VICI_END:

      break;

    default:

      DBG1(DBG_ENC, "unknown encoding type: %u", type);

      return FALSE;

  }

  *out = type;

  return TRUE;

}

METHOD(enumerator_t, parse_destroy, void,

  parse_enumerator_t *this)

{

  this->reader->destroy(this->reader);

  free(this);

}

METHOD(vici_message_t, create_enumerator, enumerator_t*,

  private_vici_message_t *this)

{

  parse_enumerator_t *enumerator;

  INIT(enumerator,

    .public = {

      .enumerate = enumerator_enumerate_default,

      .venumerate = _parse_enumerate,

      .destroy = _parse_destroy,

    },

    .reader = bio_reader_create(this->encoding),

  );

  return &enumerator->public;

}

/**

 * Find a value for given vararg key

 */

static bool find_value(private_vici_message_t *this, chunk_t *value,

             char *fmt, va_list args)

{

  enumerator_t *enumerator;

  char buf[128], *name, *key, *dot, *next;

  int section = 0, keysection = 0;

  bool found = FALSE;

  chunk_t current;

  vici_type_t type;

  vsnprintf(buf, sizeof(buf), fmt, args);

  next = buf;

  enumerator = create_enumerator(this);

  /* descent into section */

  while (TRUE)

  {

    dot = strchr(next, '.');

    if (!dot)

    {

      key = next;

      break;

    }

    *dot = '\0';

    key = next;

    next = dot + 1;

    keysection++;

    while (enumerator->enumerate(enumerator, &type, &name, &current))

    {

      switch (type)

      {

        case VICI_SECTION_START:

          section++;

          if (section == keysection && streq(name, key))

          {

            break;

          }

          continue;

        case VICI_SECTION_END:

          section--;

          continue;

        case VICI_END:

          break;

        default:

          continue;

      }

      break;

    }

  }

  /* find key/value in current section */

  while (enumerator->enumerate(enumerator, &type, &name, &current))

  {

    switch (type)

    {

      case VICI_KEY_VALUE:

        if (section == keysection && streq(key, name))

        {

          *value = current;

          found = TRUE;

          break;

        }

        continue;

      case VICI_SECTION_START:

        section++;

        continue;

      case VICI_SECTION_END:

        section--;

        continue;

      case VICI_END:

        break;

      default:

        continue;

    }

    break;

  }

  enumerator->destroy(enumerator);

  return found;

}

METHOD(vici_message_t, vget_str, char*,

  private_vici_message_t *this, char *def, char *fmt, va_list args)

{

  chunk_t value;

  bool found;

  char *str;

  found = find_value(this, &value, fmt, args);

  if (found)

  {

    if (chunk_printable(value, NULL, 0))

    {

      str = strndup(value.ptr, value.len);

      /* keep a reference to string, so caller doesn't have to care */

      this->strings->insert_last(this->strings, str);

      return str;

    }

  }

  return def;

}

METHOD(vici_message_t, get_str, char*,

  private_vici_message_t *this, char *def, char *fmt, ...)

{

  va_list args;

  char *str;

  va_start(args, fmt);

  str = vget_str(this, def, fmt, args);

  va_end(args);

  return str;

}

METHOD(vici_message_t, vget_int, int,

  private_vici_message_t *this, int def, char *fmt, va_list args)

{

  chunk_t value;

  bool found;

  char buf[32], *pos;

  int ret;

  found = find_value(this, &value, fmt, args);

  if (found)

  {

    if (value.len == 0)

    {

      return def;

    }

    if (chunk_printable(value, NULL, 0))

    {

      snprintf(buf, sizeof(buf), "%.*s", (int)value.len, value.ptr);

      errno = 0;

      ret = strtol(buf, &pos, 0);

      if (errno == 0 && pos == buf + strlen(buf))

      {

        return ret;

      }

    }

  }

  return def;

}

METHOD(vici_message_t, get_int, int,

  private_vici_message_t *this, int def, char *fmt, ...)

{

  va_list args;

  int val;

  va_start(args, fmt);

  val = vget_int(this, def, fmt, args);

  va_end(args);

  return val;

}

METHOD(vici_message_t, vget_bool, bool,

  private_vici_message_t *this, bool def, char *fmt, va_list args)

{

  chunk_t value;

  bool found;

  char buf[16];

  found = find_value(this, &value, fmt, args);

  if (found)

  {

    if (value.len == 0)

    {

      return def;

    }

    if (chunk_printable(value, NULL, 0))

    {

      snprintf(buf, sizeof(buf), "%.*s", (int)value.len, value.ptr);

      return settings_value_as_bool(buf, def);

    }

  }

  return def;

}

METHOD(vici_message_t, get_bool, bool,

  private_vici_message_t *this, bool def, char *fmt, ...)

{

  va_list args;

  bool val;

  va_start(args, fmt);

  val = vget_bool(this, def, fmt, args);

  va_end(args);

  return val;

}

METHOD(vici_message_t, vget_value, chunk_t,

  private_vici_message_t *this, chunk_t def, char *fmt, va_list args)

{

  chunk_t value;

  bool found;

  found = find_value(this, &value, fmt, args);

  if (found)

  {

    return value;

  }

  return def;

}

METHOD(vici_message_t, get_value, chunk_t,

  private_vici_message_t *this, chunk_t def, char *fmt, ...)

{

  va_list args;

  chunk_t value;

  va_start(args, fmt);

  value = vget_value(this, def, fmt, args);

  va_end(args);

  return value;

}

METHOD(vici_message_t, get_encoding, chunk_t,

  private_vici_message_t *this)

{

  return this->encoding;

}

/**

 * Private parse context data

 */

struct vici_parse_context_t {

  /** current section nesting level */

  int level;

  /** parse enumerator */

  enumerator_t *e;

};

METHOD(vici_message_t, parse, bool,

  private_vici_message_t *this, vici_parse_context_t *ctx,

  vici_section_cb_t section, vici_value_cb_t kv, vici_value_cb_t li,

  void *user)

{

  vici_parse_context_t root = {};

  char *name, *list = NULL;

  vici_type_t type;

  chunk_t value;

  int base;

  bool ok = TRUE;

  if (!ctx)

  {

    ctx = &root;

    root.e = create_enumerator(this);

  }

  base = ctx->level;

  while (ok)

  {

    ok = ctx->e->enumerate(ctx->e, &type, &name, &value);

    if (ok)

    {

      switch (type)

      {

        case VICI_START:

          /* should never occur */

          continue;

        case VICI_KEY_VALUE:

          if (ctx->level == base && kv)

          {

            name = strdup(name);

            this->strings->insert_last(this->strings, name);

            ok = kv(user, &this->public, name, value);

          }

          continue;

        case VICI_LIST_START:

          if (ctx->level == base)

          {

            list = strdup(name);

            this->strings->insert_last(this->strings, list);

          }

          continue;

        case VICI_LIST_ITEM:

          if (list && li)

          {

            name = strdup(name);

            this->strings->insert_last(this->strings, name);

            ok = li(user, &this->public, list, value);

          }

          continue;

        case VICI_LIST_END:

          if (ctx->level == base)

          {

            list = NULL;

          }

          continue;

        case VICI_SECTION_START:

          if (ctx->level++ == base && section)

          {

            name = strdup(name);

            this->strings->insert_last(this->strings, name);

            ok = section(user, &this->public, ctx, name);

          }

          continue;

        case VICI_SECTION_END:

          if (ctx->level-- == base)

          {

            break;

          }

          continue;

        case VICI_END:

          break;

      }

    }

    break;

  }

  if (ctx == &root)

  {

    root.e->destroy(root.e);

  }

  return ok;

}

METHOD(vici_message_t, dump, bool,

  private_vici_message_t *this, char *label, bool pretty, FILE *out)

{

  enumerator_t *enumerator;

  int ident = 0, delta;

  vici_type_t type, last_type = VICI_START;

  char *name, *term, *sep, *separ, *assign;

  chunk_t value;

  /* pretty print uses indentation on multiple lines */

  if (pretty)

  {

    delta  = 2;

    term   = "\n";

    separ  = "";

    assign = " = ";

  }

  else

  {

    delta  = 0;

    term   = "";

    separ  = " ";

    assign = "=";

  }

  fprintf(out, "%s {%s", label, term);

  ident += delta;

  enumerator = create_enumerator(this);

  while (enumerator->enumerate(enumerator, &type, &name, &value))

  {

    switch (type)

    {

      case VICI_START:

        /* should never occur */

        break;

      case VICI_SECTION_START:

        sep = (last_type != VICI_SECTION_START &&

             last_type != VICI_START) ? separ : "";

        fprintf(out, "%*s%s%s {%s", ident, "", sep, name, term);

        ident += delta;

        break;

      case VICI_SECTION_END:

        ident -= delta;

        fprintf(out, "%*s}%s", ident, "", term);

        break;

      case VICI_KEY_VALUE:

        sep = (last_type != VICI_SECTION_START &&

             last_type != VICI_START) ? separ : "";

        if (chunk_printable(value, NULL, ' '))

        {

          fprintf(out, "%*s%s%s%s%.*s%s", ident, "", sep, name,

              assign, (int)value.len, value.ptr, term);

        }

        else

        {

          fprintf(out, "%*s%s%s%s0x%+#B%s", ident, "", sep, name,

              assign, &value, term);

        }

        break;

      case VICI_LIST_START:

        sep = (last_type != VICI_SECTION_START &&

             last_type != VICI_START) ? separ : "";

        fprintf(out, "%*s%s%s%s[%s", ident, "", sep, name, assign, term);

        ident += delta;

        break;

      case VICI_LIST_END:

        ident -= delta;

        fprintf(out, "%*s]%s", ident, "", term);

        break;

      case VICI_LIST_ITEM:

        sep = (last_type != VICI_LIST_START) ? separ : "";

        if (chunk_printable(value, NULL, ' '))

        {

          fprintf(out, "%*s%s%.*s%s", ident, "", sep,

              (int)value.len, value.ptr, term);

        }

        else

        {

          fprintf(out, "%*s%s0x%+#B%s", ident, "", sep,

              &value, term);

        }

        break;

      case VICI_END:

        fprintf(out, "}\n");

        enumerator->destroy(enumerator);

        return TRUE;

    }

    last_type = type;

  }

  enumerator->destroy(enumerator);

  return FALSE;

}

CALLBACK(clear_strings, void,

  char *str)

{

  memwipe(str, strlen(str));

  free(str);

}

METHOD(vici_message_t, destroy, void,

  private_vici_message_t *this)

{

  if (this->cleanup)

  {

    chunk_clear(&this->encoding);

  }

  this->strings->destroy_function(this->strings, clear_strings);

  free(this);

}

/**

 * See header

 */

vici_message_t *vici_message_create_from_data(chunk_t data, bool cleanup)

{

  private_vici_message_t *this;

  INIT(this,

    .public = {

      .create_enumerator = _create_enumerator,

      .get_str = _get_str,

      .vget_str = _vget_str,

      .get_int = _get_int,

      .vget_int = _vget_int,

      .get_bool = _get_bool,

      .vget_bool = _vget_bool,

      .get_value = _get_value,

      .vget_value = _vget_value,

      .get_encoding = _get_encoding,

      .parse = _parse,

      .dump = _dump,

      .destroy = _destroy,

    },

    .strings = linked_list_create(),

    .encoding = data,

    .cleanup = cleanup,

  );

  return &this->public;

}

/**

 * See header

 */

vici_message_t *vici_message_create_from_enumerator(enumerator_t *enumerator)

{

  vici_builder_t *builder;

  vici_type_t type;

  char *name;

  chunk_t value;

  builder = vici_builder_create();

  while (enumerator->enumerate(enumerator, &type, &name, &value))

  {

    switch (type)

    {

      case VICI_SECTION_START:

      case VICI_LIST_START:

        builder->add(builder, type, name);

        continue;

      case VICI_KEY_VALUE:

        builder->add(builder, type, name, value);

        continue;

      case VICI_LIST_ITEM:

        builder->add(builder, type, value);

        continue;

      case VICI_SECTION_END:

      case VICI_LIST_END:

      default:

        builder->add(builder, type);

        continue;

      case VICI_END:

        break;

    }

    break;

  }

  enumerator->destroy(enumerator);

  return builder->finalize(builder);

}

/**

 * See header

 */

vici_message_t *vici_message_create_from_args(vici_type_t type, ...)

{

  vici_builder_t *builder;

  va_list args;

  char *name;

  chunk_t value;

  builder = vici_builder_create();

  va_start(args, type);

  while (type != VICI_END)

  {

    switch (type)

    {

      case VICI_LIST_START:

      case VICI_SECTION_START:

        name = va_arg(args, char*);

        builder->add(builder, type, name);

        break;

      case VICI_KEY_VALUE:

        name = va_arg(args, char*);

        value = va_arg(args, chunk_t);

        builder->add(builder, type, name, value);

        break;

      case VICI_LIST_ITEM:

        value = va_arg(args, chunk_t);

        builder->add(builder, type, value);

        break;

      case VICI_SECTION_END:

      case VICI_LIST_END:

      default:

        builder->add(builder, type);

        break;

    }

    type = va_arg(args, vici_type_t);

  }

  va_end(args);

  return builder->finalize(builder);

}