is_json.c

Go to the documentation of this file.

/*-
 * Copyright (c) 2018 Christos Zoulas
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
/*
 * Parse JSON object serialization format (RFC-7159)
 */
 
#ifndef TEST
#include "file.h"
 
#ifndef lint
FILE_RCSID("@(#)$File: is_json.c,v 1.30 2022/09/27 19:12:40 christos Exp $")
#endif
 
#include "magic.h"
#else
#include <stdio.h>
#include <stddef.h>
#endif
#include <string.h>
 
#ifdef DEBUG
#include <stdio.h>
#define DPRINTF(a, b, c)    \
    printf("%*s%s [%.2x/%c] %.*s\n", (int)lvl, "", (a), *(b), *(b), \
    (int)(b - c), (const char *)(c))
#define __file_debugused
#else
#define DPRINTF(a, b, c)    do { } while (/*CONSTCOND*/0)
#define __file_debugused __attribute__((__unused__))
#endif
 
#define JSON_ARRAY  0
#define JSON_CONSTANT   1
#define JSON_NUMBER 2
#define JSON_OBJECT 3
#define JSON_STRING 4
#define JSON_ARRAYN 5
#define JSON_MAX    6
 
/*
 * if JSON_COUNT != 0:
 *  count all the objects, require that we have the whole data file
 * otherwise:
 *  stop if we find an object or an array
 */
#ifndef JSON_COUNT
#define JSON_COUNT 0
#endif
 
static int json_parse(const unsigned char **, const unsigned char *, size_t *,
    size_t);
 
static int
json_isspace(const unsigned char uc)
{
    switch (uc) {
    case ' ':
    case '\n':
    case '\r':
    case '\t':
        return 1;
    default:
        return 0;
    }
}
 
static int
json_isdigit(unsigned char uc)
{
    switch (uc) {
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        return 1;
    default:
        return 0;
    }
}
 
static int
json_isxdigit(unsigned char uc)
{
    if (json_isdigit(uc))
        return 1;
    switch (uc) {
    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
        return 1;
    default:
        return 0;
    }
}
 
static const unsigned char *
json_skip_space(const unsigned char *uc, const unsigned char *ue)
{
    while (uc < ue && json_isspace(*uc))
        uc++;
    return uc;
}
 
/*ARGSUSED*/
static int
json_parse_string(const unsigned char **ucp, const unsigned char *ue,
    size_t lvl __file_debugused)
{
    const unsigned char *uc = *ucp;
    size_t i;
 
    DPRINTF("Parse string: ", uc, *ucp);
    while (uc < ue) {
        switch (*uc++) {
        case '\0':
            goto out;
        case '\\':
            if (uc == ue)
                goto out;
            switch (*uc++) {
            case '\0':
                goto out;
            case '"':
            case '\\':
            case '/':
            case 'b':
            case 'f':
            case 'n':
            case 'r':
            case 't':
                continue;
            case 'u':
                if (ue - uc < 4) {
                    uc = ue;
                    goto out;
                }
                for (i = 0; i < 4; i++)
                    if (!json_isxdigit(*uc++))
                        goto out;
                continue;
            default:
                goto out;
            }
        case '"':
            DPRINTF("Good string: ", uc, *ucp);
            *ucp = uc;
            return 1;
        default:
            continue;
        }
    }
out:
    DPRINTF("Bad string: ", uc, *ucp);
    *ucp = uc;
    return 0;
}
 
static int
json_parse_array(const unsigned char **ucp, const unsigned char *ue,
    size_t *st, size_t lvl)
{
    const unsigned char *uc = *ucp;
 
    DPRINTF("Parse array: ", uc, *ucp);
    while (uc < ue) {
        uc = json_skip_space(uc, ue);
        if (uc == ue)
            goto out;
        if (*uc == ']')
            goto done;
        if (!json_parse(&uc, ue, st, lvl + 1))
            goto out;
        if (uc == ue)
            goto out;
        switch (*uc) {
        case ',':
            uc++;
            continue;
        case ']':
        done:
            st[JSON_ARRAYN]++;
            DPRINTF("Good array: ", uc, *ucp);
            *ucp = uc + 1;
            return 1;
        default:
            goto out;
        }
    }
out:
    DPRINTF("Bad array: ", uc,  *ucp);
    *ucp = uc;
    return 0;
}
 
