Greenbone Vulnerability Management Libraries 22.26.0
jsonpull.c
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Greenbone AG
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 */
5
6#include "jsonpull.h"
7
8#include <assert.h>
9
10#define GVM_JSON_CHAR_EOF -1
11#define GVM_JSON_CHAR_ERROR -2
12#define GVM_JSON_CHAR_UNDEFINED -3
13
24 int depth)
25{
26 gvm_json_path_elem_t *new_elem = g_malloc0 (sizeof (gvm_json_path_elem_t));
27 new_elem->parent_type = parent_type;
28 new_elem->depth = depth;
29 return new_elem;
30}
31
37void
39{
40 g_free (elem->key);
41 g_free (elem);
42}
43
49void
51{
52 memset (event, 0, sizeof (gvm_json_pull_event_t));
53}
54
60void
62{
63 cJSON_Delete (event->value);
64 if (event->error_message)
65 g_free (event->error_message);
66 memset (event, 0, sizeof (gvm_json_pull_event_t));
67}
68
77void
79 FILE *input_stream, size_t parse_buffer_limit,
80 size_t read_buffer_size)
81{
82 assert (parser);
83 assert (input_stream);
84 memset (parser, 0, sizeof (gvm_json_pull_parser_t));
85
86 if (parse_buffer_limit <= 0)
87 parse_buffer_limit = GVM_JSON_PULL_PARSE_BUFFER_LIMIT;
88
89 if (read_buffer_size <= 0)
90 read_buffer_size = GVM_JSON_PULL_READ_BUFFER_SIZE;
91
92 parser->input_stream = input_stream;
93 parser->path = g_queue_new ();
95 parser->parse_buffer_limit = parse_buffer_limit;
96 parser->parse_buffer = g_string_new ("");
97 parser->read_buffer_size = read_buffer_size;
98 parser->read_buffer = g_malloc0 (read_buffer_size);
100}
101
108void
110{
111 gvm_json_pull_parser_init_full (parser, input_stream, 0, 0);
112}
113
119void
121{
122 assert (parser);
123 g_queue_free_full (parser->path,
124 (GDestroyNotify) gvm_json_pull_path_elem_free);
125 g_string_free (parser->parse_buffer, TRUE);
126 g_free (parser->read_buffer);
127 memset (parser, 0, sizeof (gvm_json_pull_parser_t));
128}
129
135static gchar *
137{
138 return g_strdup_printf ("error reading JSON stream: %s", strerror (errno));
139}
140
150static int
154{
155 if (parser->parse_buffer->len >= parser->parse_buffer_limit)
156 {
157 event->error_message =
158 g_strdup_printf ("%s exceeds size limit of %zu bytes", value_type,
159 parser->parse_buffer_limit);
160 event->type = GVM_JSON_PULL_EVENT_ERROR;
161 return 1;
162 }
163 return 0;
164}
165
173static int
175{
176 parser->read_pos++;
177 if (parser->read_pos < parser->last_read_size)
178 {
179 parser->last_read_char =
180 (unsigned char) parser->read_buffer[parser->read_pos];
181 return parser->last_read_char;
182 }
183 else
184 {
185 parser->read_pos = 0;
186 parser->last_read_size = fread (
187 parser->read_buffer, 1, parser->read_buffer_size, parser->input_stream);
188 if (ferror (parser->input_stream))
190 else if (parser->last_read_size <= 0)
192 else
193 parser->last_read_char =
194 (unsigned char) parser->read_buffer[parser->read_pos];
195 return parser->last_read_char;
196 }
197}
198
210static int
213 const char *value_name,
214 cJSON_bool (*validate_func) (const cJSON *const),
215 cJSON **cjson_value)
216{
217 cJSON *parsed_value = cJSON_Parse (parser->parse_buffer->str);
218 *cjson_value = NULL;
219 if (validate_func (parsed_value) == 0)
220 {
221 event->type = GVM_JSON_PULL_EVENT_ERROR;
222 event->error_message = g_strdup_printf ("error parsing %s", value_name);
223 cJSON_free (parsed_value);
224 return 1;
225 }
226 *cjson_value = parsed_value;
227 return 0;
228}
229
237static void
239 gvm_json_pull_event_t *event, gboolean allow_eof)
240{
241 if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
242 {
243 event->error_message = gvm_json_read_stream_error_str ();
244 event->type = GVM_JSON_PULL_EVENT_ERROR;
245 }
246 else if (allow_eof)
247 event->type = GVM_JSON_PULL_EVENT_EOF;
248 else
249 {
250 event->error_message = g_strdup ("unexpected EOF");
251 event->type = GVM_JSON_PULL_EVENT_ERROR;
252 }
253}
254
266static int
268 gvm_json_pull_event_t *event, gboolean allow_eof)
269{
270 while (g_ascii_isspace (parser->last_read_char))
272 if (parser->last_read_char < 0)
273 {
274 gvm_json_pull_handle_read_end (parser, event, allow_eof);
275 return 1;
276 }
277 return 0;
278}
279
292static int
294 gvm_json_pull_event_t *event, cJSON **cjson_value)
295{
296 gboolean escape_next_char = FALSE;
297 g_string_truncate (parser->parse_buffer, 0);
298 g_string_append_c (parser->parse_buffer, '"');
299 while (gvm_json_pull_parser_next_char (parser) >= 0)
300 {
301 if (gvm_json_pull_check_parse_buffer_size ("string", parser, event))
302 return 1;
303 g_string_append_c (parser->parse_buffer, parser->last_read_char);
304 if (escape_next_char)
305 escape_next_char = FALSE;
306 else if (parser->last_read_char == '\\')
307 escape_next_char = TRUE;
308 else if (parser->last_read_char == '"')
309 break;
310 }
311
312 if (parser->last_read_char < 0)
313 {
314 gvm_json_pull_handle_read_end (parser, event, FALSE);
315 return 1;
316 }
317
319
320 return gvm_json_pull_parse_buffered (parser, event, "string", cJSON_IsString,
321 cjson_value);
322}
323
336static int
338 gvm_json_pull_event_t *event, cJSON **cjson_value)
339{
340 g_string_truncate (parser->parse_buffer, 0);
341 g_string_append_c (parser->parse_buffer, parser->last_read_char);
342 while (gvm_json_pull_parser_next_char (parser) >= 0)
343 {
344 if (gvm_json_pull_check_parse_buffer_size ("number", parser, event))
345 return 1;
346 if (g_ascii_isdigit (parser->last_read_char)
347 || parser->last_read_char == '.' || parser->last_read_char == 'e'
348 || parser->last_read_char == '-' || parser->last_read_char == '+')
349 g_string_append_c (parser->parse_buffer, parser->last_read_char);
350 else
351 break;
352 }
353
354 if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
355 {
356 event->error_message = gvm_json_read_stream_error_str ();
357 event->type = GVM_JSON_PULL_EVENT_ERROR;
358 return 1;
359 }
360
361 return gvm_json_pull_parse_buffered (parser, event, "number", cJSON_IsNumber,
362 cjson_value);
363}
364
377static int
379 gvm_json_pull_event_t *event, const char *keyword)
380{
381 for (size_t i = 0; i < strlen (keyword); i++)
382 {
383 if (parser->last_read_char < 0)
384 {
385 gvm_json_pull_handle_read_end (parser, event, FALSE);
386 return 1;
387 }
388 else if (parser->last_read_char != keyword[i])
389 {
390 event->type = GVM_JSON_PULL_EVENT_ERROR;
391 event->error_message =
392 g_strdup_printf ("misspelled keyword '%s'", keyword);
393 return 1;
394 }
396 }
397 return 0;
398}
399
405static void
407{
408 if (parser->path->length)
410 else
412}
413
425static int
428{
429 if (gvm_json_pull_skip_space (parser, event, FALSE))
430 return 1;
431
432 cJSON *key_cjson = NULL;
433 gchar *key_str;
434 gvm_json_path_elem_t *path_elem;
435
436 switch (parser->last_read_char)
437 {
438 case '"':
439 if (gvm_json_pull_parse_string (parser, event, &key_cjson))
440 return 1;
441 key_str = g_strdup (key_cjson->valuestring);
442 cJSON_Delete (key_cjson);
443
444 // Expect colon:
445 if (gvm_json_pull_skip_space (parser, event, FALSE))
446 {
447 g_free (key_str);
448 return 1;
449 }
450 if (parser->last_read_char != ':')
451 {
452 event->type = GVM_JSON_PULL_EVENT_ERROR;
453 event->error_message = g_strdup_printf ("expected colon");
454 g_free (key_str);
455 return 1;
456 }
458
459 path_elem = g_queue_peek_tail (parser->path);
460 g_free (path_elem->key);
461 path_elem->key = key_str;
463
464 break;
465 case '}':
466 event->type = GVM_JSON_PULL_EVENT_OBJECT_END;
467 event->value = NULL;
468 gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
471 break;
472 case ']':
473 event->type = GVM_JSON_PULL_EVENT_ERROR;
474 event->error_message = g_strdup ("unexpected closing square bracket");
475 return 1;
476 default:
477 event->type = GVM_JSON_PULL_EVENT_ERROR;
478 event->error_message = g_strdup ("unexpected character");
479 return 1;
480 }
481
482 return 0;
483}
484
496static int
499{
500 if (gvm_json_pull_skip_space (parser, event, FALSE))
501 return 1;
502
503 gvm_json_path_elem_t *path_elem = NULL;
504 switch (parser->last_read_char)
505 {
506 case ',':
507 path_elem = g_queue_peek_tail (parser->path);
508 path_elem->index++;
511 else
514 break;
515 case ']':
516 path_elem = g_queue_peek_tail (parser->path);
517 if (path_elem == NULL
519 {
520 event->type = GVM_JSON_PULL_EVENT_ERROR;
521 event->error_message = g_strdup ("unexpected closing square bracket");
522 return 1;
523 }
524 event->type = GVM_JSON_PULL_EVENT_ARRAY_END;
525 event->value = NULL;
526 gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
529 break;
530 case '}':
531 path_elem = g_queue_peek_tail (parser->path);
532 if (path_elem == NULL
534 {
535 event->type = GVM_JSON_PULL_EVENT_ERROR;
536 event->error_message = g_strdup ("unexpected closing curly brace");
537 return 1;
538 }
539 event->type = GVM_JSON_PULL_EVENT_OBJECT_END;
540 event->value = NULL;
541 gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
544 break;
545 default:
546 event->error_message = g_strdup ("expected comma or end of container");
547 event->type = GVM_JSON_PULL_EVENT_ERROR;
548 return 1;
549 }
550 return 0;
551}
552
564static int
567{
568 if (gvm_json_pull_skip_space (parser, event, FALSE))
569 return 1;
570
571 cJSON *cjson_value = NULL;
572 gvm_json_path_elem_t *path_elem = NULL;
573
574 switch (parser->last_read_char)
575 {
576 case '"':
577 if (gvm_json_pull_parse_string (parser, event, &cjson_value))
578 return 1;
579 event->type = GVM_JSON_PULL_EVENT_STRING;
580 event->value = cjson_value;
582 break;
583 case 'n':
584 if (gvm_json_pull_parse_keyword (parser, event, "null"))
585 return 1;
586 event->type = GVM_JSON_PULL_EVENT_NULL;
587 event->value = cJSON_CreateNull ();
589 break;
590 case 'f':
591 if (gvm_json_pull_parse_keyword (parser, event, "false"))
592 return 1;
593 event->type = GVM_JSON_PULL_EVENT_BOOLEAN;
594 event->value = cJSON_CreateFalse ();
596 break;
597 case 't':
598 if (gvm_json_pull_parse_keyword (parser, event, "true"))
599 return 1;
600 event->type = GVM_JSON_PULL_EVENT_BOOLEAN;
601 event->value = cJSON_CreateTrue ();
603 break;
604 case '[':
606 event->value = NULL;
608 GVM_JSON_PULL_CONTAINER_ARRAY, parser->path->length);
611 break;
612 case ']':
613 path_elem = g_queue_peek_tail (parser->path);
614 if (path_elem == NULL
616 {
617 event->type = GVM_JSON_PULL_EVENT_ERROR;
618 event->error_message = g_strdup ("unexpected closing square bracket");
619 return 1;
620 }
621 event->type = GVM_JSON_PULL_EVENT_ARRAY_END;
622 event->value = NULL;
623 gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
626 break;
627 case '{':
629 event->value = NULL;
631 GVM_JSON_PULL_CONTAINER_OBJECT, parser->path->length);
634 break;
635 case '}':
636 event->type = GVM_JSON_PULL_EVENT_ERROR;
637 event->error_message = g_strdup ("unexpected closing curly brace");
638 return 1;
639 break;
640 default:
641 if (g_ascii_isdigit (parser->last_read_char)
642 || parser->last_read_char == '-')
643 {
644 if (gvm_json_pull_parse_number (parser, event, &cjson_value))
645 return 1;
646 event->type = GVM_JSON_PULL_EVENT_NUMBER;
647 event->value = cjson_value;
649 }
650 else
651 {
652 event->type = GVM_JSON_PULL_EVENT_ERROR;
653 event->error_message = g_strdup ("unexpected character");
654 return 1;
655 }
656 }
657 return 0;
658}
659
668void
671{
672 assert (parser);
673 assert (event);
674
677 {
678 // Handle first read of the stream
679 if (gvm_json_pull_parser_next_char (parser) < 0)
680 {
681 gvm_json_pull_handle_read_end (parser, event, TRUE);
682 return;
683 }
684 }
685
686 event->path = parser->path;
687
688 // Delayed addition to path after a container start element
689 if (parser->path_add)
690 {
691 g_queue_push_tail (parser->path, parser->path_add);
692 parser->path_add = NULL;
693 }
694
695 // Check for expected end of file
696 if (parser->expect == GVM_JSON_PULL_EXPECT_EOF)
697 {
698 if (gvm_json_pull_skip_space (parser, event, TRUE))
699 {
700 // EOF was reached, or an error occurred.
701 // The event type is already set, and if an error occurred, then
702 // error_message is also already set.
703 return;
704 }
705
706 // Skipping space succeeded. Check for unexpected characters at EOF.
707
708 if (parser->last_read_char == GVM_JSON_CHAR_EOF)
709 return;
710
711 event->type = GVM_JSON_PULL_EVENT_ERROR;
712 event->error_message = g_strdup_printf (
713 "unexpected character at end of file (%d)", parser->last_read_char);
714 return;
715 }
716
717 if (parser->expect == GVM_JSON_PULL_EXPECT_COMMA)
718 {
719 if (gvm_json_pull_parse_comma (parser, event))
720 return;
721 }
722
723 if (parser->expect == GVM_JSON_PULL_EXPECT_KEY)
724 {
725 if (gvm_json_pull_parse_key (parser, event))
726 return;
727 }
728
729 if (parser->expect == GVM_JSON_PULL_EXPECT_VALUE)
730 {
731 gvm_json_pull_parse_value (parser, event);
732 }
733}
734
745cJSON *
747 gchar **error_message)
748{
749 gvm_json_path_elem_t *path_tail = NULL;
750
751 int start_depth;
752 gboolean in_string, escape_next_char, in_expanded_container;
753 cJSON *expanded;
754
755 g_string_truncate (parser->parse_buffer, 0);
756
757 if (error_message)
758 *error_message = NULL;
759
760 // require "path_add" to only allow expansion at start of container
761 if (parser->path_add)
762 {
763 path_tail = parser->path_add;
764 g_queue_push_tail (parser->path, path_tail);
765 parser->path_add = NULL;
766 }
767
768 if (path_tail && path_tail->parent_type == GVM_JSON_PULL_CONTAINER_ARRAY)
769 g_string_append_c (parser->parse_buffer, '[');
770 else if (path_tail
772 g_string_append_c (parser->parse_buffer, '{');
773 else
774 {
775 if (error_message)
776 *error_message =
777 g_strdup ("can only expand after array or object start");
778 return NULL;
779 }
780
781 start_depth = path_tail->depth;
782 in_string = escape_next_char = FALSE;
783 in_expanded_container = TRUE;
784
785 while (parser->last_read_char >= 0 && in_expanded_container)
786 {
787 if (parser->parse_buffer->len >= parser->parse_buffer_limit)
788 {
789 if (error_message)
790 *error_message =
791 g_strdup_printf ("container exceeds size limit of %zu bytes",
792 parser->parse_buffer_limit);
793 return NULL;
794 }
795
796 g_string_append_c (parser->parse_buffer, parser->last_read_char);
797
798 if (escape_next_char)
799 {
800 escape_next_char = FALSE;
801 }
802 else if (in_string)
803 {
804 escape_next_char = (parser->last_read_char == '\\');
805 in_string = (parser->last_read_char != '"');
806 }
807 else
808 {
809 switch (parser->last_read_char)
810 {
811 case '"':
812 in_string = TRUE;
813 break;
814 case '[':
815 path_tail = gvm_json_pull_path_elem_new (
816 GVM_JSON_PULL_CONTAINER_ARRAY, parser->path->length);
817 g_queue_push_tail (parser->path, path_tail);
818 break;
819 case '{':
820 path_tail = gvm_json_pull_path_elem_new (
821 GVM_JSON_PULL_CONTAINER_OBJECT, parser->path->length);
822 g_queue_push_tail (parser->path, path_tail);
823 break;
824 case ']':
825 path_tail = g_queue_pop_tail (parser->path);
827 {
828 if (error_message)
829 *error_message =
830 g_strdup ("unexpected closing square bracket");
832 return NULL;
833 }
834 if (path_tail->depth == start_depth)
835 in_expanded_container = FALSE;
836
838 break;
839 case '}':
840 path_tail = g_queue_pop_tail (parser->path);
842 {
843 if (error_message)
844 *error_message =
845 g_strdup ("unexpected closing curly brace");
847 return NULL;
848 }
849 if (path_tail->depth == start_depth)
850 in_expanded_container = FALSE;
851
853 break;
854 }
855 }
857 }
858
859 if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
860 {
861 if (error_message)
862 *error_message = gvm_json_read_stream_error_str ();
863 return NULL;
864 }
865 else if (in_expanded_container && parser->last_read_char == GVM_JSON_CHAR_EOF)
866 {
867 if (error_message)
868 *error_message = g_strdup ("unexpected EOF");
869 return NULL;
870 }
871
872 expanded = cJSON_Parse (parser->parse_buffer->str);
873 g_string_truncate (parser->parse_buffer, 0);
875
876 if (expanded == NULL && error_message)
877 *error_message = g_strdup ("could not parse expanded container");
878
879 return expanded;
880}
881
888static void
890 GString *path_string)
891{
893 {
894 gchar *escaped_key = gvm_json_string_escape (path_elem->key, TRUE);
895 g_string_append_printf (path_string, "['%s']", escaped_key);
896 g_free (escaped_key);
897 }
898 else
899 g_string_append_printf (path_string, "[%d]", path_elem->index);
900}
901
909gchar *
911{
912 GString *path_string = g_string_new ("$");
913 g_queue_foreach (path, (GFunc) gvm_json_path_string_add_elem, path_string);
914 return g_string_free (path_string, FALSE);
915}
gchar * gvm_json_string_escape(const char *string, gboolean single_quote)
Escapes a string according to the JSON or JSONPath standard.
Definition json.c:17
static int gvm_json_pull_parse_number(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event, cJSON **cjson_value)
Parses a number in a JSON pull parser.
Definition jsonpull.c:337
void gvm_json_pull_parser_cleanup(gvm_json_pull_parser_t *parser)
Frees the data of a JSON pull parser.
Definition jsonpull.c:120
void gvm_json_pull_parser_init_full(gvm_json_pull_parser_t *parser, FILE *input_stream, size_t parse_buffer_limit, size_t read_buffer_size)
Initializes a JSON pull parser.
Definition jsonpull.c:78
static int gvm_json_pull_parse_string(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event, cJSON **cjson_value)
Parses a string in a JSON pull parser.
Definition jsonpull.c:293
static int gvm_json_pull_skip_space(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event, gboolean allow_eof)
Skips whitespaces in the input stream of a JSON pull parser.
Definition jsonpull.c:267
static int gvm_json_pull_parse_comma(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event)
Handles the case that a comma is expected in a JSON pull parser.
Definition jsonpull.c:497
static int gvm_json_pull_parser_next_char(gvm_json_pull_parser_t *parser)
Reads the next character in a pull parser input stream.
Definition jsonpull.c:174
void gvm_json_pull_event_cleanup(gvm_json_pull_event_t *event)
Frees all data of JSON pull event data structure.
Definition jsonpull.c:61
static int gvm_json_pull_parse_value(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event)
Handles the case that a value is expected in a JSON pull parser.
Definition jsonpull.c:565
void gvm_json_pull_parser_next(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event)
Get the next event from a JSON pull parser.
Definition jsonpull.c:669
#define GVM_JSON_CHAR_UNDEFINED
Undefined state.
Definition jsonpull.c:12
void gvm_json_pull_parser_init(gvm_json_pull_parser_t *parser, FILE *input_stream)
Initializes a JSON pull parser with default buffer sizes.
Definition jsonpull.c:109
static int gvm_json_pull_parse_key(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event)
Handles the case that an object key is expected in a JSON pull parser.
Definition jsonpull.c:426
static void gvm_json_pull_handle_read_end(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event, gboolean allow_eof)
Handles error or EOF after reading a character in JSON pull parser.
Definition jsonpull.c:238
gchar * gvm_json_path_to_string(GQueue *path)
Converts a path as used by a JSON pull parser to a JSONPath string.
Definition jsonpull.c:910
#define GVM_JSON_CHAR_ERROR
Error reading file.
Definition jsonpull.c:11
cJSON * gvm_json_pull_expand_container(gvm_json_pull_parser_t *parser, gchar **error_message)
Expands the current array or object of a JSON pull parser.
Definition jsonpull.c:746
static int gvm_json_pull_parse_keyword(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event, const char *keyword)
Parses a keyword value in a JSON pull parser.
Definition jsonpull.c:378
static void gvm_json_path_string_add_elem(gvm_json_path_elem_t *path_elem, GString *path_string)
Appends a string path element to a JSONPath string.
Definition jsonpull.c:889
static int gvm_json_pull_parse_buffered(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event, const char *value_name, cJSON_bool(*validate_func)(const cJSON *const), cJSON **cjson_value)
Tries to parse the buffer content of a JSON pull parser.
Definition jsonpull.c:211
static void parse_value_next_expect(gvm_json_pull_parser_t *parser)
Updates the expectation for a JSON pull parser according to the path.
Definition jsonpull.c:406
#define GVM_JSON_CHAR_EOF
End of file.
Definition jsonpull.c:10
static int gvm_json_pull_check_parse_buffer_size(const char *value_type, gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event)
Checks if the parse buffer limit of a JSON pull parser is reached.
Definition jsonpull.c:151
void gvm_json_pull_path_elem_free(gvm_json_path_elem_t *elem)
Frees a JSON path element.
Definition jsonpull.c:38
gvm_json_path_elem_t * gvm_json_pull_path_elem_new(gvm_json_pull_container_type_t parent_type, int depth)
Creates a new JSON path element.
Definition jsonpull.c:23
void gvm_json_pull_event_init(gvm_json_pull_event_t *event)
Initializes a JSON pull event data structure.
Definition jsonpull.c:50
static gchar * gvm_json_read_stream_error_str()
Generates message for an error that occurred reading the JSON stream.
Definition jsonpull.c:136
#define GVM_JSON_PULL_READ_BUFFER_SIZE
Definition jsonpull.h:80
#define GVM_JSON_PULL_PARSE_BUFFER_LIMIT
Definition jsonpull.h:78
gvm_json_pull_container_type_t
Type of container the parser is currently in.
Definition jsonpull.h:20
@ GVM_JSON_PULL_CONTAINER_OBJECT
Object.
Definition jsonpull.h:23
@ GVM_JSON_PULL_CONTAINER_ARRAY
Array.
Definition jsonpull.h:22
@ GVM_JSON_PULL_EXPECT_VALUE
Expect start of a value.
Definition jsonpull.h:72
@ GVM_JSON_PULL_EXPECT_KEY
Expect start of a key.
Definition jsonpull.h:73
@ GVM_JSON_PULL_EXPECT_EOF
Expect end of file.
Definition jsonpull.h:75
@ GVM_JSON_PULL_EXPECT_COMMA
Expect comma or container end brace.
Definition jsonpull.h:74
@ GVM_JSON_PULL_EVENT_STRING
Definition jsonpull.h:47
@ GVM_JSON_PULL_EVENT_OBJECT_START
Definition jsonpull.h:45
@ GVM_JSON_PULL_EVENT_ERROR
Definition jsonpull.h:52
@ GVM_JSON_PULL_EVENT_NULL
Definition jsonpull.h:50
@ GVM_JSON_PULL_EVENT_EOF
Definition jsonpull.h:51
@ GVM_JSON_PULL_EVENT_NUMBER
Definition jsonpull.h:48
@ GVM_JSON_PULL_EVENT_ARRAY_END
Definition jsonpull.h:44
@ GVM_JSON_PULL_EVENT_OBJECT_END
Definition jsonpull.h:46
@ GVM_JSON_PULL_EVENT_ARRAY_START
Definition jsonpull.h:43
@ GVM_JSON_PULL_EVENT_BOOLEAN
Definition jsonpull.h:49
struct gvm_json_path_elem gvm_json_path_elem_t
Path element types for the JSON pull parser.
int depth
Number of ancestor elements.
Definition jsonpull.h:34
int index
Index of the element within the parent.
Definition jsonpull.h:32
char * key
Key if element is in an object.
Definition jsonpull.h:33
gvm_json_pull_container_type_t parent_type
parent container type
Definition jsonpull.h:31
Event generated by the JSON pull parser.
Definition jsonpull.h:59
gchar * error_message
Error message, NULL on success.
Definition jsonpull.h:63
cJSON * value
Value for non-container value events.
Definition jsonpull.h:62
A json pull parser.
Definition jsonpull.h:86
char * read_buffer
Stream reading buffer.
Definition jsonpull.h:92
size_t read_buffer_size
Size of the stream reading buffer.
Definition jsonpull.h:93
gvm_json_pull_expect_t expect
Current expected token.
Definition jsonpull.h:89
size_t last_read_size
Size of last stream read.
Definition jsonpull.h:94
GString * parse_buffer
Buffer for parsing values and object keys.
Definition jsonpull.h:97
size_t parse_buffer_limit
Maximum parse buffer size.
Definition jsonpull.h:98
gvm_json_path_elem_t * path_add
Path elem to add in next step.
Definition jsonpull.h:88
size_t read_pos
Position in current read.
Definition jsonpull.h:96
GQueue * path
Path to the current value.
Definition jsonpull.h:87
int last_read_char
Character last read from stream.
Definition jsonpull.h:95
FILE * input_stream
Input stream.
Definition jsonpull.h:91