jsonpull.c File Reference

#include "jsonpull.h"
#include <assert.h>

Include dependency graph for jsonpull.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	GVM_JSON_CHAR_EOF   -1
	End of file.
#define	GVM_JSON_CHAR_ERROR   -2
	Error reading file.
#define	GVM_JSON_CHAR_UNDEFINED   -3
	Undefined state.

Functions
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.
void	gvm_json_pull_path_elem_free (gvm_json_path_elem_t *elem)
	Frees a JSON path element.
void	gvm_json_pull_event_init (gvm_json_pull_event_t *event)
	Initializes a JSON pull event data structure.
void	gvm_json_pull_event_cleanup (gvm_json_pull_event_t *event)
	Frees all data of JSON pull event data structure.
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.
void	gvm_json_pull_parser_init (gvm_json_pull_parser_t *parser, FILE *input_stream)
	Initializes a JSON pull parser with default buffer sizes.
void	gvm_json_pull_parser_cleanup (gvm_json_pull_parser_t *parser)
	Frees the data of a JSON pull parser.
static gchar *	gvm_json_read_stream_error_str ()
	Generates message for an error that occurred reading the JSON stream.
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.
static int	gvm_json_pull_parser_next_char (gvm_json_pull_parser_t *parser)
	Reads the next character in a pull parser input stream.
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.
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.
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.
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.
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.
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.
static void	parse_value_next_expect (gvm_json_pull_parser_t *parser)
	Updates the expectation for a JSON pull parser according to the path.
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.
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.
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.
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.
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.
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.
gchar *	gvm_json_path_to_string (GQueue *path)
	Converts a path as used by a JSON pull parser to a JSONPath string.

Macro Definition Documentation

GVM_JSON_CHAR_EOF

#define GVM_JSON_CHAR_EOF   -1

End of file.

Definition at line 10 of file jsonpull.c.

Referenced by gvm_json_pull_expand_container(), gvm_json_pull_parser_next(), and gvm_json_pull_parser_next_char().

GVM_JSON_CHAR_ERROR

#define GVM_JSON_CHAR_ERROR   -2

Error reading file.

Definition at line 11 of file jsonpull.c.

Referenced by gvm_json_pull_expand_container(), gvm_json_pull_handle_read_end(), gvm_json_pull_parse_number(), and gvm_json_pull_parser_next_char().

GVM_JSON_CHAR_UNDEFINED

#define GVM_JSON_CHAR_UNDEFINED   -3

Undefined state.

Definition at line 12 of file jsonpull.c.

Referenced by gvm_json_pull_parser_init_full(), and gvm_json_pull_parser_next().

Function Documentation

gvm_json_path_string_add_elem()

void gvm_json_path_string_add_elem ( gvm_json_path_elem_t * path_elem, GString * path_string )

static

Appends a string path element to a JSONPath string.

Parameters

[in]	path_elem	The path element to append
[in]	path_string	The path string to append to

Definition at line 888 of file jsonpull.c.

{
  if (path_elem->parent_type == GVM_JSON_PULL_CONTAINER_OBJECT)
    {
      gchar *escaped_key = gvm_json_string_escape (path_elem->key, TRUE);
      g_string_append_printf (path_string, "['%s']", escaped_key);
      g_free (escaped_key);
    }
  else
    g_string_append_printf (path_string, "[%d]", path_elem->index);
}

References GVM_JSON_PULL_CONTAINER_OBJECT, gvm_json_string_escape(), gvm_json_path_elem::index, gvm_json_path_elem::key, and gvm_json_path_elem::parent_type.

Referenced by gvm_json_path_to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_path_to_string()

gchar * gvm_json_path_to_string

(

GQueue *

path

)

Converts a path as used by a JSON pull parser to a JSONPath string.

Parameters

[in]

path

The path to convert

Returns

Newly allocated string of the path in JSONPath bracket notation

Definition at line 909 of file jsonpull.c.

{
  GString *path_string = g_string_new ("$");
  g_queue_foreach (path, (GFunc) gvm_json_path_string_add_elem, path_string);
  return g_string_free (path_string, FALSE);
}

References gvm_json_path_string_add_elem().

Referenced by parse_vt_json().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_check_parse_buffer_size()

int gvm_json_pull_check_parse_buffer_size ( const char * value_type, gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event )

static

Checks if the parse buffer limit of a JSON pull parser is reached.

Parameters

[in]	value_type	The value type to include in the error message
[in]	parser	The parser to check the parse buffer of
[in]	event	Event data for error status and message if needed

Returns

0 if buffer size is okay, 1 if limit was reached

Definition at line 150 of file jsonpull.c.

{
  if (parser->parse_buffer->len >= parser->parse_buffer_limit)
    {
      event->error_message =
        g_strdup_printf ("%s exceeds size limit of %zu bytes", value_type,
                         parser->parse_buffer_limit);
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      return 1;
    }
  return 0;
}

References GVM_JSON_PULL_EVENT_ERROR, gvm_json_pull_parser_t::parse_buffer, and gvm_json_pull_parser_t::parse_buffer_limit.

Referenced by gvm_json_pull_parse_number(), and gvm_json_pull_parse_string().

Here is the caller graph for this function:

