// Copyright 2020 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include "yaml.h"

#include "yaml_write_handler.h"

#include <assert.h>

#include <stdbool.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef NDEBUG

#undef NDEBUG

#endif

#define MAX_DOCUMENTS 16

bool nodes_equal(yaml_document_t *document1, int index1,

                 yaml_document_t *document2, int index2, int level) {

  const bool equal = true;

  if (level++ > 1000)

    return !equal;

  yaml_node_t *node1 = yaml_document_get_node(document1, index1);

  if (!node1)

    return !equal;

  yaml_node_t *node2 = yaml_document_get_node(document2, index2);

  if (!node2)

    return !equal;

  if (node1->type != node2->type)

    return !equal;

  if (strcmp((char *)node1->tag, (char *)node2->tag) != 0)

    return !equal;

  switch (node1->type) {

  case YAML_SCALAR_NODE:

    if (node1->data.scalar.length != node2->data.scalar.length)

      return !equal;

    if (strncmp((char *)node1->data.scalar.value,

                (char *)node2->data.scalar.value,

                node1->data.scalar.length) != 0)

      return !equal;

    break;

  case YAML_SEQUENCE_NODE:

    if ((node1->data.sequence.items.top - node1->data.sequence.items.start) !=

        (node2->data.sequence.items.top - node2->data.sequence.items.start))

      return !equal;

    for (int k = 0; k < (node1->data.sequence.items.top -

                         node1->data.sequence.items.start);

         k++) {

      if (!nodes_equal(document1, node1->data.sequence.items.start[k],

                       document2, node2->data.sequence.items.start[k], level))

        return !equal;

    }

    break;

  case YAML_MAPPING_NODE:

    if ((node1->data.mapping.pairs.top - node1->data.mapping.pairs.start) !=

        (node2->data.mapping.pairs.top - node2->data.mapping.pairs.start))

      return !equal;

    for (int k = 0;

         k < (node1->data.mapping.pairs.top - node1->data.mapping.pairs.start);

         k++) {

      if (!nodes_equal(document1, node1->data.mapping.pairs.start[k].key,

                       document2, node2->data.mapping.pairs.start[k].key,

                       level))

        return !equal;

      if (!nodes_equal(document1, node1->data.mapping.pairs.start[k].value,

                       document2, node2->data.mapping.pairs.start[k].value,

                       level))

        return !equal;

    }

    break;

  default:

    return !equal;

  }

  return equal;

}

bool documents_equal(yaml_document_t *document1, yaml_document_t *document2) {

  const bool equal = true;

  if ((document1->version_directive && !document2->version_directive) ||

      (!document1->version_directive && document2->version_directive) ||

      (document1->version_directive && document2->version_directive &&

       (document1->version_directive->major !=

            document2->version_directive->major ||

        document1->version_directive->minor !=

            document2->version_directive->minor)))

    return !equal;

  if ((document1->tag_directives.end - document1->tag_directives.start) !=

      (document2->tag_directives.end - document2->tag_directives.start))

    return !equal;

  for (int k = 0;

       k < (document1->tag_directives.end - document1->tag_directives.start);

       k++) {

    if ((strcmp((char *)document1->tag_directives.start[k].handle,

                (char *)document2->tag_directives.start[k].handle) != 0) ||

        (strcmp((char *)document1->tag_directives.start[k].prefix,

                (char *)document2->tag_directives.start[k].prefix) != 0))

      return !equal;

  }

  if ((document1->nodes.top - document1->nodes.start) !=

      (document2->nodes.top - document2->nodes.start))

    return !equal;

  if (document1->nodes.top != document1->nodes.start) {

    if (!nodes_equal(document1, 1, document2, 1, 0))

      return !equal;

  }

  return equal;

}

