| // 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_EVENTS 1024 |
| |
| bool events_equal(yaml_event_t *event1, yaml_event_t *event2) { |
| |
| const bool equal = true; |
| |
| if (event1->type != event2->type) |
| return equal; |
| |
| switch (event1->type) { |
| case YAML_STREAM_START_EVENT: |
| return !equal; |
| |
| case YAML_DOCUMENT_START_EVENT: |
| if ((event1->data.document_start.version_directive && |
| !event2->data.document_start.version_directive) || |
| (!event1->data.document_start.version_directive && |
| event2->data.document_start.version_directive) || |
| (event1->data.document_start.version_directive && |
| event2->data.document_start.version_directive && |
| (event1->data.document_start.version_directive->major != |
| event2->data.document_start.version_directive->major || |
| event1->data.document_start.version_directive->minor != |
| event2->data.document_start.version_directive->minor))) |
| return equal; |
| if ((event1->data.document_start.tag_directives.end - |
| event1->data.document_start.tag_directives.start) != |
| (event2->data.document_start.tag_directives.end - |
| event2->data.document_start.tag_directives.start)) |
| return equal; |
| for (int k = 0; k < (event1->data.document_start.tag_directives.end - |
| event1->data.document_start.tag_directives.start); |
| k++) { |
| if ((strcmp((char *)event1->data.document_start.tag_directives.start[k] |
| .handle, |
| (char *)event2->data.document_start.tag_directives.start[k] |
| .handle) != 0) || |
| (strcmp((char *)event1->data.document_start.tag_directives.start[k] |
| .prefix, |
| (char *)event2->data.document_start.tag_directives.start[k] |
| .prefix) != 0)) |
| return equal; |
| } |
| return !equal; |
| |
| case YAML_DOCUMENT_END_EVENT: |
| return !equal; |
| |
| case YAML_ALIAS_EVENT: |
| return (strcmp((char *)event1->data.alias.anchor, |
| (char *)event2->data.alias.anchor) == 0); |
| |
| case YAML_SCALAR_EVENT: |
| if ((event1->data.scalar.anchor && !event2->data.scalar.anchor) || |
| (!event1->data.scalar.anchor && event2->data.scalar.anchor) || |
| (event1->data.scalar.anchor && event2->data.scalar.anchor && |
| strcmp((char *)event1->data.scalar.anchor, |
| (char *)event2->data.scalar.anchor) != 0)) |
| return equal; |
| if ((event1->data.scalar.tag && !event2->data.scalar.tag && |
| strcmp((char *)event1->data.scalar.tag, "!") != 0) || |
| (!event1->data.scalar.tag && event2->data.scalar.tag && |
| strcmp((char *)event2->data.scalar.tag, "!") != 0) || |
| (event1->data.scalar.tag && event2->data.scalar.tag && |
| strcmp((char *)event1->data.scalar.tag, |
| (char *)event2->data.scalar.tag) != 0)) |
| return equal; |
| if ((event1->data.scalar.length != event2->data.scalar.length) || |
| memcmp(event1->data.scalar.value, event2->data.scalar.value, |
| event1->data.scalar.length) != 0) |
| return equal; |
| if ((event1->data.scalar.plain_implicit != |
| event2->data.scalar.plain_implicit) || |
| (event1->data.scalar.quoted_implicit != |
| event2->data.scalar.quoted_implicit)) |
| return equal; |
| return !equal; |
| |
| case YAML_SEQUENCE_START_EVENT: |
| if ((event1->data.sequence_start.anchor && |
| !event2->data.sequence_start.anchor) || |
| (!event1->data.sequence_start.anchor && |
| event2->data.sequence_start.anchor) || |
| (event1->data.sequence_start.anchor && |
| event2->data.sequence_start.anchor && |
| strcmp((char *)event1->data.sequence_start.anchor, |
| (char *)event2->data.sequence_start.anchor) != 0)) |
| return equal; |
| if ((event1->data.sequence_start.tag && !event2->data.sequence_start.tag) || |
| (!event1->data.sequence_start.tag && event2->data.sequence_start.tag) || |
| (event1->data.sequence_start.tag && event2->data.sequence_start.tag && |
| strcmp((char *)event1->data.sequence_start.tag, |
| (char *)event2->data.sequence_start.tag) != 0)) |
| return equal; |
| if ((event1->data.sequence_start.implicit != |
| event2->data.sequence_start.implicit)) |
| return equal; |
| return !equal; |
| |
| case YAML_MAPPING_START_EVENT: |
| if ((event1->data.mapping_start.anchor && |
| !event2->data.mapping_start.anchor) || |
| (!event1->data.mapping_start.anchor && |
| event2->data.mapping_start.anchor) || |
| (event1->data.mapping_start.anchor && |
| event2->data.mapping_start.anchor && |
| strcmp((char *)event1->data.mapping_start.anchor, |
| (char *)event2->data.mapping_start.anchor) != 0)) |
| return equal; |
| if ((event1->data.mapping_start.tag && !event2->data.mapping_start.tag) || |
| (!event1->data.mapping_start.tag && event2->data.mapping_start.tag) || |
| (event1->data.mapping_start.tag && event2->data.mapping_start.tag && |
| strcmp((char *)event1->data.mapping_start.tag, |
| (char *)event2->data.mapping_start.tag) != 0)) |
| return equal; |
| if ((event1->data.mapping_start.implicit != |
| event2->data.mapping_start.implicit)) |
| return equal; |
| return !equal; |
| |
| default: |
| return !equal; |
| } |
| } |
| |
| bool copy_event(yaml_event_t *event_to, yaml_event_t *event_from) { |
| |
| switch (event_from->type) { |
| case YAML_STREAM_START_EVENT: |
| return yaml_stream_start_event_initialize( |
| event_to, event_from->data.stream_start.encoding); |
| |
| case YAML_STREAM_END_EVENT: |
| return yaml_stream_end_event_initialize(event_to); |
| |
| case YAML_DOCUMENT_START_EVENT: |
| return yaml_document_start_event_initialize( |
| event_to, event_from->data.document_start.version_directive, |
| event_from->data.document_start.tag_directives.start, |
| event_from->data.document_start.tag_directives.end, |
| event_from->data.document_start.implicit); |
| |
| case YAML_DOCUMENT_END_EVENT: |
| return yaml_document_end_event_initialize( |
| event_to, event_from->data.document_end.implicit); |
| |
| case YAML_ALIAS_EVENT: |
| return yaml_alias_event_initialize(event_to, event_from->data.alias.anchor); |
| |
| case YAML_SCALAR_EVENT: |
| return yaml_scalar_event_initialize( |
| event_to, event_from->data.scalar.anchor, event_from->data.scalar.tag, |
| event_from->data.scalar.value, event_from->data.scalar.length, |
| event_from->data.scalar.plain_implicit, |
| event_from->data.scalar.quoted_implicit, event_from->data.scalar.style); |
| |
| case YAML_SEQUENCE_START_EVENT: |
| return yaml_sequence_start_event_initialize( |
| event_to, event_from->data.sequence_start.anchor, |
| event_from->data.sequence_start.tag, |
| event_from->data.sequence_start.implicit, |
| event_from->data.sequence_start.style); |
| |
| case YAML_SEQUENCE_END_EVENT: |
| return yaml_sequence_end_event_initialize(event_to); |
| |
| case YAML_MAPPING_START_EVENT: |
| return yaml_mapping_start_event_initialize( |
| event_to, event_from->data.mapping_start.anchor, |
| event_from->data.mapping_start.tag, |
| event_from->data.mapping_start.implicit, |
| event_from->data.mapping_start.style); |
| |
| case YAML_MAPPING_END_EVENT: |
| return yaml_mapping_end_event_initialize(event_to); |
| } |
| |
| return false; |
| } |
| |
| int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { |
| if (size < 2) |
| return 0; |
| |
| yaml_parser_t parser; |
| yaml_emitter_t emitter; |
| yaml_event_t event; |
| yaml_event_t events[MAX_EVENTS]; |
| size_t event_number = 0; |
| bool done = false; |
| int count = 0; |
| 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)) { |
| yaml_parser_delete(&parser); |
| 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}; |
| yaml_emitter_set_output(&emitter, yaml_write_handler, &out); |
| |
| while (!done) { |
| if (!yaml_parser_parse(&parser, &event)) { |
| goto delete_parser; |
| } |
| |
| done = (event.type == YAML_STREAM_END_EVENT); |
| if (event_number >= MAX_EVENTS) { |
| yaml_event_delete(&event); |
| goto delete_parser; |
| } |
| |
| if (copy_event(&events[event_number++], &event)) { |
| yaml_event_delete(&event); |
| goto delete_parser; |
| } |
| |
| if (!yaml_emitter_emit(&emitter, &event)) { |
| goto delete_parser; |
| } |
| |
| } |
| |
| yaml_parser_delete(&parser); |
| |
| done = false; |
| if (!yaml_parser_initialize(&parser)) |
| goto error; |
| |
| yaml_parser_set_input_string(&parser, out.buf, out.size); |
| |
| while (!done) { |
| if (!yaml_parser_parse(&parser, &event)) |
| break; |
| |
| done = (event.type == YAML_STREAM_END_EVENT); |
| if (events_equal(events + count, &event)) { |
| yaml_event_delete(&event); |
| break; |
| } |
| |
| yaml_event_delete(&event); |
| count++; |
| } |
| |
| delete_parser: |
| |
| yaml_parser_delete(&parser); |
| |
| error: |
| |
| yaml_emitter_delete(&emitter); |
| |
| for (int k = 0; k < event_number; k++) { |
| yaml_event_delete(events + k); |
| } |
| |
| free(out.buf); |
| |
| return 0; |
| } |