gvm_json_pull_event_cleanup()

void gvm_json_pull_event_cleanup

(

gvm_json_pull_event_t *

event

)

Frees all data of JSON pull event data structure.

Parameters

[in]

event

The event structure to clean up

Definition at line 61 of file jsonpull.c.

{
  cJSON_Delete (event->value);
  g_free (event->error_message);
  memset (event, 0, sizeof (gvm_json_pull_event_t));
}

References gvm_json_pull_event_t::error_message, and gvm_json_pull_event_t::value.

Referenced by Ensure(), Ensure(), and gvm_json_pull_parser_next().

Here is the caller graph for this function:

gvm_json_pull_event_init()

void gvm_json_pull_event_init

(

gvm_json_pull_event_t *

event

)

Initializes a JSON pull event data structure.

Parameters

[in]

event

The event structure to initialize

Definition at line 50 of file jsonpull.c.

{
  memset (event, 0, sizeof (gvm_json_pull_event_t));
}

Referenced by Ensure().

Here is the caller graph for this function:

gvm_json_pull_expand_container()

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.

This should be called after an array or object start event.

Parameters

[in]	parser	Parser to get the current container element from
[out]	error_message	Error message output

Returns

The expanded container as a cJSON object if successful, else NULL

Definition at line 745 of file jsonpull.c.

{
  gvm_json_path_elem_t *path_tail = NULL;
 
  int start_depth;
  gboolean in_string, escape_next_char, in_expanded_container;
  cJSON *expanded;
 
  g_string_truncate (parser->parse_buffer, 0);
 
  if (error_message)
    *error_message = NULL;
 
  // require "path_add" to only allow expansion at start of container
  if (parser->path_add)
    {
      path_tail = parser->path_add;
      g_queue_push_tail (parser->path, path_tail);
      parser->path_add = NULL;
    }
 
  if (path_tail && path_tail->parent_type == GVM_JSON_PULL_CONTAINER_ARRAY)
    g_string_append_c (parser->parse_buffer, '[');
  else if (path_tail
           && path_tail->parent_type == GVM_JSON_PULL_CONTAINER_OBJECT)
    g_string_append_c (parser->parse_buffer, '{');
  else
    {
      if (error_message)
        *error_message =
          g_strdup ("can only expand after array or object start");
      return NULL;
    }
 
  start_depth = path_tail->depth;
  in_string = escape_next_char = FALSE;
  in_expanded_container = TRUE;
 
  while (parser->last_read_char >= 0 && in_expanded_container)
    {
      if (parser->parse_buffer->len >= parser->parse_buffer_limit)
        {
          if (error_message)
            *error_message =
              g_strdup_printf ("container exceeds size limit of %zu bytes",
                               parser->parse_buffer_limit);
          return NULL;
        }
 
      g_string_append_c (parser->parse_buffer, parser->last_read_char);
 
      if (escape_next_char)
        {
          escape_next_char = FALSE;
        }
      else if (in_string)
        {
          escape_next_char = (parser->last_read_char == '\\');
          in_string = (parser->last_read_char != '"');
        }
      else
        {
          switch (parser->last_read_char)
            {
            case '"':
              in_string = TRUE;
              break;
            case '[':
              path_tail = gvm_json_pull_path_elem_new (
                GVM_JSON_PULL_CONTAINER_ARRAY, parser->path->length);
              g_queue_push_tail (parser->path, path_tail);
              break;
            case '{':
              path_tail = gvm_json_pull_path_elem_new (
                GVM_JSON_PULL_CONTAINER_OBJECT, parser->path->length);
              g_queue_push_tail (parser->path, path_tail);
              break;
            case ']':
              path_tail = g_queue_pop_tail (parser->path);
              if (path_tail->parent_type != GVM_JSON_PULL_CONTAINER_ARRAY)
                {
                  if (error_message)
                    *error_message =
                      g_strdup ("unexpected closing square bracket");
                  gvm_json_pull_path_elem_free (path_tail);
                  return NULL;
                }
              if (path_tail->depth == start_depth)
                in_expanded_container = FALSE;
 
              gvm_json_pull_path_elem_free (path_tail);
              break;
            case '}':
              path_tail = g_queue_pop_tail (parser->path);
              if (path_tail->parent_type != GVM_JSON_PULL_CONTAINER_OBJECT)
                {
                  if (error_message)
                    *error_message =
                      g_strdup ("unexpected closing curly brace");
                  gvm_json_pull_path_elem_free (path_tail);
                  return NULL;
                }
              if (path_tail->depth == start_depth)
                in_expanded_container = FALSE;
 
              gvm_json_pull_path_elem_free (path_tail);
              break;
            }
        }
      gvm_json_pull_parser_next_char (parser);
    }
 
  if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
    {
      if (error_message)
        *error_message = gvm_json_read_stream_error_str ();
      return NULL;
    }
  else if (in_expanded_container && parser->last_read_char == GVM_JSON_CHAR_EOF)
    {
      if (error_message)
        *error_message = g_strdup ("unexpected EOF");
      return NULL;
    }
 
  expanded = cJSON_Parse (parser->parse_buffer->str);
  g_string_truncate (parser->parse_buffer, 0);
  parse_value_next_expect (parser);
 
  if (expanded == NULL && error_message)
    *error_message = g_strdup ("could not parse expanded container");
 
  return expanded;
}