static int
json_parse_object(const unsigned char **ucp, const unsigned char *ue,
    size_t *st, size_t lvl)
{
    const unsigned char *uc = *ucp;
    DPRINTF("Parse object: ", uc, *ucp);
    while (uc < ue) {
        uc = json_skip_space(uc, ue);
        if (uc == ue)
            goto out;
        if (*uc == '}') {
            uc++;
            goto done;
        }
        if (*uc++ != '"') {
            DPRINTF("not string", uc, *ucp);
            goto out;
        }
        DPRINTF("next field", uc, *ucp);
        if (!json_parse_string(&uc, ue, lvl)) {
            DPRINTF("not string", uc, *ucp);
            goto out;
        }
        uc = json_skip_space(uc, ue);
        if (uc == ue)
            goto out;
        if (*uc++ != ':') {
            DPRINTF("not colon", uc, *ucp);
            goto out;
        }
        if (!json_parse(&uc, ue, st, lvl + 1)) {
            DPRINTF("not json", uc, *ucp);
            goto out;
        }
        if (uc == ue)
            goto out;
        switch (*uc++) {
        case ',':
            continue;
        case '}': /* { */
        done:
            DPRINTF("Good object: ", uc, *ucp);
            *ucp = uc;
            return 1;
        default:
            DPRINTF("not more", uc, *ucp);
            *ucp = uc - 1;
            goto out;
        }
    }
out:
    DPRINTF("Bad object: ", uc, *ucp);
    *ucp = uc;
    return 0;
}
 
/*ARGSUSED*/
static int
json_parse_number(const unsigned char **ucp, const unsigned char *ue, 
    size_t lvl __file_debugused)
{
    const unsigned char *uc = *ucp;
    int got = 0;
 
    DPRINTF("Parse number: ", uc, *ucp);
    if (uc == ue)
        return 0;
    if (*uc == '-')
        uc++;
 
    for (; uc < ue; uc++) {
        if (!json_isdigit(*uc))
            break;
        got = 1;
    }
    if (uc == ue)
        goto out;
    if (*uc == '.')
        uc++;
    for (; uc < ue; uc++) {
        if (!json_isdigit(*uc))
            break;
        got = 1;
    }
    if (uc == ue)
        goto out;
    if (got && (*uc == 'e' || *uc == 'E')) {
        uc++;
        got = 0;
        if (uc == ue)
            goto out;
        if (*uc == '+' || *uc == '-')
            uc++;
        for (; uc < ue; uc++) {
            if (!json_isdigit(*uc))
                break;
            got = 1;
        }
    }
out:
    if (!got)
        DPRINTF("Bad number: ", uc, *ucp);
    else
        DPRINTF("Good number: ", uc, *ucp);
    *ucp = uc;
    return got;
}
 
/*ARGSUSED*/
static int
json_parse_const(const unsigned char **ucp, const unsigned char *ue,
    const char *str, size_t len, size_t lvl __file_debugused)
{
    const unsigned char *uc = *ucp;
 
    DPRINTF("Parse const: ", uc, *ucp);
    *ucp += --len - 1;
    if (*ucp > ue)
        *ucp = ue;
    for (; uc < ue && --len;) {
        if (*uc++ != *++str) {
            DPRINTF("Bad const: ", uc, *ucp);
            return 0;
        }
    }
    DPRINTF("Good const: ", uc, *ucp);
    return 1;
}
 
