src/core/transport/http/util/axis2_json_reader.c - axis-axis2-c-core - Git at Google

 /*
  *  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 <axutil_stream.h>
 #include <axiom_node.h>
 #include <axiom_element.h>
 #include <axiom_attribute.h>
 #include <json.h>
 #include "axis2_json_reader.h"

 #define AXIS2_JSON_XSI_URI "http://www.w3.org/2001/XMLSchema-instance"

 struct axis2_json_reader
 {
     json_object* json_obj;
     axiom_node_t* axiom_node;
 };

 const char* json_tokener_error_to_str(enum json_tokener_error error)
 {
     switch (error)
     {
     case json_tokener_success:
         return "success";
     case json_tokener_continue:
         return "continue";
     case json_tokener_error_depth:
         return "error_depth";
     case json_tokener_error_parse_eof:
         return "error_parse_eof";
     case json_tokener_error_parse_unexpected:
         return "error_parse_unexpected";
     case json_tokener_error_parse_null:
         return "error_parse_null";
     case json_tokener_error_parse_boolean:
         return "error_parse_boolean";
     case json_tokener_error_parse_number:
         return "error_parse_number";
     case json_tokener_error_parse_array:
         return "error_parse_array";
     case json_tokener_error_parse_object_key_name:
         return "error_parse_object_key_name";
     case json_tokener_error_parse_object_key_sep:
         return "error_parse_object_key_sep";
     case json_tokener_error_parse_object_value_sep:
         return "error_parse_object_value_sep";
     case json_tokener_error_parse_string:
         return "error_parse_string";
     case json_tokener_error_parse_comment:
         return "error_parse_comment";
     }
     return "UNKNOWN";
 }

 axis2_status_t
 axis2_json_read_node(
         json_object* parent,
         const char* name,
         axiom_node_t** om_node,
         const axutil_env_t* env);


 axis2_status_t
 axis2_json_read_child_node(
         json_object* child_object,
         const char* child_name,
         axiom_node_t* om_node,
         const axutil_env_t* env)
 {
     axiom_node_t* child_node = NULL;

     switch (json_object_get_type(child_object))
     {
     case json_type_object:
     {
         if (axis2_json_read_node(child_object, child_name, &child_node, env) != AXIS2_SUCCESS)
             return AXIS2_FAILURE;
         if (axiom_node_add_child(om_node, env, child_node) != AXIS2_SUCCESS)
             return AXIS2_FAILURE;
         break;
     }

     case json_type_array:
     {
         int i;
         int array_len = json_object_array_length(child_object);
         for (i = 0; i < array_len; ++i)
         {
             if (axis2_json_read_child_node(json_object_array_get_idx(child_object, i),
                                        child_name, om_node, env) != AXIS2_SUCCESS)
                 return AXIS2_FAILURE;
         }
         break;
     }

     case json_type_int:
     case json_type_boolean:
     case json_type_double:
     case json_type_string:
     {
         axiom_node_t* om_child_node = NULL;
         axiom_node_t* om_text_node = NULL;

         if (!axiom_element_create(env, NULL, child_name, NULL, &om_child_node))
             return AXIS2_FAILURE;

         if (!axiom_text_create(env, om_child_node, json_object_get_string(child_object),
                           &om_text_node))
                 return AXIS2_FAILURE;

         if (axiom_node_add_child(om_node, env, om_child_node) != AXIS2_SUCCESS)
         {
             axiom_node_free_tree(om_text_node, env);
             return AXIS2_FAILURE;
         }

         break;
     }

     case json_type_null:
     {
         axiom_element_t* om_child_elem = NULL;
         axiom_node_t* om_child_node = NULL;

         /* handle as nillable */
         axiom_attribute_t* attr;
         axiom_namespace_t* ns =
                 axiom_namespace_create(env, AXIS2_JSON_XSI_URI, "xsi");

         if (!ns)
             return AXIS2_FAILURE;

         om_child_elem = axiom_element_create(env, NULL, child_name, NULL, &om_child_node);
         if (!om_child_elem)
         {
             axiom_namespace_free(ns, env);
             return AXIS2_FAILURE;
         }

         if (axiom_node_add_child(om_node, env, om_child_node) != AXIS2_SUCCESS)
         {
             axiom_namespace_free(ns, env);
             axiom_node_free_tree(om_child_node, env);
             return AXIS2_FAILURE;
         }

         attr = axiom_attribute_create(env, "nil", "true", ns);
         if (!attr)
         {
             axiom_attribute_free(attr, env);
             return AXIS2_FAILURE;
         }

         if (axiom_element_add_attribute(om_child_elem, env, attr,
                                         om_child_node) != AXIS2_SUCCESS)
         {
             axiom_attribute_free(attr, env);
             return AXIS2_FAILURE;
         }

         break;
     }
     }

     return AXIS2_SUCCESS;
 }

 axis2_status_t
 axis2_json_read_node(
         json_object* parent,
         const char* name,
         axiom_node_t** om_node,
         const axutil_env_t* env)
 {
     if (!json_object_is_type(parent, json_type_object))
         return AXIS2_FAILURE;

     axiom_element_create(env, NULL, name, NULL, om_node);

     json_object_object_foreach(parent, child_name, child_object)
     {
         if (axis2_json_read_child_node(child_object, child_name, *om_node, env) != AXIS2_SUCCESS)
             return AXIS2_FAILURE;
     }

     return AXIS2_SUCCESS;
 }

 AXIS2_EXTERN axis2_json_reader_t* AXIS2_CALL
 axis2_json_reader_create_for_stream(
         const axutil_env_t* env,
         axutil_stream_t* stream)
 {
     axis2_json_reader_t* reader =
             (axis2_json_reader_t*)AXIS2_MALLOC(env->allocator,
                                                sizeof(struct axis2_json_reader));
     if (reader)
     {
         axis2_char_t buffer[512];
         int readed;
         struct json_tokener* tokener = json_tokener_new();
         enum json_tokener_error error;
         json_object* json_obj = NULL;

         reader->json_obj = NULL;
         reader->axiom_node = NULL;
         do
         {
             readed = axutil_stream_read(stream, env, &buffer, sizeof(buffer));
             if (readed < 0)
                 break;

             json_obj = json_tokener_parse_ex(tokener, buffer, readed);

         } while ((error = json_tokener_get_error(tokener)) == json_tokener_continue);

         if (error != json_tokener_success)
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
             AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to parse JSON request: %s",
                             json_tokener_error_to_str(tokener->err));
             if (json_obj)
                 json_object_put(json_obj);
             json_tokener_free(tokener);
             free(reader);
             return NULL;
         }

         reader->json_obj = json_obj;

         json_tokener_free(tokener);
     }

     return reader;
 }


 AXIS2_EXTERN axis2_json_reader_t* AXIS2_CALL
 axis2_json_reader_create_for_memory(
         const axutil_env_t* env,
         const axis2_char_t* json_string,
         int json_string_size)
 {
     axis2_json_reader_t* reader =
             (axis2_json_reader_t*)AXIS2_MALLOC(env->allocator,
                                                sizeof(struct axis2_json_reader));
     if (reader)
     {
         struct json_tokener* tokener = json_tokener_new();

         reader->axiom_node = NULL;
         reader->json_obj = json_tokener_parse_ex(tokener, json_string, json_string_size);
         if (tokener->err != json_tokener_success)
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
             AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to parse JSON request: %s",
                             json_tokener_error_to_str(tokener->err));
             if (reader->json_obj)
                 json_object_put(reader->json_obj);
             json_tokener_free(tokener);
             free(reader);
             return NULL;
         }
         json_tokener_free(tokener);
     }

     return reader;
 }


 AXIS2_EXTERN void AXIS2_CALL
 axis2_json_reader_free(
         axis2_json_reader_t* reader,
         const axutil_env_t* env)
 {
     if (reader->json_obj)
         json_object_put(reader->json_obj);
     AXIS2_FREE(env->allocator, reader);
 }


 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axis2_json_reader_read(
         axis2_json_reader_t* reader,
         const axutil_env_t* env)
 {
     json_object* json_root = NULL;
     const char* json_root_name = NULL;

     /* free existing om tree */
     if (reader->axiom_node)
         axiom_node_free_tree(reader->axiom_node, env);
     reader->axiom_node = NULL;

     /* get first child */
     json_object_object_foreach(reader->json_obj, key, value)
     {
         json_root = value;
         json_root_name = key;
         break;
     }

     if (!json_root || !json_root_name)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed find root JSON node");
         return AXIS2_FAILURE;
     }

     return axis2_json_read_node(json_root, json_root_name, &reader->axiom_node, env);
 }


 AXIS2_EXTERN axiom_node_t* AXIS2_CALL
 axis2_json_reader_get_root_node(
         axis2_json_reader_t* reader,
         const axutil_env_t* env)
 {
     (void)env;
     return reader->axiom_node;
 }
	/*
	* 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 <axutil_stream.h>
	#include <axiom_node.h>
	#include <axiom_element.h>
	#include <axiom_attribute.h>
	#include <json.h>
	#include "axis2_json_reader.h"

	#define AXIS2_JSON_XSI_URI "http://www.w3.org/2001/XMLSchema-instance"

	struct axis2_json_reader
	{
	json_object* json_obj;
	axiom_node_t* axiom_node;
	};

	const char* json_tokener_error_to_str(enum json_tokener_error error)
	{
	switch (error)
	{
	case json_tokener_success:
	return "success";
	case json_tokener_continue:
	return "continue";
	case json_tokener_error_depth:
	return "error_depth";
	case json_tokener_error_parse_eof:
	return "error_parse_eof";
	case json_tokener_error_parse_unexpected:
	return "error_parse_unexpected";
	case json_tokener_error_parse_null:
	return "error_parse_null";
	case json_tokener_error_parse_boolean:
	return "error_parse_boolean";
	case json_tokener_error_parse_number:
	return "error_parse_number";
	case json_tokener_error_parse_array:
	return "error_parse_array";
	case json_tokener_error_parse_object_key_name:
	return "error_parse_object_key_name";
	case json_tokener_error_parse_object_key_sep:
	return "error_parse_object_key_sep";
	case json_tokener_error_parse_object_value_sep:
	return "error_parse_object_value_sep";
	case json_tokener_error_parse_string:
	return "error_parse_string";
	case json_tokener_error_parse_comment:
	return "error_parse_comment";
	}
	return "UNKNOWN";
	}

	axis2_status_t
	axis2_json_read_node(
	json_object* parent,
	const char* name,
	axiom_node_t** om_node,
	const axutil_env_t* env);


	axis2_status_t
	axis2_json_read_child_node(
	json_object* child_object,
	const char* child_name,
	axiom_node_t* om_node,
	const axutil_env_t* env)
	{
	axiom_node_t* child_node = NULL;

	switch (json_object_get_type(child_object))
	{
	case json_type_object:
	{
	if (axis2_json_read_node(child_object, child_name, &child_node, env) != AXIS2_SUCCESS)
	return AXIS2_FAILURE;
	if (axiom_node_add_child(om_node, env, child_node) != AXIS2_SUCCESS)
	return AXIS2_FAILURE;
	break;
	}

	case json_type_array:
	{
	int i;
	int array_len = json_object_array_length(child_object);
	for (i = 0; i < array_len; ++i)
	{
	if (axis2_json_read_child_node(json_object_array_get_idx(child_object, i),
	child_name, om_node, env) != AXIS2_SUCCESS)
	return AXIS2_FAILURE;
	}
	break;
	}

	case json_type_int:
	case json_type_boolean:
	case json_type_double:
	case json_type_string:
	{
	axiom_node_t* om_child_node = NULL;
	axiom_node_t* om_text_node = NULL;

	if (!axiom_element_create(env, NULL, child_name, NULL, &om_child_node))
	return AXIS2_FAILURE;

	if (!axiom_text_create(env, om_child_node, json_object_get_string(child_object),
	&om_text_node))
	return AXIS2_FAILURE;

	if (axiom_node_add_child(om_node, env, om_child_node) != AXIS2_SUCCESS)
	{
	axiom_node_free_tree(om_text_node, env);
	return AXIS2_FAILURE;
	}

	break;
	}

	case json_type_null:
	{
	axiom_element_t* om_child_elem = NULL;
	axiom_node_t* om_child_node = NULL;

	/* handle as nillable */
	axiom_attribute_t* attr;
	axiom_namespace_t* ns =
	axiom_namespace_create(env, AXIS2_JSON_XSI_URI, "xsi");

	if (!ns)
	return AXIS2_FAILURE;

	om_child_elem = axiom_element_create(env, NULL, child_name, NULL, &om_child_node);
	if (!om_child_elem)
	{
	axiom_namespace_free(ns, env);
	return AXIS2_FAILURE;
	}

	if (axiom_node_add_child(om_node, env, om_child_node) != AXIS2_SUCCESS)
	{
	axiom_namespace_free(ns, env);
	axiom_node_free_tree(om_child_node, env);
	return AXIS2_FAILURE;
	}

	attr = axiom_attribute_create(env, "nil", "true", ns);
	if (!attr)
	{
	axiom_attribute_free(attr, env);
	return AXIS2_FAILURE;
	}

	if (axiom_element_add_attribute(om_child_elem, env, attr,
	om_child_node) != AXIS2_SUCCESS)
	{
	axiom_attribute_free(attr, env);
	return AXIS2_FAILURE;
	}

	break;
	}
	}

	return AXIS2_SUCCESS;
	}

	axis2_status_t
	axis2_json_read_node(
	json_object* parent,
	const char* name,
	axiom_node_t** om_node,
	const axutil_env_t* env)
	{
	if (!json_object_is_type(parent, json_type_object))
	return AXIS2_FAILURE;

	axiom_element_create(env, NULL, name, NULL, om_node);

	json_object_object_foreach(parent, child_name, child_object)
	{
	if (axis2_json_read_child_node(child_object, child_name, *om_node, env) != AXIS2_SUCCESS)
	return AXIS2_FAILURE;
	}

	return AXIS2_SUCCESS;
	}

	AXIS2_EXTERN axis2_json_reader_t* AXIS2_CALL
	axis2_json_reader_create_for_stream(
	const axutil_env_t* env,
	axutil_stream_t* stream)
	{
	axis2_json_reader_t* reader =
	(axis2_json_reader_t*)AXIS2_MALLOC(env->allocator,
	sizeof(struct axis2_json_reader));
	if (reader)
	{
	axis2_char_t buffer[512];
	int readed;
	struct json_tokener* tokener = json_tokener_new();
	enum json_tokener_error error;
	json_object* json_obj = NULL;

	reader->json_obj = NULL;
	reader->axiom_node = NULL;
	do
	{
	readed = axutil_stream_read(stream, env, &buffer, sizeof(buffer));
	if (readed < 0)
	break;

	json_obj = json_tokener_parse_ex(tokener, buffer, readed);

	} while ((error = json_tokener_get_error(tokener)) == json_tokener_continue);

	if (error != json_tokener_success)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to parse JSON request: %s",
	json_tokener_error_to_str(tokener->err));
	if (json_obj)
	json_object_put(json_obj);
	json_tokener_free(tokener);
	free(reader);
	return NULL;
	}

	reader->json_obj = json_obj;

	json_tokener_free(tokener);
	}

	return reader;
	}


	AXIS2_EXTERN axis2_json_reader_t* AXIS2_CALL
	axis2_json_reader_create_for_memory(
	const axutil_env_t* env,
	const axis2_char_t* json_string,
	int json_string_size)
	{
	axis2_json_reader_t* reader =
	(axis2_json_reader_t*)AXIS2_MALLOC(env->allocator,
	sizeof(struct axis2_json_reader));
	if (reader)
	{
	struct json_tokener* tokener = json_tokener_new();

	reader->axiom_node = NULL;
	reader->json_obj = json_tokener_parse_ex(tokener, json_string, json_string_size);
	if (tokener->err != json_tokener_success)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to parse JSON request: %s",
	json_tokener_error_to_str(tokener->err));
	if (reader->json_obj)
	json_object_put(reader->json_obj);
	json_tokener_free(tokener);
	free(reader);
	return NULL;
	}
	json_tokener_free(tokener);
	}

	return reader;
	}


	AXIS2_EXTERN void AXIS2_CALL
	axis2_json_reader_free(
	axis2_json_reader_t* reader,
	const axutil_env_t* env)
	{
	if (reader->json_obj)
	json_object_put(reader->json_obj);
	AXIS2_FREE(env->allocator, reader);
	}


	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axis2_json_reader_read(
	axis2_json_reader_t* reader,
	const axutil_env_t* env)
	{
	json_object* json_root = NULL;
	const char* json_root_name = NULL;

	/* free existing om tree */
	if (reader->axiom_node)
	axiom_node_free_tree(reader->axiom_node, env);
	reader->axiom_node = NULL;

	/* get first child */
	json_object_object_foreach(reader->json_obj, key, value)
	{
	json_root = value;
	json_root_name = key;
	break;
	}

	if (!json_root \|\| !json_root_name)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_PARAM, AXIS2_FAILURE);
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed find root JSON node");
	return AXIS2_FAILURE;
	}

	return axis2_json_read_node(json_root, json_root_name, &reader->axiom_node, env);
	}


	AXIS2_EXTERN axiom_node_t* AXIS2_CALL
	axis2_json_reader_get_root_node(
	axis2_json_reader_t* reader,
	const axutil_env_t* env)
	{
	(void)env;
	return reader->axiom_node;
	}