References gvm_json_path_elem::depth, GVM_JSON_CHAR_EOF, GVM_JSON_CHAR_ERROR, GVM_JSON_PULL_CONTAINER_ARRAY, GVM_JSON_PULL_CONTAINER_OBJECT, gvm_json_pull_parser_next_char(), gvm_json_pull_path_elem_free(), gvm_json_pull_path_elem_new(), gvm_json_read_stream_error_str(), gvm_json_pull_parser_t::last_read_char, gvm_json_path_elem::parent_type, gvm_json_pull_parser_t::parse_buffer, gvm_json_pull_parser_t::parse_buffer_limit, parse_value_next_expect(), gvm_json_pull_parser_t::path, and gvm_json_pull_parser_t::path_add.

Referenced by Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), and parse_vt_json().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_handle_read_end()

void gvm_json_pull_handle_read_end ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event, gboolean allow_eof )

static

Handles error or EOF after reading a character in JSON pull parser.

Parameters

[in]	parser	Parser to get the last read character from
[in]	event	Event data to set EOF or error status in
[in]	allow_eof	Whether to allow EOF, generate error on EOF if FALSE

Definition at line 237 of file jsonpull.c.

{
  if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
    {
      event->error_message = gvm_json_read_stream_error_str ();
      event->type = GVM_JSON_PULL_EVENT_ERROR;
    }
  else if (allow_eof)
    event->type = GVM_JSON_PULL_EVENT_EOF;
  else
    {
      event->error_message = g_strdup ("unexpected EOF");
      event->type = GVM_JSON_PULL_EVENT_ERROR;
    }
}

References GVM_JSON_CHAR_ERROR, GVM_JSON_PULL_EVENT_EOF, GVM_JSON_PULL_EVENT_ERROR, gvm_json_read_stream_error_str(), and gvm_json_pull_parser_t::last_read_char.

Referenced by gvm_json_pull_parse_keyword(), gvm_json_pull_parse_string(), gvm_json_pull_parser_next(), and gvm_json_pull_skip_space().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parse_buffered()

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 )

static

Tries to parse the buffer content of a JSON pull parser.

Parameters

[in]	parser	The parser to use the parse buffer of
[in]	event	Event set error of if necessary
[in]	value_name	Name of the value for error message if needed
[in]	validate_func	Function for validating the parsed value
[out]	cjson_value	Return of the parsed cJSON object on success

Returns

0 success, 1 error

Definition at line 210 of file jsonpull.c.

{
  cJSON *parsed_value = cJSON_Parse (parser->parse_buffer->str);
  *cjson_value = NULL;
  if (validate_func (parsed_value) == 0)
    {
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      event->error_message = g_strdup_printf ("error parsing %s", value_name);
      cJSON_free (parsed_value);
      return 1;
    }
  *cjson_value = parsed_value;
  return 0;
}

References GVM_JSON_PULL_EVENT_ERROR, and gvm_json_pull_parser_t::parse_buffer.

Referenced by gvm_json_pull_parse_number(), and gvm_json_pull_parse_string().

Here is the caller graph for this function:

gvm_json_pull_parse_comma()

int gvm_json_pull_parse_comma ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event )

static

Handles the case that a comma is expected in a JSON pull parser.

This will continue the parsing until a comma or the end of the current array/object was reached or an error occurred.

Parameters

[in]	parser	Parser to process
[in]	event	Event data to set error or end of object status in

Returns

1 if an error occurred, 0 otherwise

Definition at line 496 of file jsonpull.c.

{
  if (gvm_json_pull_skip_space (parser, event, FALSE))
    return 1;
 
  gvm_json_path_elem_t *path_elem = NULL;
  switch (parser->last_read_char)
    {
    case ',':
      path_elem = g_queue_peek_tail (parser->path);
      path_elem->index++;
      if (path_elem->parent_type == GVM_JSON_PULL_CONTAINER_OBJECT)
        parser->expect = GVM_JSON_PULL_EXPECT_KEY;
      else
        parser->expect = GVM_JSON_PULL_EXPECT_VALUE;
      gvm_json_pull_parser_next_char (parser);
      break;
    case ']':
      path_elem = g_queue_peek_tail (parser->path);
      if (path_elem == NULL
          || path_elem->parent_type != GVM_JSON_PULL_CONTAINER_ARRAY)
        {
          event->type = GVM_JSON_PULL_EVENT_ERROR;
          event->error_message = g_strdup ("unexpected closing square bracket");
          return 1;
        }
      event->type = GVM_JSON_PULL_EVENT_ARRAY_END;
      event->value = NULL;
      gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
      parse_value_next_expect (parser);
      gvm_json_pull_parser_next_char (parser);
      break;
    case '}':
      path_elem = g_queue_peek_tail (parser->path);
      if (path_elem == NULL
          || path_elem->parent_type != GVM_JSON_PULL_CONTAINER_OBJECT)
        {
          event->type = GVM_JSON_PULL_EVENT_ERROR;
          event->error_message = g_strdup ("unexpected closing curly brace");
          return 1;
        }
      event->type = GVM_JSON_PULL_EVENT_OBJECT_END;
      event->value = NULL;
      gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
      parse_value_next_expect (parser);
      gvm_json_pull_parser_next_char (parser);
      break;
    default:
      event->error_message = g_strdup ("expected comma or end of container");
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      return 1;
    }
  return 0;
}