static int
json_parse(const unsigned char **ucp, const unsigned char *ue,
    size_t *st, size_t lvl)
{
    const unsigned char *uc, *ouc;
    int rv = 0;
    int t;
 
    ouc = uc = json_skip_space(*ucp, ue);
    if (uc == ue)
        goto out;
 
    // Avoid recursion
    if (lvl > 500) {
        DPRINTF("Too many levels", uc, *ucp);
        return 0;
    }
#if JSON_COUNT
    /* bail quickly if not counting */
    if (lvl > 1 && (st[JSON_OBJECT] || st[JSON_ARRAYN]))
        return 1;
#endif
 
    DPRINTF("Parse general: ", uc, *ucp);
    switch (*uc++) {
    case '"':
        rv = json_parse_string(&uc, ue, lvl + 1);
        t = JSON_STRING;
        break;
    case '[':
        rv = json_parse_array(&uc, ue, st, lvl + 1);
        t = JSON_ARRAY;
        break;
    case '{': /* '}' */
        rv = json_parse_object(&uc, ue, st, lvl + 1);
        t = JSON_OBJECT;
        break;
    case 't':
        rv = json_parse_const(&uc, ue, "true", sizeof("true"), lvl + 1);
        t = JSON_CONSTANT;
        break;
    case 'f':
        rv = json_parse_const(&uc, ue, "false", sizeof("false"),
            lvl + 1);
        t = JSON_CONSTANT;
        break;
    case 'n':
        rv = json_parse_const(&uc, ue, "null", sizeof("null"), lvl + 1);
        t = JSON_CONSTANT;
        break;
    default:
        --uc;
        rv = json_parse_number(&uc, ue, lvl + 1);
        t = JSON_NUMBER;
        break;
    }
    if (rv)
        st[t]++;
    uc = json_skip_space(uc, ue);
out:
    DPRINTF("End general: ", uc, *ucp);
    *ucp = uc;
    if (lvl == 0) {
        if (!rv)
            return 0;
        if (uc == ue)
            return (st[JSON_ARRAYN] || st[JSON_OBJECT]) ? 1 : 0;
        if (*ouc == *uc && json_parse(&uc, ue, st, 1))
            return (st[JSON_ARRAYN] || st[JSON_OBJECT]) ? 2 : 0;
        else
            return 0;
    }
    return rv;
}
 
#ifndef TEST
int
file_is_json(struct magic_set *ms, const struct buffer *b)
{
    const unsigned char *uc = CAST(const unsigned char *, b->fbuf);
    const unsigned char *ue = uc + b->flen;
    size_t st[JSON_MAX];
    int mime = ms->flags & MAGIC_MIME;
    int jt;
 
 
    if ((ms->flags & (MAGIC_APPLE|MAGIC_EXTENSION)) != 0)
        return 0;
 
    memset(st, 0, sizeof(st));
 
    if ((jt = json_parse(&uc, ue, st, 0)) == 0)
        return 0;
 
    if (mime == MAGIC_MIME_ENCODING)
        return 1;
    if (mime) {
        if (file_printf(ms, "application/%s",
            jt == 1 ? "json" : "x-ndjson") == -1)
            return -1;
        return 1;
    }
    if (file_printf(ms, "%sJSON text data",
        jt == 1 ? "" : "New Line Delimited ") == -1)
        return -1;
#if JSON_COUNT
#define P(n) st[n], st[n] > 1 ? "s" : ""
    if (file_printf(ms, " (%" SIZE_T_FORMAT "u object%s, %" SIZE_T_FORMAT
        "u array%s, %" SIZE_T_FORMAT "u string%s, %" SIZE_T_FORMAT
        "u constant%s, %" SIZE_T_FORMAT "u number%s, %" SIZE_T_FORMAT
        "u >1array%s)",
        P(JSON_OBJECT), P(JSON_ARRAY), P(JSON_STRING), P(JSON_CONSTANT),
        P(JSON_NUMBER), P(JSON_ARRAYN))
        == -1)
        return -1;
#endif
    return 1;
}
 
#else
 
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <err.h>
 
int
main(int argc, char *argv[])
{
    int fd;
    struct stat st;
    unsigned char *p;
    size_t stats[JSON_MAX];
 
    if ((fd = open(argv[1], O_RDONLY)) == -1)
        err(EXIT_FAILURE, "Can't open `%s'", argv[1]);
 
    if (fstat(fd, &st) == -1)
        err(EXIT_FAILURE, "Can't stat `%s'", argv[1]);
 
    if ((p = CAST(char *, malloc(st.st_size))) == NULL)
        err(EXIT_FAILURE, "Can't allocate %jd bytes",
            (intmax_t)st.st_size);
    if (read(fd, p, st.st_size) != st.st_size)
        err(EXIT_FAILURE, "Can't read %jd bytes",
            (intmax_t)st.st_size);
    memset(stats, 0, sizeof(stats));
    printf("is json %d\n", json_parse((const unsigned char **)&p,
        p + st.st_size, stats, 0));
    return 0;
}
#endif