Greenbone Vulnerability Management Libraries 22.18.1
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_free (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_free (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 gvm_json_pull_skip_space (parser, event, TRUE);
699
700 if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
701 {
702 event->type = GVM_JSON_PULL_EVENT_ERROR;
703 event->error_message = gvm_json_read_stream_error_str ();
704 }
705 else if (parser->last_read_char != GVM_JSON_CHAR_EOF)
706 {
707 event->type = GVM_JSON_PULL_EVENT_ERROR;
708 event->error_message = g_strdup_printf (
709 "unexpected character at end of file (%d)", parser->last_read_char);
710 return;
711 }
712 return;
713 }
714
715 if (parser->expect == GVM_JSON_PULL_EXPECT_COMMA)
716 {
717 if (gvm_json_pull_parse_comma (parser, event))
718 return;
719 }
720
721 if (parser->expect == GVM_JSON_PULL_EXPECT_KEY)
722 {
723 if (gvm_json_pull_parse_key (parser, event))
724 return;
725 }
726
727 if (parser->expect == GVM_JSON_PULL_EXPECT_VALUE)
728 {
729 gvm_json_pull_parse_value (parser, event);
730 }
731}
732
743cJSON *
745 gchar **error_message)
746{
747 gvm_json_path_elem_t *path_tail = NULL;
748
749 int start_depth;
750 gboolean in_string, escape_next_char, in_expanded_container;
751 cJSON *expanded;
752
753 g_string_truncate (parser->parse_buffer, 0);
754
755 if (error_message)
756 *error_message = NULL;
757
758 // require "path_add" to only allow expansion at start of container
759 if (parser->path_add)
760 {
761 path_tail = parser->path_add;
762 g_queue_push_tail (parser->path, path_tail);
763 parser->path_add = NULL;
764 }
765
766 if (path_tail && path_tail->parent_type == GVM_JSON_PULL_CONTAINER_ARRAY)
767 g_string_append_c (parser->parse_buffer, '[');
768 else if (path_tail
770 g_string_append_c (parser->parse_buffer, '{');
771 else
772 {
773 if (error_message)
774 *error_message =
775 g_strdup ("can only expand after array or object start");
776 return NULL;
777 }
778
779 start_depth = path_tail->depth;
780 in_string = escape_next_char = FALSE;
781 in_expanded_container = TRUE;
782
783 while (parser->last_read_char >= 0 && in_expanded_container)
784 {
785 if (parser->parse_buffer->len >= parser->parse_buffer_limit)
786 {
787 if (error_message)
788 *error_message =
789 g_strdup_printf ("container exceeds size limit of %zu bytes",
790 parser->parse_buffer_limit);
791 return NULL;
792 }
793
794 g_string_append_c (parser->parse_buffer, parser->last_read_char);
795
796 if (escape_next_char)
797 {
798 escape_next_char = FALSE;
799 }
800 else if (in_string)
801 {
802 escape_next_char = (parser->last_read_char == '\\');
803 in_string = (parser->last_read_char != '"');
804 }
805 else
806 {
807 switch (parser->last_read_char)
808 {
809 case '"':
810 in_string = TRUE;
811 break;
812 case '[':
813 path_tail = gvm_json_pull_path_elem_new (
814 GVM_JSON_PULL_CONTAINER_ARRAY, parser->path->length);
815 g_queue_push_tail (parser->path, path_tail);
816 break;
817 case '{':
818 path_tail = gvm_json_pull_path_elem_new (
819 GVM_JSON_PULL_CONTAINER_OBJECT, parser->path->length);
820 g_queue_push_tail (parser->path, path_tail);
821 break;
822 case ']':
823 path_tail = g_queue_pop_tail (parser->path);
825 {
826 if (error_message)
827 *error_message =
828 g_strdup ("unexpected closing square bracket");
829 return NULL;
830 }
831 if (path_tail->depth == start_depth)
832 in_expanded_container = FALSE;
833 break;
834 case '}':
835 path_tail = g_queue_pop_tail (parser->path);
837 {
838 if (error_message)
839 *error_message =
840 g_strdup ("unexpected closing curly brace");
841 return NULL;
842 }
843 if (path_tail->depth == start_depth)
844 in_expanded_container = FALSE;
845 break;
846 }
847 }
849 }
850
851 if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
852 {
853 if (error_message)
854 *error_message = gvm_json_read_stream_error_str ();
855 return NULL;
856 }
857 else if (in_expanded_container && parser->last_read_char == GVM_JSON_CHAR_EOF)
858 {
859 if (error_message)
860 *error_message = g_strdup ("unexpected EOF");
861 return NULL;
862 }
863
864 expanded = cJSON_Parse (parser->parse_buffer->str);
865 g_string_truncate (parser->parse_buffer, 0);
867
868 if (expanded == NULL && error_message)
869 *error_message = g_strdup ("could not parse expanded container");
870
871 return expanded;
872}
873
880static void
882 GString *path_string)
883{
885 {
886 gchar *escaped_key = gvm_json_string_escape (path_elem->key, TRUE);
887 g_string_append_printf (path_string, "['%s']", escaped_key);
888 g_free (escaped_key);
889 }
890 else
891 g_string_append_printf (path_string, "[%d]", path_elem->index);
892}
893
901gchar *
903{
904 GString *path_string = g_string_new ("$");
905 g_queue_foreach (path, (GFunc) gvm_json_path_string_add_elem, path_string);
906 return g_string_free (path_string, FALSE);
907}
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:902
#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:744
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:881
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