References gvm_json_pull_parser_t::expect, GVM_JSON_PULL_CONTAINER_ARRAY, GVM_JSON_PULL_CONTAINER_OBJECT, GVM_JSON_PULL_EVENT_ARRAY_END, GVM_JSON_PULL_EVENT_ERROR, GVM_JSON_PULL_EVENT_OBJECT_END, GVM_JSON_PULL_EXPECT_KEY, GVM_JSON_PULL_EXPECT_VALUE, gvm_json_pull_parser_next_char(), gvm_json_pull_path_elem_free(), gvm_json_pull_skip_space(), gvm_json_path_elem::index, gvm_json_pull_parser_t::last_read_char, gvm_json_path_elem::parent_type, parse_value_next_expect(), and gvm_json_pull_parser_t::path.

Referenced by gvm_json_pull_parser_next().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parse_key()

int gvm_json_pull_parse_key ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event )

static

Handles the case that an object key is expected in a JSON pull parser.

This will continue the parsing until the value is expected, the end of the current object was reached or an error occurred.

Parameters

[in]	parser	Parser to process
[in]	event	Event data to set error or end of object status in

Returns

1 if an error occurred, 0 otherwise

Definition at line 425 of file jsonpull.c.

{
  if (gvm_json_pull_skip_space (parser, event, FALSE))
    return 1;
 
  cJSON *key_cjson = NULL;
  gchar *key_str;
  gvm_json_path_elem_t *path_elem;
 
  switch (parser->last_read_char)
    {
    case '"':
      if (gvm_json_pull_parse_string (parser, event, &key_cjson))
        return 1;
      key_str = g_strdup (key_cjson->valuestring);
      cJSON_Delete (key_cjson);
 
      // Expect colon:
      if (gvm_json_pull_skip_space (parser, event, FALSE))
        {
          g_free (key_str);
          return 1;
        }
      if (parser->last_read_char != ':')
        {
          event->type = GVM_JSON_PULL_EVENT_ERROR;
          event->error_message = g_strdup_printf ("expected colon");
          g_free (key_str);
          return 1;
        }
      gvm_json_pull_parser_next_char (parser);
 
      path_elem = g_queue_peek_tail (parser->path);
      g_free (path_elem->key);
      path_elem->key = key_str;
      parser->expect = GVM_JSON_PULL_EXPECT_VALUE;
 
      break;
    case '}':
      event->type = GVM_JSON_PULL_EVENT_OBJECT_END;
      event->value = NULL;
      gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
      parse_value_next_expect (parser);
      gvm_json_pull_parser_next_char (parser);
      break;
    case ']':
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      event->error_message = g_strdup ("unexpected closing square bracket");
      return 1;
    default:
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      event->error_message = g_strdup ("unexpected character");
      return 1;
    }
 
  return 0;
}

References gvm_json_pull_parser_t::expect, GVM_JSON_PULL_EVENT_ERROR, GVM_JSON_PULL_EVENT_OBJECT_END, GVM_JSON_PULL_EXPECT_VALUE, gvm_json_pull_parse_string(), gvm_json_pull_parser_next_char(), gvm_json_pull_path_elem_free(), gvm_json_pull_skip_space(), gvm_json_path_elem::key, gvm_json_pull_parser_t::last_read_char, parse_value_next_expect(), and gvm_json_pull_parser_t::path.

Referenced by gvm_json_pull_parser_next().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parse_keyword()

int gvm_json_pull_parse_keyword ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event, const char * keyword )

static

Parses a keyword value in a JSON pull parser.

The parser is expected to be at the first character of the keyword and will be at the first character after the keyword on success.

Parameters

[in]	parser	Parser to handle the keyword value in
[in]	event	Event data to set EOF or error status in
[in]	keyword	The expected keyword, e.g. "null", "true", "false".

Returns

1 if an error occurred, 0 otherwise

Definition at line 377 of file jsonpull.c.

{
  for (size_t i = 0; i < strlen (keyword); i++)
    {
      if (parser->last_read_char < 0)
        {
          gvm_json_pull_handle_read_end (parser, event, FALSE);
          return 1;
        }
      else if (parser->last_read_char != keyword[i])
        {
          event->type = GVM_JSON_PULL_EVENT_ERROR;
          event->error_message =
            g_strdup_printf ("misspelled keyword '%s'", keyword);
          return 1;
        }
      gvm_json_pull_parser_next_char (parser);
    }
  return 0;
}

References GVM_JSON_PULL_EVENT_ERROR, gvm_json_pull_handle_read_end(), gvm_json_pull_parser_next_char(), and gvm_json_pull_parser_t::last_read_char.

Referenced by gvm_json_pull_parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parse_number()

int gvm_json_pull_parse_number ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event, cJSON ** cjson_value )

static

Parses a number in a JSON pull parser.