bool copy_document(yaml_document_t *document_to,

                   yaml_document_t *document_from) {

  bool error = true;

  yaml_node_t *node;

  yaml_node_item_t *item;

  yaml_node_pair_t *pair;

  if (!yaml_document_initialize(document_to, document_from->version_directive,

                                document_from->tag_directives.start,

                                document_from->tag_directives.end,

                                document_from->start_implicit,

                                document_from->end_implicit))

    return !error;

  for (node = document_from->nodes.start; node < document_from->nodes.top;

       node++) {

    switch (node->type) {

    case YAML_SCALAR_NODE:

      if (!yaml_document_add_scalar(

              document_to, node->tag, node->data.scalar.value,

              node->data.scalar.length, node->data.scalar.style))

        goto out;

      break;

    case YAML_SEQUENCE_NODE:

      if (!yaml_document_add_sequence(document_to, node->tag,

                                      node->data.sequence.style))

        goto out;

      break;

    case YAML_MAPPING_NODE:

      if (!yaml_document_add_mapping(document_to, node->tag,

                                     node->data.mapping.style))

        goto out;

      break;

    default:

      goto out;

    }

  }

  for (node = document_from->nodes.start; node < document_from->nodes.top;

       node++) {

    switch (node->type) {

    case YAML_SEQUENCE_NODE:

      for (item = node->data.sequence.items.start;

           item < node->data.sequence.items.top; item++) {

        if (!yaml_document_append_sequence_item(

                document_to, node - document_from->nodes.start + 1, *item))

          goto out;

      }

      break;

    case YAML_MAPPING_NODE:

      for (pair = node->data.mapping.pairs.start;

           pair < node->data.mapping.pairs.top; pair++) {

        if (!yaml_document_append_mapping_pair(

                document_to, node - document_from->nodes.start + 1, pair->key,

                pair->value))

          goto out;

      }

      break;

    default:

      break;

    }

  }

  return error;

out:

  yaml_document_delete(document_to);

  return !error;

}

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

  if (size < 2)

    return 0;

  yaml_parser_t parser;

  yaml_emitter_t emitter;

  yaml_document_t document;

  yaml_document_t documents[MAX_DOCUMENTS];

  size_t document_number = 0;

  int count = 0;

  bool done = false;

  bool equal = false;

  bool is_canonical = data[0] & 1;

  bool is_unicode = data[1] & 1;

  data += 2;

  size -= 2;

  if (!yaml_parser_initialize(&parser))

    return 0;

  yaml_parser_set_input_string(&parser, data, size);

  if (!yaml_emitter_initialize(&emitter))

    return 0;

  yaml_emitter_set_canonical(&emitter, is_canonical);

  yaml_emitter_set_unicode(&emitter, is_unicode);

  yaml_output_buffer_t out = {/*buf=*/NULL, /*size=*/0, /*capacity=*/1000};

  yaml_emitter_set_output(&emitter, yaml_write_handler, &out);

  yaml_emitter_open(&emitter);

  while (!done) {

    if (!yaml_parser_load(&parser, &document)) {

      equal = 1;

      break;

    }

    done = (!yaml_document_get_root_node(&document));

    if (!done) {

      if (document_number >= MAX_DOCUMENTS) {

        yaml_document_delete(&document);

        equal = true;

        break;

      }

      if (!copy_document(&documents[document_number++], &document)) {

        yaml_document_delete(&document);

        equal = true;

        break;

      }

      if (!(yaml_emitter_dump(&emitter, &document) ||

            (yaml_emitter_flush(&emitter) && 0))) {

        equal = true;

        break;

      }

      count++;

    } else {

      yaml_document_delete(&document);

    }

  }

  yaml_parser_delete(&parser);

  yaml_emitter_close(&emitter);

  yaml_emitter_delete(&emitter);

  if (!equal) {

    count = 0;

    done = false;

    if (!yaml_parser_initialize(&parser))

      goto error;

    if (!out.buf) {

      yaml_parser_delete(&parser);

      goto error;

    }

    yaml_parser_set_input_string(&parser, out.buf, out.size);

    while (!done) {

      if (!yaml_parser_load(&parser, &document)) {

        yaml_parser_delete(&parser);

        goto error;

      }

      done = (!yaml_document_get_root_node(&document));

      if (!done) {

        if (!documents_equal(documents + count, &document)) {

          yaml_parser_delete(&parser);

          yaml_document_delete(&document);

          goto error;

        }

        count++;

      }

      yaml_document_delete(&document);

    }

    yaml_parser_delete(&parser);

  }

error:

  for (int k = 0; k < document_number; k++) {

    yaml_document_delete(documents + k);

  }

  free(out.buf);

  return 0;

}