json/apr_json_encode.c

/* 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_DECLARE(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