The parser is expected to be at the first character of the number and will be at the first non-number character on success.

Parameters

[in]	parser	Parser to handle the number value in
[in]	event	Event data to set EOF or error status in
[out]	cjson_value	The cJSON value for the number on success.

Returns

1 if an error occurred, 0 otherwise

Definition at line 336 of file jsonpull.c.

{
  g_string_truncate (parser->parse_buffer, 0);
  g_string_append_c (parser->parse_buffer, parser->last_read_char);
  while (gvm_json_pull_parser_next_char (parser) >= 0)
    {
      if (gvm_json_pull_check_parse_buffer_size ("number", parser, event))
        return 1;
      if (g_ascii_isdigit (parser->last_read_char)
          || parser->last_read_char == '.' || parser->last_read_char == 'e'
          || parser->last_read_char == '-' || parser->last_read_char == '+')
        g_string_append_c (parser->parse_buffer, parser->last_read_char);
      else
        break;
    }
 
  if (parser->last_read_char == GVM_JSON_CHAR_ERROR)
    {
      event->error_message = gvm_json_read_stream_error_str ();
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      return 1;
    }
 
  return gvm_json_pull_parse_buffered (parser, event, "number", cJSON_IsNumber,
                                       cjson_value);
}

References GVM_JSON_CHAR_ERROR, gvm_json_pull_check_parse_buffer_size(), GVM_JSON_PULL_EVENT_ERROR, gvm_json_pull_parse_buffered(), gvm_json_pull_parser_next_char(), gvm_json_read_stream_error_str(), gvm_json_pull_parser_t::last_read_char, and gvm_json_pull_parser_t::parse_buffer.

Referenced by gvm_json_pull_parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parse_string()

int gvm_json_pull_parse_string ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event, cJSON ** cjson_value )

static

Parses a string in a JSON pull parser.

The parser is expected to be at the opening quote mark and will be at the character after the closing quote mark on success.

Parameters

[in]	parser	Parser to handle the string value in
[in]	event	Event data to set EOF or error status in
[out]	cjson_value	The cJSON value for the string on success

Returns

1 if an error occurred (including EOF), 0 otherwise

Definition at line 292 of file jsonpull.c.

{
  gboolean escape_next_char = FALSE;
  g_string_truncate (parser->parse_buffer, 0);
  g_string_append_c (parser->parse_buffer, '"');
  while (gvm_json_pull_parser_next_char (parser) >= 0)
    {
      if (gvm_json_pull_check_parse_buffer_size ("string", parser, event))
        return 1;
      g_string_append_c (parser->parse_buffer, parser->last_read_char);
      if (escape_next_char)
        escape_next_char = FALSE;
      else if (parser->last_read_char == '\\')
        escape_next_char = TRUE;
      else if (parser->last_read_char == '"')
        break;
    }
 
  if (parser->last_read_char < 0)
    {
      gvm_json_pull_handle_read_end (parser, event, FALSE);
      return 1;
    }
 
  gvm_json_pull_parser_next_char (parser);
 
  return gvm_json_pull_parse_buffered (parser, event, "string", cJSON_IsString,
                                       cjson_value);
}

References gvm_json_pull_check_parse_buffer_size(), gvm_json_pull_handle_read_end(), gvm_json_pull_parse_buffered(), gvm_json_pull_parser_next_char(), gvm_json_pull_parser_t::last_read_char, and gvm_json_pull_parser_t::parse_buffer.

Referenced by gvm_json_pull_parse_key(), and gvm_json_pull_parse_value().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parse_value()

int gvm_json_pull_parse_value ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event )

static

Handles the case that a value is expected in a JSON pull parser.

This will continue the parsing until a value or the end of the current array/object was parsed or an error occurred.

Parameters

[in]	parser	Parser to process
[in]	event	Event data to set error or end of object status in

Returns

1 if an error occurred, 0 otherwise

Definition at line 564 of file jsonpull.c.

