json/apr_json_encode.c - apr - Git at Google

 /* Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 "apr_json.h"

 #if !APR_CHARSET_EBCDIC

 typedef struct apr_json_serializer_t {
     apr_pool_t *pool;
     apr_bucket_brigade *brigade;
     apr_brigade_flush flush;
     void *ctx;
     int flags;
 } apr_json_serializer_t;

 static apr_status_t apr_json_encode_value(apr_json_serializer_t * self,
                                             const apr_json_value_t * value);

 static apr_status_t apr_json_brigade_write(apr_json_serializer_t * self,
                const char *chunk, apr_size_t chunk_len, const char *escaped)
 {
     apr_status_t status;

     status = apr_brigade_write(self->brigade, self->flush, self->ctx, chunk, chunk_len);
     if (APR_SUCCESS == status) {
         status = apr_brigade_puts(self->brigade, self->flush, self->ctx, escaped);
     }

     return status;
 }

 static apr_status_t apr_json_brigade_printf(apr_json_serializer_t * self,
                const char *chunk, apr_size_t chunk_len, const char *fmt, ...)
 {
     va_list ap;
     apr_status_t status;

     status = apr_brigade_write(self->brigade, self->flush, self->ctx, chunk,
             chunk_len);
     if (APR_SUCCESS == status) {
         va_start(ap, fmt);
         status = apr_brigade_vprintf(self->brigade, self->flush, self->ctx, fmt,
                 ap);
         va_end(ap);
     }

     return status;
 }

 static apr_status_t apr_json_encode_string(apr_json_serializer_t * self,
         const apr_json_string_t * string)
 {
     apr_status_t status;
     const char *p, *e, *chunk;
     const char invalid[4] = { 0xEF, 0xBF, 0xBD, 0x00 };
     unsigned char c;

     status = apr_brigade_putc(self->brigade, self->flush, self->ctx, '\"');
     if (APR_SUCCESS != status) {
         return status;
     }

     for (p = chunk = string->p, e = string->p
             + (APR_JSON_VALUE_STRING == string->len ?
                     strlen(string->p) : string->len); p < e; p++) {
         switch (*p) {
         case '\n':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\n");
             chunk = p + 1;
             break;
         case '\r':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\r");
             chunk = p + 1;
             break;
         case '\t':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\t");
             chunk = p + 1;
             break;
         case '\b':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\b");
             chunk = p + 1;
             break;
         case '\f':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\f");
             chunk = p + 1;
             break;
         case '\\':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\\\");
             chunk = p + 1;
             break;
         case '"':
             status = apr_json_brigade_write(self, chunk, p - chunk, "\\\"");
             chunk = p + 1;
             break;
         default:
             c = (unsigned char)(*p);
             apr_size_t left = e - p;
             if (c < 0x20) {
                 status = apr_json_brigade_printf(self, chunk, p - chunk,
                         "\\u%04x", c);
                 chunk = p + 1;
             }
             else if (((c >> 7) == 0x00)) {
                 /* 1 byte */
             }
             else if (left > 1 && ((c >> 5) == 0x06) && p[1]) {
                 /* 2 bytes */
                 if (left < 2 || (p[1] >> 6) != 0x02) {
                     status = apr_json_brigade_write(self, chunk, p - chunk,
                             invalid);
                     chunk = p + 1;
                 }
             }
             else if (((c >> 4) == 0x0E)) {
                 /* 3 bytes */
                 if (left < 3 || (p[1] >> 6) != 0x02 || (p[2] >> 6) != 0x02) {
                     status = apr_json_brigade_write(self, chunk, p - chunk,
                             invalid);
                     chunk = p + 1;
                 }
             }
             else if ((c >> 3) == 0x1E) {
                 /* 4 bytes */
                 if (left < 4 || (p[1] >> 6) != 0x02 || (p[2] >> 6) != 0x02 || (p[3] >> 6) != 0x02) {
                     status = apr_json_brigade_write(self, chunk, p - chunk,
                             invalid);
                     chunk = p + 1;
                 }
             }
             else {
                 status = apr_json_brigade_write(self, chunk, p - chunk,
                         invalid);
                 chunk = p + 1;
             }
             break;
         }

         if (APR_SUCCESS != status) {
             return status;
         }
     }

     if (chunk < p) {
         status = apr_brigade_write(self->brigade, self->flush, self->ctx, chunk, p - chunk);
         if (APR_SUCCESS != status) {
             return status;
         }
     }

     return apr_brigade_putc(self->brigade, self->flush, self->ctx, '\"');
 }


 static apr_status_t apr_json_encode_array(apr_json_serializer_t * self,
         const apr_json_value_t * array)
 {
     apr_status_t status;
     apr_json_value_t *val;
     apr_size_t count = 0;

     status = apr_brigade_putc(self->brigade, self->flush, self->ctx, '[');
     if (APR_SUCCESS != status) {
         return status;
     }

     val = apr_json_array_first(array);
     while (val) {

         if (count > 0) {
             status = apr_brigade_putc(self->brigade, self->flush, self->ctx, ',');
             if (APR_SUCCESS != status) {
                 return status;
             }
         }

         status = apr_json_encode_value(self, val);
         if (APR_SUCCESS != status) {
             return status;
         }

         val = apr_json_array_next(array, val);
         count++;
     }

     return apr_brigade_putc(self->brigade, self->flush, self->ctx, ']');
 }

 static apr_status_t apr_json_encode_object(apr_json_serializer_t * self, apr_json_object_t * object)
 {
     apr_status_t status;
     apr_json_kv_t *kv;
     int first = 1;
     status = apr_brigade_putc(self->brigade, self->flush, self->ctx, '{');
     if (APR_SUCCESS != status) {
         return status;
     }

     for (kv = APR_RING_FIRST(&(object)->list);
          kv != APR_RING_SENTINEL(&(object)->list, apr_json_kv_t, link);
          kv = APR_RING_NEXT((kv), link)) {

         if (!first) {
             status = apr_brigade_putc(self->brigade, self->flush, self->ctx, ',');
             if (APR_SUCCESS != status) {
                 return status;
             }
         }

         {
             status = apr_json_encode_value(self, kv->k);
             if (APR_SUCCESS != status) {
                 return status;
             }

             status = apr_brigade_putc(self->brigade, self->flush, self->ctx, ':');
             if (APR_SUCCESS != status) {
                 return status;
             }

             status = apr_json_encode_value(self, kv->v);
             if (APR_SUCCESS != status) {
                 return status;
             }
         }
         first = 0;
     }
     return apr_brigade_putc(self->brigade, self->flush, self->ctx, '}');
 }

 static apr_status_t apr_json_encode_value(apr_json_serializer_t * self, const apr_json_value_t * value)
 {
     apr_status_t status = APR_SUCCESS;

     if (value->pre && (self->flags & APR_JSON_FLAGS_WHITESPACE)) {
         status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
                 value->pre);
     }

     if (APR_SUCCESS == status) {
         switch (value->type) {
         case APR_JSON_STRING:
             status = apr_json_encode_string(self, &value->value.string);
             break;
         case APR_JSON_LONG:
             status = apr_brigade_printf(self->brigade, self->flush, self->ctx,
                     "%" APR_INT64_T_FMT, value->value.lnumber);
             break;
         case APR_JSON_DOUBLE:
             status = apr_brigade_printf(self->brigade, self->flush, self->ctx,
                     "%lf", value->value.dnumber);
             break;
         case APR_JSON_BOOLEAN:
             status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
                     value->value.boolean ? "true" : "false");
             break;
         case APR_JSON_NULL:
             status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
                     "null");
             break;
         case APR_JSON_OBJECT:
             status = apr_json_encode_object(self, value->value.object);
             break;
         case APR_JSON_ARRAY:
             status = apr_json_encode_array(self, value);
             break;
         default:
             return APR_EINVAL;
         }
     }

     if (APR_SUCCESS == status && value->post
             && (self->flags & APR_JSON_FLAGS_WHITESPACE)) {
         status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
                 value->post);
     }

     return status;
 }

 apr_status_t apr_json_encode(apr_bucket_brigade * brigade, apr_brigade_flush flush,
                 void *ctx, const apr_json_value_t * json, int flags, apr_pool_t * pool)
 {
     apr_json_serializer_t serializer = {pool, brigade, flush, ctx, flags};
     return apr_json_encode_value(&serializer, json);
 }

 #else
  /* we do not yet support JSON on EBCDIC platforms, but will do in future */
 apr_status_t apr_json_encode(apr_bucket_brigade * brigade, apr_brigade_flush flush,
                 void *ctx, const apr_json_value_t * json, apr_pool_t * pool)
 {
     return APR_ENOTIMPL;
 }
 #endif
	/* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 "apr_json.h"

	#if !APR_CHARSET_EBCDIC

	typedef struct apr_json_serializer_t {
	apr_pool_t *pool;
	apr_bucket_brigade *brigade;
	apr_brigade_flush flush;
	void *ctx;
	int flags;
	} apr_json_serializer_t;

	static apr_status_t apr_json_encode_value(apr_json_serializer_t * self,
	const apr_json_value_t * value);

	static apr_status_t apr_json_brigade_write(apr_json_serializer_t * self,
	const char chunk, apr_size_t chunk_len, const char escaped)
	{
	apr_status_t status;

	status = apr_brigade_write(self->brigade, self->flush, self->ctx, chunk, chunk_len);
	if (APR_SUCCESS == status) {
	status = apr_brigade_puts(self->brigade, self->flush, self->ctx, escaped);
	}

	return status;
	}

	static apr_status_t apr_json_brigade_printf(apr_json_serializer_t * self,
	const char chunk, apr_size_t chunk_len, const char fmt, ...)
	{
	va_list ap;
	apr_status_t status;

	status = apr_brigade_write(self->brigade, self->flush, self->ctx, chunk,
	chunk_len);
	if (APR_SUCCESS == status) {
	va_start(ap, fmt);
	status = apr_brigade_vprintf(self->brigade, self->flush, self->ctx, fmt,
	ap);
	va_end(ap);
	}

	return status;
	}

	static apr_status_t apr_json_encode_string(apr_json_serializer_t * self,
	const apr_json_string_t * string)
	{
	apr_status_t status;
	const char p, e, *chunk;
	const char invalid[4] = { 0xEF, 0xBF, 0xBD, 0x00 };
	unsigned char c;

	status = apr_brigade_putc(self->brigade, self->flush, self->ctx, '\"');
	if (APR_SUCCESS != status) {
	return status;
	}

	for (p = chunk = string->p, e = string->p
	+ (APR_JSON_VALUE_STRING == string->len ?
	strlen(string->p) : string->len); p < e; p++) {
	switch (*p) {
	case '\n':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\n");
	chunk = p + 1;
	break;
	case '\r':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\r");
	chunk = p + 1;
	break;
	case '\t':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\t");
	chunk = p + 1;
	break;
	case '\b':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\b");
	chunk = p + 1;
	break;
	case '\f':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\f");
	chunk = p + 1;
	break;
	case '\\':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\\\");
	chunk = p + 1;
	break;
	case '"':
	status = apr_json_brigade_write(self, chunk, p - chunk, "\\\"");
	chunk = p + 1;
	break;
	default:
	c = (unsigned char)(*p);
	apr_size_t left = e - p;
	if (c < 0x20) {
	status = apr_json_brigade_printf(self, chunk, p - chunk,
	"\\u%04x", c);
	chunk = p + 1;
	}
	else if (((c >> 7) == 0x00)) {
	/* 1 byte */
	}
	else if (left > 1 && ((c >> 5) == 0x06) && p[1]) {
	/* 2 bytes */
	if (left < 2 \|\| (p[1] >> 6) != 0x02) {
	status = apr_json_brigade_write(self, chunk, p - chunk,
	invalid);
	chunk = p + 1;
	}
	}
	else if (((c >> 4) == 0x0E)) {
	/* 3 bytes */
	if (left < 3 \|\| (p[1] >> 6) != 0x02 \|\| (p[2] >> 6) != 0x02) {
	status = apr_json_brigade_write(self, chunk, p - chunk,
	invalid);
	chunk = p + 1;
	}
	}
	else if ((c >> 3) == 0x1E) {
	/* 4 bytes */
	if (left < 4 \|\| (p[1] >> 6) != 0x02 \|\| (p[2] >> 6) != 0x02 \|\| (p[3] >> 6) != 0x02) {
	status = apr_json_brigade_write(self, chunk, p - chunk,
	invalid);
	chunk = p + 1;
	}
	}
	else {
	status = apr_json_brigade_write(self, chunk, p - chunk,
	invalid);
	chunk = p + 1;
	}
	break;
	}

	if (APR_SUCCESS != status) {
	return status;
	}
	}

	if (chunk < p) {
	status = apr_brigade_write(self->brigade, self->flush, self->ctx, chunk, p - chunk);
	if (APR_SUCCESS != status) {
	return status;
	}
	}

	return apr_brigade_putc(self->brigade, self->flush, self->ctx, '\"');
	}


	static apr_status_t apr_json_encode_array(apr_json_serializer_t * self,
	const apr_json_value_t * array)
	{
	apr_status_t status;
	apr_json_value_t *val;
	apr_size_t count = 0;

	status = apr_brigade_putc(self->brigade, self->flush, self->ctx, '[');
	if (APR_SUCCESS != status) {
	return status;
	}

	val = apr_json_array_first(array);
	while (val) {

	if (count > 0) {
	status = apr_brigade_putc(self->brigade, self->flush, self->ctx, ',');
	if (APR_SUCCESS != status) {
	return status;
	}
	}

	status = apr_json_encode_value(self, val);
	if (APR_SUCCESS != status) {
	return status;
	}

	val = apr_json_array_next(array, val);
	count++;
	}

	return apr_brigade_putc(self->brigade, self->flush, self->ctx, ']');
	}

	static apr_status_t apr_json_encode_object(apr_json_serializer_t * self, apr_json_object_t * object)
	{
	apr_status_t status;
	apr_json_kv_t *kv;
	int first = 1;
	status = apr_brigade_putc(self->brigade, self->flush, self->ctx, '{');
	if (APR_SUCCESS != status) {
	return status;
	}

	for (kv = APR_RING_FIRST(&(object)->list);
	kv != APR_RING_SENTINEL(&(object)->list, apr_json_kv_t, link);
	kv = APR_RING_NEXT((kv), link)) {

	if (!first) {
	status = apr_brigade_putc(self->brigade, self->flush, self->ctx, ',');
	if (APR_SUCCESS != status) {
	return status;
	}
	}

	{
	status = apr_json_encode_value(self, kv->k);
	if (APR_SUCCESS != status) {
	return status;
	}

	status = apr_brigade_putc(self->brigade, self->flush, self->ctx, ':');
	if (APR_SUCCESS != status) {
	return status;
	}

	status = apr_json_encode_value(self, kv->v);
	if (APR_SUCCESS != status) {
	return status;
	}
	}
	first = 0;
	}
	return apr_brigade_putc(self->brigade, self->flush, self->ctx, '}');
	}

	static apr_status_t apr_json_encode_value(apr_json_serializer_t * self, const apr_json_value_t * value)
	{
	apr_status_t status = APR_SUCCESS;

	if (value->pre && (self->flags & APR_JSON_FLAGS_WHITESPACE)) {
	status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
	value->pre);
	}

	if (APR_SUCCESS == status) {
	switch (value->type) {
	case APR_JSON_STRING:
	status = apr_json_encode_string(self, &value->value.string);
	break;
	case APR_JSON_LONG:
	status = apr_brigade_printf(self->brigade, self->flush, self->ctx,
	"%" APR_INT64_T_FMT, value->value.lnumber);
	break;
	case APR_JSON_DOUBLE:
	status = apr_brigade_printf(self->brigade, self->flush, self->ctx,
	"%lf", value->value.dnumber);
	break;
	case APR_JSON_BOOLEAN:
	status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
	value->value.boolean ? "true" : "false");
	break;
	case APR_JSON_NULL:
	status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
	"null");
	break;
	case APR_JSON_OBJECT:
	status = apr_json_encode_object(self, value->value.object);
	break;
	case APR_JSON_ARRAY:
	status = apr_json_encode_array(self, value);
	break;
	default:
	return APR_EINVAL;
	}
	}

	if (APR_SUCCESS == status && value->post
	&& (self->flags & APR_JSON_FLAGS_WHITESPACE)) {
	status = apr_brigade_puts(self->brigade, self->flush, self->ctx,
	value->post);
	}

	return status;
	}

	apr_status_t apr_json_encode(apr_bucket_brigade * brigade, apr_brigade_flush flush,
	void ctx, const apr_json_value_t json, int flags, apr_pool_t * pool)
	{
	apr_json_serializer_t serializer = {pool, brigade, flush, ctx, flags};
	return apr_json_encode_value(&serializer, json);
	}

	#else
	/* we do not yet support JSON on EBCDIC platforms, but will do in future */
	apr_status_t apr_json_encode(apr_bucket_brigade * brigade, apr_brigade_flush flush,
	void ctx, const apr_json_value_t json, apr_pool_t * pool)
	{
	return APR_ENOTIMPL;
	}
	#endif