{
  if (gvm_json_pull_skip_space (parser, event, FALSE))
    return 1;
 
  cJSON *cjson_value = NULL;
  gvm_json_path_elem_t *path_elem = NULL;
 
  switch (parser->last_read_char)
    {
    case '"':
      if (gvm_json_pull_parse_string (parser, event, &cjson_value))
        return 1;
      event->type = GVM_JSON_PULL_EVENT_STRING;
      event->value = cjson_value;
      parse_value_next_expect (parser);
      break;
    case 'n':
      if (gvm_json_pull_parse_keyword (parser, event, "null"))
        return 1;
      event->type = GVM_JSON_PULL_EVENT_NULL;
      event->value = cJSON_CreateNull ();
      parse_value_next_expect (parser);
      break;
    case 'f':
      if (gvm_json_pull_parse_keyword (parser, event, "false"))
        return 1;
      event->type = GVM_JSON_PULL_EVENT_BOOLEAN;
      event->value = cJSON_CreateFalse ();
      parse_value_next_expect (parser);
      break;
    case 't':
      if (gvm_json_pull_parse_keyword (parser, event, "true"))
        return 1;
      event->type = GVM_JSON_PULL_EVENT_BOOLEAN;
      event->value = cJSON_CreateTrue ();
      parse_value_next_expect (parser);
      break;
    case '[':
      event->type = GVM_JSON_PULL_EVENT_ARRAY_START;
      event->value = NULL;
      parser->path_add = gvm_json_pull_path_elem_new (
        GVM_JSON_PULL_CONTAINER_ARRAY, parser->path->length);
      parser->expect = GVM_JSON_PULL_EXPECT_VALUE;
      gvm_json_pull_parser_next_char (parser);
      break;
    case ']':
      path_elem = g_queue_peek_tail (parser->path);
      if (path_elem == NULL
          || path_elem->parent_type != GVM_JSON_PULL_CONTAINER_ARRAY)
        {
          event->type = GVM_JSON_PULL_EVENT_ERROR;
          event->error_message = g_strdup ("unexpected closing square bracket");
          return 1;
        }
      event->type = GVM_JSON_PULL_EVENT_ARRAY_END;
      event->value = NULL;
      gvm_json_pull_path_elem_free (g_queue_pop_tail (parser->path));
      parse_value_next_expect (parser);
      gvm_json_pull_parser_next_char (parser);
      break;
    case '{':
      event->type = GVM_JSON_PULL_EVENT_OBJECT_START;
      event->value = NULL;
      parser->path_add = gvm_json_pull_path_elem_new (
        GVM_JSON_PULL_CONTAINER_OBJECT, parser->path->length);
      parser->expect = GVM_JSON_PULL_EXPECT_KEY;
      gvm_json_pull_parser_next_char (parser);
      break;
    case '}':
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      event->error_message = g_strdup ("unexpected closing curly brace");
      return 1;
      break;
    default:
      if (g_ascii_isdigit (parser->last_read_char)
          || parser->last_read_char == '-')
        {
          if (gvm_json_pull_parse_number (parser, event, &cjson_value))
            return 1;
          event->type = GVM_JSON_PULL_EVENT_NUMBER;
          event->value = cjson_value;
          parse_value_next_expect (parser);
        }
      else
        {
          event->type = GVM_JSON_PULL_EVENT_ERROR;
          event->error_message = g_strdup ("unexpected character");
          return 1;
        }
    }
  return 0;
}

References gvm_json_pull_parser_t::expect, GVM_JSON_PULL_CONTAINER_ARRAY, GVM_JSON_PULL_CONTAINER_OBJECT, GVM_JSON_PULL_EVENT_ARRAY_END, GVM_JSON_PULL_EVENT_ARRAY_START, GVM_JSON_PULL_EVENT_BOOLEAN, GVM_JSON_PULL_EVENT_ERROR, GVM_JSON_PULL_EVENT_NULL, GVM_JSON_PULL_EVENT_NUMBER, GVM_JSON_PULL_EVENT_OBJECT_START, GVM_JSON_PULL_EVENT_STRING, GVM_JSON_PULL_EXPECT_KEY, GVM_JSON_PULL_EXPECT_VALUE, gvm_json_pull_parse_keyword(), gvm_json_pull_parse_number(), gvm_json_pull_parse_string(), gvm_json_pull_parser_next_char(), gvm_json_pull_path_elem_free(), gvm_json_pull_path_elem_new(), gvm_json_pull_skip_space(), gvm_json_pull_parser_t::last_read_char, gvm_json_path_elem::parent_type, parse_value_next_expect(), gvm_json_pull_parser_t::path, and gvm_json_pull_parser_t::path_add.

Referenced by gvm_json_pull_parser_next().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parser_cleanup()

void gvm_json_pull_parser_cleanup

(

gvm_json_pull_parser_t *

parser

)

Frees the data of a JSON pull parser.

Parameters

[in]

parser

The parser data structure to free the data of

Definition at line 119 of file jsonpull.c.

{
  assert (parser);
  g_queue_free_full (parser->path,
                     (GDestroyNotify) gvm_json_pull_path_elem_free);
  g_string_free (parser->parse_buffer, TRUE);
  g_free (parser->read_buffer);
  memset (parser, 0, sizeof (gvm_json_pull_parser_t));
}

References gvm_json_pull_path_elem_free(), gvm_json_pull_parser_t::parse_buffer, gvm_json_pull_parser_t::path, and gvm_json_pull_parser_t::read_buffer.

Referenced by Ensure(), Ensure(), and Ensure().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parser_init()

void gvm_json_pull_parser_init	(	gvm_json_pull_parser_t *	parser,
		FILE *	input_stream )

Initializes a JSON pull parser with default buffer sizes.

Parameters

[in]	parser	The parser data structure to initialize
[in]	input_stream	The JSON input stream

Definition at line 108 of file jsonpull.c.

{
  gvm_json_pull_parser_init_full (parser, input_stream, 0, 0);
}

References gvm_json_pull_parser_init_full().

Referenced by Ensure(), and Ensure().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_pull_parser_init_full()

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.

Parameters

[in]	parser	The parser data structure to initialize
[in]	input_stream	The JSON input stream
[in]	parse_buffer_limit	Maximum buffer size for parsing values
[in]	read_buffer_size	Buffer size for reading from the stream

Definition at line 77 of file jsonpull.c.

{
  assert (parser);
  assert (input_stream);
  memset (parser, 0, sizeof (gvm_json_pull_parser_t));
 
  if (parse_buffer_limit <= 0)
    parse_buffer_limit = GVM_JSON_PULL_PARSE_BUFFER_LIMIT;
 
  if (read_buffer_size <= 0)
    read_buffer_size = GVM_JSON_PULL_READ_BUFFER_SIZE;
 
  parser->input_stream = input_stream;
  parser->path = g_queue_new ();
  parser->expect = GVM_JSON_PULL_EXPECT_VALUE;
  parser->parse_buffer_limit = parse_buffer_limit;
  parser->parse_buffer = g_string_new ("");
  parser->read_buffer_size = read_buffer_size;
  parser->read_buffer = g_malloc0 (read_buffer_size);
  parser->last_read_char = GVM_JSON_CHAR_UNDEFINED;
}

References gvm_json_pull_parser_t::expect, GVM_JSON_CHAR_UNDEFINED, GVM_JSON_PULL_EXPECT_VALUE, GVM_JSON_PULL_PARSE_BUFFER_LIMIT, GVM_JSON_PULL_READ_BUFFER_SIZE, gvm_json_pull_parser_t::input_stream, gvm_json_pull_parser_t::last_read_char, gvm_json_pull_parser_t::parse_buffer, gvm_json_pull_parser_t::parse_buffer_limit, gvm_json_pull_parser_t::path, gvm_json_pull_parser_t::read_buffer, and gvm_json_pull_parser_t::read_buffer_size.

Referenced by gvm_json_pull_parser_init().

Here is the caller graph for this function:

gvm_json_pull_parser_next()

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.

Note: This invalidates previous event data like the cJSON value.

Parameters

[in]	parser	The JSON pull parser to process until the next event
[in]	event	Structure to store event data in.

Definition at line 668 of file jsonpull.c.

{
  assert (parser);
  assert (event);
 
  gvm_json_pull_event_cleanup (event);
  if (parser->last_read_char == GVM_JSON_CHAR_UNDEFINED)
    {
      // Handle first read of the stream
      if (gvm_json_pull_parser_next_char (parser) < 0)
        {
          gvm_json_pull_handle_read_end (parser, event, TRUE);
          return;
        }
    }
 
  event->path = parser->path;
 
  // Delayed addition to path after a container start element
  if (parser->path_add)
    {
      g_queue_push_tail (parser->path, parser->path_add);
      parser->path_add = NULL;
    }
 
  // Check for expected end of file
  if (parser->expect == GVM_JSON_PULL_EXPECT_EOF)
    {
      if (gvm_json_pull_skip_space (parser, event, TRUE))
        {
          // EOF was reached, or an error occurred.
          // The event type is already set, and if an error occurred, then
          // error_message is also already set.
          return;
        }
 
      // Skipping space succeeded. Check for unexpected characters at EOF.
 
      if (parser->last_read_char == GVM_JSON_CHAR_EOF)
        return;
 
      event->type = GVM_JSON_PULL_EVENT_ERROR;
      event->error_message = g_strdup_printf (
        "unexpected character at end of file (%d)", parser->last_read_char);
      return;
    }
 
  if (parser->expect == GVM_JSON_PULL_EXPECT_COMMA)
    {
      if (gvm_json_pull_parse_comma (parser, event))
        return;
    }
 
  if (parser->expect == GVM_JSON_PULL_EXPECT_KEY)
    {
      if (gvm_json_pull_parse_key (parser, event))
        return;
    }
 
  if (parser->expect == GVM_JSON_PULL_EXPECT_VALUE)
    {
      gvm_json_pull_parse_value (parser, event);
    }
}

References gvm_json_pull_parser_t::expect, GVM_JSON_CHAR_EOF, GVM_JSON_CHAR_UNDEFINED, gvm_json_pull_event_cleanup(), GVM_JSON_PULL_EVENT_ERROR, GVM_JSON_PULL_EXPECT_COMMA, GVM_JSON_PULL_EXPECT_EOF, GVM_JSON_PULL_EXPECT_KEY, GVM_JSON_PULL_EXPECT_VALUE, gvm_json_pull_handle_read_end(), gvm_json_pull_parse_comma(), gvm_json_pull_parse_key(), gvm_json_pull_parse_value(), gvm_json_pull_parser_next_char(), gvm_json_pull_skip_space(), gvm_json_pull_parser_t::last_read_char, gvm_json_pull_parser_t::path, and gvm_json_pull_parser_t::path_add.

Referenced by Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), Ensure(), and parse_vt_json().

Here is the call graph for this function:

gvm_json_pull_parser_next_char()

int gvm_json_pull_parser_next_char ( gvm_json_pull_parser_t * parser )

static

Reads the next character in a pull parser input stream.

Parameters

[in]

parser

The parser to read the next character from

Returns

The character code, GVM_JSON_CHAR_ERROR or GVM_JSON_CHAR_EOF.

Definition at line 173 of file jsonpull.c.

{
  parser->read_pos++;
  if (parser->read_pos < parser->last_read_size)
    {
      parser->last_read_char =
        (unsigned char) parser->read_buffer[parser->read_pos];
      return parser->last_read_char;
    }
  else
    {
      parser->read_pos = 0;
      parser->last_read_size = fread (
        parser->read_buffer, 1, parser->read_buffer_size, parser->input_stream);
      if (ferror (parser->input_stream))
        parser->last_read_char = GVM_JSON_CHAR_ERROR;
      else if (parser->last_read_size <= 0)
        parser->last_read_char = GVM_JSON_CHAR_EOF;
      else
        parser->last_read_char =
          (unsigned char) parser->read_buffer[parser->read_pos];
      return parser->last_read_char;
    }
}

References GVM_JSON_CHAR_EOF, GVM_JSON_CHAR_ERROR, gvm_json_pull_parser_t::input_stream, gvm_json_pull_parser_t::last_read_char, gvm_json_pull_parser_t::last_read_size, gvm_json_pull_parser_t::read_buffer, gvm_json_pull_parser_t::read_buffer_size, and gvm_json_pull_parser_t::read_pos.

Referenced by gvm_json_pull_expand_container(), gvm_json_pull_parse_comma(), gvm_json_pull_parse_key(), gvm_json_pull_parse_keyword(), gvm_json_pull_parse_number(), gvm_json_pull_parse_string(), gvm_json_pull_parse_value(), gvm_json_pull_parser_next(), and gvm_json_pull_skip_space().

Here is the caller graph for this function:

gvm_json_pull_path_elem_free()

void gvm_json_pull_path_elem_free

(

gvm_json_path_elem_t *

elem

)

Frees a JSON path element.

Parameters

[in]

elem

The element to free

Definition at line 38 of file jsonpull.c.

{
  g_free (elem->key);
  g_free (elem);
}

References gvm_json_path_elem::key.

Referenced by gvm_json_pull_expand_container(), gvm_json_pull_parse_comma(), gvm_json_pull_parse_key(), gvm_json_pull_parse_value(), and gvm_json_pull_parser_cleanup().

Here is the caller graph for this function:

gvm_json_pull_path_elem_new()

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.

Parameters

[in]	parent_type	Type of the parent (array, object, none/root)
[in]	depth	The depth in the document tree

Returns

The newly allocated path element

Definition at line 23 of file jsonpull.c.

{
  gvm_json_path_elem_t *new_elem = g_malloc0 (sizeof (gvm_json_path_elem_t));
  new_elem->parent_type = parent_type;
  new_elem->depth = depth;
  return new_elem;
}

References gvm_json_path_elem::depth, and gvm_json_path_elem::parent_type.

Referenced by gvm_json_pull_expand_container(), and gvm_json_pull_parse_value().

Here is the caller graph for this function:

gvm_json_pull_skip_space()

int gvm_json_pull_skip_space ( gvm_json_pull_parser_t * parser, gvm_json_pull_event_t * event, gboolean allow_eof )

static

Skips whitespaces in the input stream of a JSON pull parser.

The parser will be at the first non-whitespace character on success.

Parameters

[in]	parser	Parser to skip the whitespaces in
[in]	event	Event data to set EOF or error status in
[in]	allow_eof	Whether to allow EOF, generate error on EOF if FALSE

Returns

1 if EOF was reached or an error occurred, 0 otherwise

Definition at line 266 of file jsonpull.c.

{
  while (g_ascii_isspace (parser->last_read_char))
    gvm_json_pull_parser_next_char (parser);
  if (parser->last_read_char < 0)
    {
      gvm_json_pull_handle_read_end (parser, event, allow_eof);
      return 1;
    }
  return 0;
}

References gvm_json_pull_handle_read_end(), gvm_json_pull_parser_next_char(), and gvm_json_pull_parser_t::last_read_char.

Referenced by gvm_json_pull_parse_comma(), gvm_json_pull_parse_key(), gvm_json_pull_parse_value(), and gvm_json_pull_parser_next().

Here is the call graph for this function:

Here is the caller graph for this function:

gvm_json_read_stream_error_str()

gchar * gvm_json_read_stream_error_str ( )

static

Generates message for an error that occurred reading the JSON stream.

Returns

The newly allocated error message

Definition at line 135 of file jsonpull.c.

{
  return g_strdup_printf ("error reading JSON stream: %s", strerror (errno));
}

Referenced by gvm_json_pull_expand_container(), gvm_json_pull_handle_read_end(), and gvm_json_pull_parse_number().

Here is the caller graph for this function:

parse_value_next_expect()

void parse_value_next_expect ( gvm_json_pull_parser_t * parser )

static

Updates the expectation for a JSON pull parser according to the path.

Parameters

[in]

parser

The parser to update.

Definition at line 405 of file jsonpull.c.

{
  if (parser->path->length)
    parser->expect = GVM_JSON_PULL_EXPECT_COMMA;
  else
    parser->expect = GVM_JSON_PULL_EXPECT_EOF;
}

References gvm_json_pull_parser_t::expect, GVM_JSON_PULL_EXPECT_COMMA, GVM_JSON_PULL_EXPECT_EOF, and gvm_json_pull_parser_t::path.

Referenced by gvm_json_pull_expand_container(), gvm_json_pull_parse_comma(), gvm_json_pull_parse_key(), and gvm_json_pull_parse_value().

Here is the caller graph for this function: