/*
 *
  ***** BEGIN LICENSE BLOCK *****
 
  Copyright (C) 2009-2019 Olof Hagsand
  Copyright (C) 2020-2022 Olof Hagsand and Rubicon Communications, LLC(Netgate)

  This file is part of CLIXON.

  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.

  Alternatively, the contents of this file may be used under the terms of
  the GNU General Public License Version 3 or later (the "GPL"),
  in which case the provisions of the GPL are applicable instead
  of those above. If you wish to allow use of your version of this file only
  under the terms of the GPL, and not to allow others to
  use your version of this file under the terms of Apache License version 2, 
  indicate your decision by deleting the provisions above and replace them with
  the  notice and other provisions required by the GPL. If you do not delete
  the provisions above, a recipient may use your version of this file under
  the terms of any one of the Apache License version 2 or the GPL.

  ***** END LICENSE BLOCK *****

 * JSON support functions.
 * @see http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf
 *  and RFC 7951 JSON Encoding of Data Modeled with YANG
 *  and RFC 8259 The JavaScript Object Notation (JSON) Data Interchange Format
 * XXX: The complexity of xml2json1_cbuf() mapping from internal cxobj structure to JSON output
 * needs a rewrite due to complexity of lists/leaf-lists/null-values, etc.
 */

#ifdef HAVE_CONFIG_H
#include "clixon_config.h" /* generated by config & autoconf */
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <stdint.h>
#include <syslog.h>

/* cligen */
#include <cligen/cligen.h>

/* clixon */
#include "clixon_queue.h"
#include "clixon_string.h"
#include "clixon_hash.h"
#include "clixon_handle.h"
#include "clixon_yang.h"
#include "clixon_xml.h"
#include "clixon_err.h"
#include "clixon_log.h"
#include "clixon_debug.h"
#include "clixon_options.h"
#include "clixon_yang_type.h"
#include "clixon_yang_module.h"
#include "clixon_xml_sort.h"
#include "clixon_xml_bind.h"
#include "clixon_xml_map.h"
#include "clixon_xml_nsctx.h" /* namespace context */
#include "clixon_netconf_lib.h"
#include "clixon_json.h"
#include "clixon_json_parse.h"

/* Let xml2json_cbuf_vec() return json array: [a,b].
   ALternative is to create a pseudo-object and return that: {top:{a,b}}
*/
#define VEC_ARRAY 1

/* Size of json read buffer when reading from file*/
#define BUFLEN 1024

/* Name of xml top object created by parse functions */
#define JSON_TOP_SYMBOL "top"

enum array_element_type{
    NO_ARRAY=0,
    FIRST_ARRAY,  /* [a, */
    MIDDLE_ARRAY, /*  a, */
    LAST_ARRAY,   /*  a] */
    SINGLE_ARRAY, /* [a] */
    BODY_ARRAY
};

enum childtype{
    NULL_CHILD=0, /* eg <a/> no children. Translated to null if in
                   * array or leaf terminal, and to {} if proper object, ie container.
                   * anyxml/anydata?
                   */
    BODY_CHILD,   /* eg one child which is a body, eg <a>1</a> */
    ANY_CHILD,    /* eg <a><b/></a> or <a><b/><c/></a> */
};

/*! x is element and has exactly one child which in turn has none
 *
 * remove attributes from x
 * @see tleaf in clixon_xml_map.c
 */
static enum childtype
child_type(cxobj *x)
{
    cxobj *xc;   /* the only child of x */
    int    clen; /* nr of children */

    clen = xml_child_nr_notype(x, CX_ATTR);
    if (xml_type(x) != CX_ELMNT)
        return -1; /* n/a */
    if (clen == 0)
        return NULL_CHILD;
    if (clen > 1)
        return ANY_CHILD;
    /* From here exactly one noattr child, get it */
    xc = NULL;
    while ((xc = xml_child_each(x, xc, -1)) != NULL)
        if (xml_type(xc) != CX_ATTR)
            break;
    if (xc == NULL)
        return -2; /* n/a */
    if (xml_child_nr_notype(xc, CX_ATTR) == 0 && xml_type(xc)==CX_BODY)
        return BODY_CHILD;
    else
        return ANY_CHILD;
}

static char*
childtype2str(enum childtype lt)
{
    switch(lt){
    case NULL_CHILD:
        return "null";
        break;
    case BODY_CHILD:
        return "body";
        break;
    case ANY_CHILD:
        return "any";
        break;
    }
    return "";
}

static char*
arraytype2str(enum array_element_type lt)
{
    switch(lt){
    case NO_ARRAY:
        return "no";
        break;
    case FIRST_ARRAY:
        return "first";
        break;
    case MIDDLE_ARRAY:
        return "middle";
        break;
    case LAST_ARRAY:
        return "last";
        break;
    case SINGLE_ARRAY:
        return "single";
        break;
    case BODY_ARRAY:
        return "body";
        break;
    }
    return "";
}

/*! Check typeof x in array
 *
 * Check if element is in an array, and if so, if it is in the start "[x,", in the middle: "[..,x,..]"
 * in the end: ",x]", or a single element: "[x]"
 * Some complexity when x is in different namespaces
 * @param[in]  xprev     The previous element (if any)
 * @param[in]  x         The element itself
 * @param[in]  xnext     The next element (if any)
 * @retval     arraytype Type of array
 */
static enum array_element_type
array_eval(cxobj *xprev,
           cxobj *x,
           cxobj *xnext)
{
    enum array_element_type arraytype = NO_ARRAY;
    int                     eqprev=0;
    int                     eqnext=0;
    yang_stmt              *ys;
    char                   *nsx; /* namespace of x */
    char                   *ns2;

    nsx = xml_find_type_value(x, NULL, "xmlns", CX_ATTR);
    if (xml_type(x) != CX_ELMNT){
        arraytype = BODY_ARRAY;
        goto done;
    }
    if (xnext &&
        xml_type(xnext)==CX_ELMNT &&
        strcmp(xml_name(x), xml_name(xnext))==0){
        ns2 = xml_find_type_value(xnext, NULL, "xmlns", CX_ATTR);
        if ((!nsx && !ns2)
            || (nsx && ns2 && strcmp(nsx,ns2)==0))
            eqnext++;
    }
    if (xprev &&
        xml_type(xprev)==CX_ELMNT &&
        strcmp(xml_name(x),xml_name(xprev))==0){
        ns2 = xml_find_type_value(xprev, NULL, "xmlns", CX_ATTR);
        if ((!nsx && !ns2)
            || (nsx && ns2 && strcmp(nsx,ns2)==0))
            eqprev++;
    }
    if (eqprev && eqnext)
        arraytype = MIDDLE_ARRAY;
    else if (eqprev)
        arraytype = LAST_ARRAY;
    else if (eqnext)
        arraytype = FIRST_ARRAY;
    else if ((ys = xml_spec(x)) != NULL) {
        if (yang_keyword_get(ys) == Y_LIST || yang_keyword_get(ys) == Y_LEAF_LIST)
            arraytype = SINGLE_ARRAY;
        else
            arraytype = NO_ARRAY;
    }
    else
        arraytype = NO_ARRAY;
 done:
    return arraytype;
}

/*! Escape a json string as well as decode xml cdata
 *
 * @param[out] cb   cbuf   (encoded)
 * @param[in]  str  string (unencoded)
 * @retval     0    OK
 */
static int
json_str_escape_cdata(cbuf *cb,
                      char *str)
{
    int    retval = -1;
    size_t len;
    int    i;

    len = strlen(str);
    for (i=0; i<len; i++)
        switch (str[i]){
        case '\"':
            cprintf(cb, "\\\"");
            break;
        case '\\':
            cprintf(cb, "\\\\");
            break;
        case '\b':
            cprintf(cb, "\\b");
            break;
        case '\f':
            cprintf(cb, "\\f");
            break;
        case '\n':
            cprintf(cb, "\\n");
            break;
        case '\r':
            cprintf(cb, "\\r");
            break;
        case '\t':
            cprintf(cb, "\\t");
            break;
        default: /* fall thru */
            cprintf(cb, "%c", str[i]);
            break;
        }
    retval = 0;
    // done:
    return retval;
}

/*! Decode types from JSON to XML identityrefs
 *
 * Assume an xml tree where prefix:name have been split into "module":"name"
 * In other words, from JSON RFC7951 to XML namespace trees
 * @param[in]     x     XML tree. Must be yang populated.
 * @param[in]     yspec Yang spec
 * @param[out]    xerr  Reason for invalid tree returned as netconf err msg or NULL
 * @retval        1     OK
 * @retval        0     Invalid, wrt namespace.  xerr set
 * @retval       -1     Error
 * @see RFC7951 Sec 4 and 6.8
 */
static int
json2xml_decode_identityref(cxobj     *x,
                            yang_stmt *y,
                            cxobj    **xerr)
{
    int        retval = -1;
    char      *ns;
    char      *body;
    cxobj     *xb;
    char      *prefix = NULL;
    char      *id = NULL;
    yang_stmt *ymod;
    yang_stmt *yspec;
    cvec      *nsc = NULL;
    char      *prefix2 = NULL;
    cbuf      *cbv = NULL;

    clixon_debug(CLIXON_DBG_DEFAULT, "");
    yspec = ys_spec(y);
    if ((xb = xml_body_get(x)) == NULL)
        goto ok;
    body = xml_value(xb);
    if (nodeid_split(body, &prefix, &id) < 0)
        goto done;
    /* prefix is a module name -> find module */
    if (prefix){
        if ((ymod = yang_find_module_by_name(yspec, prefix)) != NULL){
            ns = yang_find_mynamespace(ymod);
            /* Is this namespace in the xml context?
             * (yes) use its prefix (unless it is NULL)
             * (no)  insert a xmlns:<prefix> statement
             * Get the whole namespace context from x
             */
            if (xml_nsctx_node(x, &nsc) < 0)
                goto done;
            clixon_debug(CLIXON_DBG_DEFAULT, "prefix:%s body:%s namespace:%s",
                         prefix, body, ns);
            if (!xml_nsctx_get_prefix(nsc, ns, &prefix2)){
                /* (no)  insert a xmlns:<prefix> statement
                 * Get yang prefix from import statement of my mod
                 * I am not sure this is correct
                 */
                if (yang_find_prefix_by_namespace(y, ns, &prefix2) < 0)
                    goto done;
                /* if prefix2 is NULL here, we get the canonical prefix */
                if (prefix2 == NULL)
                    prefix2 = yang_find_myprefix(ymod);
                /* Add "xmlns:prefix2=namespace" */
                if (xml_add_attr(x, prefix2, ns, "xmlns", NULL) == NULL)
                    goto done;

            }
            /* Here prefix2 is valid and can be NULL
               Change body prefix to prefix2:id */
            if ((cbv = cbuf_new()) == NULL){
                clixon_err(OE_JSON, errno, "cbuf_new");
                goto done;
            }
            if (prefix2)
                cprintf(cbv, "%s:%s", prefix2, id);
            else
                cprintf(cbv, "%s", id);

            if (xml_value_set(xb, cbuf_get(cbv)) < 0)
                goto done;
        }
        else{
            if (xerr && netconf_unknown_namespace_xml(xerr, "application",
                                                      prefix,
                                                      "No module corresponding to prefix") < 0)
                goto done;
            goto fail;
        }
    } /* prefix */
 ok:
    retval = 1;
 done:
    if (prefix)
        free(prefix);
    if (id)
        free(id);
    if (nsc)
        xml_nsctx_free(nsc);
    if (cbv)
        cbuf_free(cbv);
    return retval;
 fail:
    retval = 0;
    goto done;
}

/*! Decode leaf/leaf_list types from JSON to XML after parsing and yang
 *
 * Assume an xml tree where prefix:name have been split into "module":"name"
 * In other words, from JSON RFC7951 to XML namespace trees
 *
 * @param[in]     x     XML tree. Must be yang populated. After json parsing
 * @param[in]     yspec Yang spec
 * @param[out]    xerr  Reason for invalid tree returned as netconf err msg or NULL
 * @retval        1     OK
 * @retval        0     Invalid, wrt namespace.  xerr set
 * @retval       -1     Error
 * @see RFC7951 Sec 4 and 6.8
 */
int
json2xml_decode(cxobj     *x,
                cxobj    **xerr)
{
    int           retval = -1;
    yang_stmt    *y;
    enum rfc_6020 keyword;
    cxobj        *xc;
    int           ret;
    yang_stmt    *ytype = NULL;

    if ((y = xml_spec(x)) != NULL){
        keyword = yang_keyword_get(y);
        if (keyword == Y_LEAF || keyword == Y_LEAF_LIST){
            if (yang_type_get(y, NULL, &ytype, NULL, NULL, NULL, NULL, NULL) < 0)
                goto done;

            if (ytype){
                if (strcmp(yang_argument_get(ytype), "identityref")==0){
                    if ((ret = json2xml_decode_identityref(x, y, xerr)) < 0)
                        goto done;
                    if (ret == 0)
                        goto fail;
                }
                else if (strcmp(yang_argument_get(ytype), "empty")==0)
                    ; /* dont need to do anything */
            }
        }
    }
    xc = NULL;
    while ((xc = xml_child_each(x, xc, CX_ELMNT)) != NULL){
        if ((ret = json2xml_decode(xc, xerr)) < 0)
            goto done;
        if (ret == 0)
            goto fail;
    }
    retval = 1;
 done:
    return retval;
 fail:
    retval = 0;
    goto done;
}

/*! Encode leaf/leaf_list identityref type from XML to JSON
 *
 * @param[in]   x    XML body node
 * @param[in]   body body string
 * @param[in]   ys   Yang spec of parent
 * @param[out]  cb   Encoded string
 * @retval      0    OK
 * @retval     -1    Error
 */
static int
xml2json_encode_identityref(cxobj     *xb,
                            char      *body,
                            yang_stmt *yp,
                            cbuf      *cb)
{
    int        retval = -1;
    char      *prefix = NULL;
    char      *id = NULL;
    char      *namespace = NULL;
    yang_stmt *ymod;
    yang_stmt *yspec;
    yang_stmt *my_ymod;

    clixon_debug(CLIXON_DBG_DEFAULT, "%s", body);
    my_ymod = ys_module(yp);
    yspec = ys_spec(yp);
    if (nodeid_split(body, &prefix, &id) < 0)
        goto done;
    /* prefix is xml local -> get namespace */
    if (xml2ns(xb, prefix, &namespace) < 0)
        goto done;
    /* We got the namespace, now get the module */
    if ((ymod = yang_find_module_by_namespace(yspec, namespace)) != NULL){
        if (ymod == my_ymod)
            cprintf(cb, "%s", id);
        else{
            cprintf(cb, "%s:%s", yang_argument_get(ymod), id);
        }
    }
    else
        cprintf(cb, "%s", id);
    retval = 0;
 done:
    if (prefix)
        free(prefix);
    if (id)
        free(id);
    return retval;
}

/*! Encode leaf/leaf_list types from XML to JSON
 *
 * @param[in]   xb   XML body
 * @param[in]   xp   XML parent
 * @param[in]   yp   Yang spec of parent
 * @param[out]  cb0  Encoded string
 * @retval      0    OK
 * @retval     -1    Error
 */
static int
xml2json_encode_leafs(cxobj     *xb,
                      cxobj     *xp,
                      yang_stmt *yp,
                      cbuf      *cb0)
{
    int           retval = -1;
    enum rfc_6020 keyword;
    yang_stmt    *ytype;
    char         *restype;  /* resolved type */
    char         *origtype=NULL;   /* original type */
    char         *body;
    enum cv_type  cvtype;
    int           quote = 1; /* Quote value w string: "val" */
    cbuf         *cb = NULL; /* the variable itself */

    if ((cb = cbuf_new()) ==NULL){
        clixon_err(OE_XML, errno, "cbuf_new");
        goto done;
    }
    body = xb?xml_value(xb):NULL;
    if (yp == NULL){
        cprintf(cb, "%s", body?body:"null");
        goto ok; /* unknown */
    }
    keyword = yang_keyword_get(yp);
    switch (keyword){
    case Y_LEAF:
    case Y_LEAF_LIST:
        if (yang_type_get(yp, &origtype, &ytype, NULL, NULL, NULL, NULL, NULL) < 0)
            goto done;
        restype = ytype?yang_argument_get(ytype):NULL;
        cvtype = yang_type2cv(yp);
        switch (cvtype){
        case CGV_STRING:
        case CGV_REST:
            if (body==NULL)
                ; /* empty: "" */
            else if (ytype){
                if (strcmp(restype, "identityref")==0){
                    if (xml2json_encode_identityref(xb, body, yp, cb) < 0)
                        goto done;
                }
                else{
                    cprintf(cb, "%s", body);
                }
            }
            else
                cprintf(cb, "%s", body);
            break;
        case CGV_INT64:
        case CGV_UINT64:
        case CGV_DEC64:
            // [RFC7951] JSON Encoding of YANG Data
            // 6.1 Numeric Types - A value of the "int64", "uint64", or "decimal64" type is represented as a JSON string
            if (yang_keyword_get(yp) == Y_LEAF_LIST && xml_child_nr_type(xml_parent(xp), CX_ELMNT) == 1) {
                cprintf(cb, "[%s]", body);
            }
            else {
                cprintf(cb, "%s", body);
            }
            quote = 1;
            break;
        case CGV_INT8:
        case CGV_INT16:
        case CGV_INT32:
        case CGV_UINT8:
        case CGV_UINT16:
        case CGV_UINT32:
        case CGV_BOOL:
            cprintf(cb, "%s", body);
            quote = 0;
            break;
        case CGV_VOID:
            /* special case YANG empty type */
            if (body == NULL && strcmp(restype, "empty")==0){
                quote = 0;
                if (keyword == Y_LEAF)
                    cprintf(cb, "[null]");
                else if (keyword == Y_LEAF_LIST && strcmp(restype, "empty") == 0)
                    cprintf(cb, "[null]");
                else
                    cprintf(cb, "null");
            }
            break;
        default:
            if (body)
                cprintf(cb, "%s", body);
            else
                cprintf(cb, "{}"); /* dont know */
        }
        break;
    default:
        cprintf(cb, "%s", body);
        break;
    }
 ok:
    /* write into original cb0
     * includign quoting and encoding
     */
    if (quote){
        cprintf(cb0, "\"");
        json_str_escape_cdata(cb0, cbuf_get(cb));
    }
    else
        cprintf(cb0, "%s", cbuf_get(cb));
    if (quote)
        cprintf(cb0, "\"");
    retval = 0;
 done:
    if (cb)
        cbuf_free(cb);
    if (origtype)
        free(origtype);
    return retval;
}

/*! Check if X has no XML child - no body.
 *
 * If x is a container, use {} instead of null
 * if leaf or leaf-list then assume EMPTY type, then [null]
 * else null
 */
static int
nullchild(cbuf      *cb,
          cxobj     *x,
          yang_stmt *y)
{
    int           retval = -1;

    if (y == NULL){
        /* This is very problematic.
         * RFC 7951 explicitly forbids "null" to be used unless for empty types in [null]
         */
        cprintf(cb, "{}");
    }
    else{
        switch (yang_keyword_get(y)){
        case Y_ANYXML:
        case Y_ANYDATA:
        case Y_CONTAINER:
            cprintf(cb, "{}");
            break;
        case Y_LEAF:
        case Y_LEAF_LIST:
            if (xml2json_encode_leafs(NULL, x, y, cb) < 0)
                goto done;
            break;
        default:
            /* This is very problematic.
             * RFC 7951 explicitly forbids "null" to be used unless for empty types in [null]
             */
            cprintf(cb, "{}");
            break;
        }
    }
    retval = 0;
 done:
    return retval;
}

/*! Encode json metadata
 *
 * This function could be more general, code based on two examples:
 * 1) ietf-list-pagination:remaining
 *  {
 *     "example-social:uint8-numbers": [17],
 *     "@example-social:uint8-numbers": [
 *        {
 *           "ietf-list-pagination:remaining": 5
 *        }
 *      ]
 *    }
 * 2) ietf-netconf-with-defaults:default:
 *     "@mtu" : {
 *          "ietf-netconf-with-defaults:default" : true
 *      },
 */
static int
json_metadata_encoding(cbuf  *cb,
                       cxobj *x,
                       int    level,
                       int    pretty,
                       char  *prefix,
                       char  *name,
                       char  *modname2,
                       char  *name2,
                       char  *val,
                       int    list)
{
    cprintf(cb, ",\"@");
    if (prefix)
        cprintf(cb, "%s:", prefix);
    cprintf(cb, "%s\":", name);
    if (list)
        cprintf(cb, "[");
    cprintf(cb, "%*s", pretty?((level+1)*PRETTYPRINT_INDENT):0, "{");
    cprintf(cb, "\"%s:%s\":%s", modname2, name2, val);
    cprintf(cb, "%*s", pretty?((level+1)*PRETTYPRINT_INDENT):0, "}");
    if (list)
        cprintf(cb, "%*s", pretty?(level*PRETTYPRINT_INDENT):0, "]");
    return 0;
}

/*! Encode XML attributes as JSON meta-data
 *
 * There are two methods for this:
 * 1) Registered meta-data according to RFC 7952 using md:annotate.
 *    This is derived from a YANG module
 *    Examples: ietf-origin:origin, ietf-list-pagination: remaining
 * 2) Assigned, if someother mechanism, eg XSD is used
 *    Example: ietf-restconf: default
 * If neither matches, the attribute is skipped
 * @param[in]     xc       XML attribute
 * @param[in]     xp       XML node, parent of xa
 * @param[in]     yp       Yang spec of xp
 * @param[in]     level    Indentation level
 * @param[in]     pretty   Pretty-print output (2 means debug)
 * @param[in]     modname  Name of yang module
 * @param[in,out] metacb   Encode into cbuf
 * @retval        0        OK
 * @retval       -1        Error
 * @see RFC7952
 */
static int
xml2json_encode_attr(cxobj     *xa,
                     cxobj     *xp,
                     yang_stmt *yp,
                     int        level,
                     int        pretty,
                     char      *modname,
                     cbuf      *metacb)
{
    int           retval = -1;
    int           ismeta = 0;
    char         *namespace = NULL;
    yang_stmt    *ymod;
    enum rfc_6020 ykeyw;

    if (xml2ns(xa, xml_prefix(xa), &namespace) < 0)
        goto done;
    /* Check for (1) registered meta-data */
    if (namespace != NULL && yp){
        ykeyw = yang_keyword_get(yp);
        if ((ymod = yang_find_module_by_namespace(ys_spec(yp), namespace)) != NULL){
            if (yang_metadata_annotation_check(xa, ymod, &ismeta) < 0)
                goto done;
            if (ismeta)
                if (json_metadata_encoding(metacb, xp, level, pretty,
                                           modname, xml_name(xp),
                                           yang_argument_get(ymod),
                                           xml_name(xa),
                                           xml_value(xa),
                                           ykeyw == Y_LEAF_LIST || ykeyw == Y_LIST) < 0)
                    goto done;
        }
        /* Check for (2) assigned - hardcoded for now */
        else if (strcmp(namespace, "urn:ietf:params:xml:ns:netconf:default:1.0") == 0 &&
                 strcmp(xml_name(xa), "default") == 0){
            /* RFC 7952 / RFC 8040 defaults attribute */
            if (json_metadata_encoding(metacb, xp, level, pretty,
                                       modname, xml_name(xp),
                                       "ietf-netconf-with-defaults",
                                       xml_name(xa),
                                       xml_value(xa),
                                       ykeyw == Y_LEAF_LIST || ykeyw == Y_LIST) < 0)
                goto done;
        }
    }
    retval = 0;
 done:
    return retval;
}

/*! Do the actual work of translating XML to JSON
 *
 * @param[out]  cb        Cligen text buffer containing json on exit
 * @param[in]   x         XML tree structure containing XML to translate
 * @param[in]   arraytype Does x occur in a array (of its parent) and how?
 * @param[in]   level     Indentation level
 * @param[in]   pretty    Pretty-print output (2 means debug)
 * @param[in]   flat      Dont print NO_ARRAY object name (for _vec call)
 * @param[in]   system_only Enable checks for system-only-config extension
 * @param[in]   modname0
 * @param[out]  metacbp   Meta encoding of attribute
 * @retval      0         OK
 * @retval     -1         Error
 *
 * @note Does not work with XML attributes
 * The following matrix explains how the mapping is done.
 * You need to understand what arraytype means (no/first/middle/last)
 * and what childtype is (null,body,any)
  +----------+--------------+--------------+--------------+
  |array,leaf| null         | body         | any          |
  +----------+--------------+--------------+--------------+
  |no        | <a/>         |<a>1</a>      |<a><b/></a>   |
  |          |              |              |              |
  |  json:   |\ta:null      |\ta:          |\ta:{\n       |
  |          |              |              |\n}           |
  +----------+--------------+--------------+--------------+
  |first     |<a/><a..      |<a>1</a><a..  |<a><b/></a><a.|
  |          |              |              |              |
  |  json:   |\ta:[\n\tnull |\ta:[\n\t     |\ta:[\n\t{\n  |
  |          |              |              |\n\t}         |
  +----------+--------------+--------------+--------------+
  |middle    |..a><a/><a..  |.a><a>1</a><a.|              |
  |          |              |              |              |
  |  json:   |\tnull        |\t            |\t{a          |
  |          |              |              |\n\t}         |
  +----------+--------------+--------------+--------------+
  |last      |..a></a>      |..a><a>1</a>  |              |
  |          |              |              |              |
  |  json:   |\tnull        |\t            |\t{a          |
  |          |\n\t]         |\n\t]         |\n\t}\t]      |
  +----------+--------------+--------------+--------------+
 */
static int
xml2json1_cbuf(cbuf                   *cb,
               cxobj                  *x,
               enum array_element_type arraytype,
               int                     level,
               int                     pretty,
               int                     flat,
               int                     system_only,
               char                   *modname0,
               cbuf                   *metacbp)
{
    int              retval = -1;
    int              i;
    cxobj           *xc;
    cxobj           *xp;
    enum childtype   childt;
    enum array_element_type xc_arraytype;
    yang_stmt       *yc;
    yang_stmt       *ys;
    yang_stmt       *ymod = NULL; /* yang module */
    int              commas;
    char            *modname = NULL;
    cbuf            *metacbc = NULL;
    int              exist;

    if ((ys = xml_spec(x)) != NULL){
        if (ys_real_module(ys, &ymod) < 0)
            goto done;
        modname = yang_argument_get(ymod);
        /* Special case for ietf-netconf -> ietf-restconf translation
         * A special case is for return data on the form {"data":...}
         * See also json_xmlns_translate()
         */
        if (strcmp(modname, "ietf-netconf") == 0)
            modname = "ietf-restconf";
        if (modname0 && strcmp(modname, modname0) == 0)
            modname=NULL;
        else
            modname0 = modname; /* modname0 is ancestor ns passed to child */
    }
    childt = child_type(x);
    if (pretty==2)
        cprintf(cb, "#%s_array, %s_child ",
                arraytype2str(arraytype),
                childtype2str(childt));
    switch(arraytype){
    case BODY_ARRAY: /* Only place in fn where body is printed (except nullchild) */
        xp = xml_parent(x);
        if (xml2json_encode_leafs(x, xp, xml_spec(xp), cb) < 0)
            goto done;
        break;
    case NO_ARRAY:
        if (!flat){
            cprintf(cb, "%*s\"", pretty?(level*PRETTYPRINT_INDENT):0, "");
            if (modname)
                cprintf(cb, "%s:", modname);
            cprintf(cb, "%s\":%s", xml_name(x), pretty?" ":"");
        }
        switch (childt){
        case NULL_CHILD:
            if (nullchild(cb, x, ys) < 0)
                goto done;
            break;
        case BODY_CHILD:
            break;
        case ANY_CHILD:
            cprintf(cb, "{%s", pretty?"\n":"");
            break;
        default:
            break;
        }
        break;
    case FIRST_ARRAY:
    case SINGLE_ARRAY:
        cprintf(cb, "%*s\"", pretty?(level*PRETTYPRINT_INDENT):0, "");
        if (modname)
            cprintf(cb, "%s:", modname);
        cprintf(cb, "%s\":%s", xml_name(x), pretty?" ":"");
        level++;
        cprintf(cb, "[%s%*s",
                pretty?"\n":"",
                pretty?(level*PRETTYPRINT_INDENT):0, "");
        switch (childt){
        case NULL_CHILD:
            if (nullchild(cb, x, ys) < 0)
                goto done;
            break;
        case BODY_CHILD:
            break;
        case ANY_CHILD:
            cprintf(cb, "{%s", pretty?"\n":"");
            break;
        default:
            break;
        }
        break;
    case MIDDLE_ARRAY:
    case LAST_ARRAY:
        level++;
        cprintf(cb, "%*s",
                pretty?(level*PRETTYPRINT_INDENT):0, "");
        switch (childt){
        case NULL_CHILD:
            if (nullchild(cb, x, ys) < 0)
                goto done;
            break;
        case BODY_CHILD:
            break;
        case ANY_CHILD:
            cprintf(cb, "{%s", pretty?"\n":"");
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }
    if ((metacbc = cbuf_new()) == NULL){
        clixon_err(OE_UNIX, errno, "cbuf_new");
        goto done;
    }
    /* Check for typed sub-body if:
     * arraytype=* but child-type is BODY_CHILD
     * This is code for writing <a>42</a> as "a":42 and not "a":"42"
     */
    commas = xml_child_nr_notype(x, CX_ATTR) - 1;
    for (i=0; i<xml_child_nr(x); i++){
        xc = xml_child_i(x, i);
        if (xml_type(xc) == CX_ATTR){
            if (metacbp &&
                xml2json_encode_attr(xc, x, ys, level, pretty, modname, metacbp) < 0)
                goto done;
            continue;
        }
        xc_arraytype = array_eval(i?xml_child_i(x,i-1):NULL,
                                  xc,
                                  xml_child_i(x, i+1));
        exist = 0;
        if ((yc = xml_spec(xc)) != NULL && system_only){
            if (yang_extension_value(yc, "system-only-config", CLIXON_LIB_NS, &exist, NULL) < 0)
                goto done;
            if (exist && commas)
                commas--;
        }
        if (!exist) {
            if (xml2json1_cbuf(cb,
                               xc,
                               xc_arraytype,
                               level+1, pretty, 0, system_only, modname0,
                               metacbc) < 0)
                goto done;
            if (commas > 0) {
                cprintf(cb, ",%s", pretty?"\n":"");
                --commas;
            }
        }
    }
    if (cbuf_len(metacbc)){
        cprintf(cb, "%s", cbuf_get(metacbc));
    }
    switch (arraytype){
    case BODY_ARRAY:
        break;
    case NO_ARRAY:
        switch (childt){
        case NULL_CHILD:
        case BODY_CHILD:
            break;
        case ANY_CHILD:
            cprintf(cb, "%s%*s}",
                    pretty?"\n":"",
                    pretty?(level*PRETTYPRINT_INDENT):0, "");
            break;
        default:
            break;
        }
        level--;
        break;
    case FIRST_ARRAY:
    case MIDDLE_ARRAY:
        switch (childt){
        case NULL_CHILD:
        case BODY_CHILD:
            break;
        case ANY_CHILD:
            cprintf(cb, "%s%*s}",
                    pretty?"\n":"",
                    pretty?(level*PRETTYPRINT_INDENT):0, "");
            level--;
            break;
        default:
            break;
        }
        break;
    case SINGLE_ARRAY:
    case LAST_ARRAY:
        switch (childt){
        case NULL_CHILD:
        case BODY_CHILD:
            cprintf(cb, "%s",pretty?"\n":"");
            break;
        case ANY_CHILD:
            cprintf(cb, "%s%*s}",
                    pretty?"\n":"",
                    pretty?(level*PRETTYPRINT_INDENT):0, "");
            cprintf(cb, "%s",pretty?"\n":"");
            level--;
            break;
        default:
            break;
        }
        cprintf(cb, "%*s]",
                pretty?(level*PRETTYPRINT_INDENT):0,"");
        break;
    default:
        break;
    }
    retval = 0;
 done:
    if (metacbc)
        cbuf_free(metacbc);
    return retval;
}

/*! Translate an XML tree to JSON in a CLIgen buffer
 *
 * XML-style namespace notation in tree, but RFC7951 in output assume yang
 * populated
 * @param[in,out] cb          Cligen buffer to write to
 * @param[in]     x           XML tree to translate from
 * @param[in]     pretty      Set if output is pretty-printed
 * @param[in]     autocliext  How to handle autocli extensions: 0: ignore 1: follow
 * @param[in]     system_only Enable checks for system-only-config extension
 * @retval        0           OK
 * @retval       -1           Error
 *
 * @see clixon_xml2cbuf     XML corresponding function
 * @see xml2json_cbuf_vec   Top symbol is list
 */
static int
xml2json_cbuf1(cbuf  *cb,
               cxobj *x,
               int    pretty,
               int    autocliext,
               int    system_only)
{
    int                     retval = 1;
    int                     level = 0;
    yang_stmt              *y;
    enum array_element_type arraytype = NO_ARRAY;
    int                     exist = 0;

    y = xml_spec(x);
    if (autocliext && y != NULL) {
        if (yang_extension_value(y, "hide-show", CLIXON_AUTOCLI_NS, &exist, NULL) < 0)
            goto done;
        if (exist)
            goto ok;
    }

    cprintf(cb, "%*s{%s",
            pretty?level*PRETTYPRINT_INDENT:0,"",
            pretty?"\n":"");
    if (y != NULL){
        switch (yang_keyword_get(y)){
        case Y_LEAF_LIST:
        case Y_LIST:
            arraytype = SINGLE_ARRAY;
            break;
        default:
            arraytype = NO_ARRAY;
            break;
        }
    }
    if (xml2json1_cbuf(cb,
                       x,
                       arraytype,
                       level+1,
                       pretty,
                       0,
                       system_only,
                       NULL, /* ancestor modname / namespace */
                       NULL) < 0)
        goto done;
    cprintf(cb, "%s%*s}%s",
            pretty?"\n":"",
            pretty?level*PRETTYPRINT_INDENT:0,"",
            pretty?"\n":"");
 ok:
    retval = 0;
 done:
    return retval;
}

/*! Translate an XML tree to JSON in a CLIgen buffer skip top-level object
 *
 * XML-style namespace notation in tree, but RFC7951 in output assume yang
 * populated 
 * @param[in,out] cb          Cligen buffer to write to
 * @param[in]     xt          Top-level xml object
 * @param[in]     pretty      Set if output is pretty-printed
 * @param[in]     skiptop     0: Include top object 1: Skip top-object, only children,
 * @param[in]     autocliext  How to handle autocli extensions: 0: ignore 1: follow
 * @param[in]     system_only Enable checks for system-only-config extension
 * @retval        0           OK
 * @retval       -1           Error
 * @code
 *   cbuf *cb = cbuf_new();
 *   if (xml2json_cbuf(cb, xn, 0, 0, 0) < 0)
 *     goto err;
 *   cbuf_free(cb);
 * @endcode
 * @see xml2json_cbuf where the top level object is included
 */
int
clixon_json2cbuf(cbuf  *cb,
                 cxobj *xt,
                 int    pretty,
                 int    skiptop,
                 int    autocliext,
                 int    system_only)
{
    int    retval = -1;
    cxobj *xc;
    int    i=0;

    if (skiptop){
        xc = NULL;
        while ((xc = xml_child_each(xt, xc, CX_ELMNT)) != NULL){
            if (i++)
                cprintf(cb, ",");
            if (xml2json_cbuf1(cb, xc, pretty, autocliext, system_only) < 0)
                goto done;
        }
    }
    else {
        if (xml2json_cbuf1(cb, xt, pretty, autocliext, system_only) < 0)
            goto done;
    }
    retval = 0;
 done:
    return retval;
}

/*! Translate a vector of xml objects to JSON Cligen buffer.
 *
 * This is done by adding a top pseudo-object, and add the vector as subs,
 * and then not printing the top pseudo-object using the 'flat' option.
 * @param[out] cb     Cligen buffer to write to
 * @param[in]  vec    Vector of xml objecst
 * @param[in]  veclen Length of vector
 * @param[in]  pretty Set if output is pretty-printed (2 for debug)
 * @param[in]  skiptop 0: Include top object 1: Skip top-object, only children,
 * @retval     0      OK
 * @retval    -1      Error
 * @note This only works if the vector is uniform, ie same object name.
 * Example: <b/><c/> --> <a><b/><c/></a> --> {"b" : null,"c" : null}
 * @see clixon_json2cbuf
 */
int
xml2json_cbuf_vec(cbuf      *cb,
                  cxobj    **vec,
                  size_t     veclen,
                  int        pretty,
                  int        skiptop)
{
    int    retval = -1;
    int    level = 0;
    cxobj *xp = NULL;
    int    i;
    cxobj *xc0;
    cxobj *xc;
    cvec  *nsc = NULL;

    if ((xp = xml_new("xml2json", NULL, CX_ELMNT)) == NULL)
        goto done;
    /* Make a copy of old and graft it into new top-object
     * Also copy namespace context */
    for (i=0; i<veclen; i++){
        xc0 = vec[i];
        if (xml_nsctx_node(xc0, &nsc) < 0)
            goto done;
        if (skiptop){
            cxobj *x = NULL;
            while ((x = xml_child_each(xc0, x, CX_ELMNT)) != NULL) {
                if ((xc = xml_dup(x)) == NULL)
                    goto done;
                xml_addsub(xp, xc);
                xmlns_set_all(xc, nsc); // ?
            }
            cvec_free(nsc);
        }
        else {
            if ((xc = xml_dup(xc0)) == NULL)
                goto done;
            xml_addsub(xp, xc);
            nscache_replace(xc, nsc);
        }
        nsc = NULL; /* nsc consumed */
    }
    if (0){
        cprintf(cb, "[%s", pretty?"\n":" ");
        level++;
    }
    if (xml2json1_cbuf(cb,
                       xp,
                       NO_ARRAY,
                       level,
                       pretty,
                       1, 0, NULL, NULL) < 0)
        goto done;

    if (0){
        level--;
        cprintf(cb, "%s]%s",
                pretty?"\n":"",
                pretty?"\n":""); /* top object */
    }
    retval = 0;
 done:
    if (nsc)
        xml_nsctx_free(nsc);
    if (xp)
        xml_free(xp);
    return retval;
}

/*! Translate from xml tree to JSON and print to file using a callback
 *
 * @param[in]  f           File to print to
 * @param[in]  xn          XML tree to translate from
 * @param[in]  pretty      Set if output is pretty-printed
 * @param[in]  fn          File print function
 * @param[in]  skiptop 0:  Include top object 1: Skip top-object, only children,
 * @param[in]  autocliext  How to handle autocli extensions: 0: ignore 1: follow
 * @param[in]  system_only Enable checks for system-only-config extension
 * @retval     0           OK
 * @retval    -1           Error
 *
 * @note yang is necessary to translate to one-member lists,
 * eg if a is a yang LIST <a>0</a> -> {"a":["0"]} and not {"a":"0"}
 * @code
 * if (clixon_json2file(stderr, xn, 0, fprintf, 0, 0, 0) < 0)
 *   goto err;
 * @endcode
 */
int
clixon_json2file(FILE             *f,
                 cxobj            *xn,
                 int               pretty,
                 clicon_output_cb *fn,
                 int               skiptop,
                 int               autocliext,
                 int               system_only)
{
    int   retval = 1;
    cbuf *cb = NULL;

    if (fn == NULL)
        fn = fprintf;
    if ((cb = cbuf_new()) ==NULL){
        clixon_err(OE_XML, errno, "cbuf_new");
        goto done;
    }
    if (clixon_json2cbuf(cb, xn, pretty, skiptop, autocliext, system_only) < 0)
        goto done;
    (*fn)(f, "%s", cbuf_get(cb));
    retval = 0;
 done:
    if (cb)
        cbuf_free(cb);
    return retval;
}

/*! Print an XML tree structure to an output stream as JSON
 *
 * @param[in]   f           UNIX output stream
 * @param[in]   xn          clicon xml tree
 */
int
json_print(FILE  *f,
           cxobj *x)
{
    return clixon_json2file(f, x, 1, fprintf, 0, 0, 0);
}

/*! Translate a vector of xml objects to JSON File.
 *
 * This is done by adding a top pseudo-object, and add the vector as subs,
 * and then not pritning the top pseudo-.object using the 'flat' option.
 * @param[out] cb     Cligen buffer to write to
 * @param[in]  vec    Vector of xml objecst
 * @param[in]  veclen Length of vector
 * @param[in]  pretty Set if output is pretty-printed (2 for debug)
 * @param[in]  fn       File print function
 * @param[in]  skiptop 0: Include top object 1: Skip top-object, only children,
 * @retval     0      OK
 * @retval    -1      Error
 * @note This only works if the vector is uniform, ie same object name.
 * Example: <b/><c/> --> <a><b/><c/></a> --> {"b" : null,"c" : null}
 * @see xml2json1_cbuf
 */
int
xml2json_vec(FILE             *f,
             cxobj           **vec,
             size_t            veclen,
             int               pretty,
             clicon_output_cb *fn,
             int               skiptop)
{
    int   retval = 1;
    cbuf *cb = NULL;

    if ((cb = cbuf_new()) == NULL){
        clixon_err(OE_XML, errno, "cbuf_new");
        goto done;
    }
    if (xml2json_cbuf_vec(cb, vec, veclen, pretty, skiptop) < 0)
        goto done;
    (*fn)(f, "%s\n", cbuf_get(cb));
    retval = 0;
 done:
    if (cb)
        cbuf_free(cb);
    return retval;
}

/*! Translate from JSON module:name to XML default ns: xmlns="uri" recursively
 *
 * Assume an xml tree where prefix:name have been split into "module":"name"
 * In other words, from JSON to XML namespace trees
 *
 * @param[in]     yspec Yang spec
 * @param[in,out] x     XML tree. Translate it in-line
 * @param[out]    xerr  Reason for invalid tree returned as netconf err msg or NULL
 * @retval        1     OK
 * @retval        0     Invalid, wrt namespace.  xerr set
 * @retval       -1     Error
 * @note the opposite - xml2ns is made inline in xml2json1_cbuf
 * Example: <top><module:input> --> <top><input xmlns="">
 * @see RFC7951 Sec 4
 */
static int
json_xmlns_translate(yang_stmt *yspec,
                     cxobj     *x,
                     cxobj    **xerr)
{
    int        retval = -1;
    yang_stmt *ymod;
    char      *namespace;
    char      *modname = NULL;
    cxobj     *xc;
    int        ret;

    if ((modname = xml_prefix(x)) != NULL){ /* prefix is here module name */
        /* Special case for ietf-netconf -> ietf-restconf translation
         * A special case is for return data on the form {"data":...}
         * See also xml2json1_cbuf
         */
        if (strcmp(modname, "ietf-restconf") == 0)
            modname = "ietf-netconf";
        if ((ymod = yang_find_module_by_name(yspec, modname)) == NULL){
            if (xerr &&
                netconf_unknown_namespace_xml(xerr, "application",
                                              modname,
                                              "No yang module found corresponding to prefix") < 0)
                goto done;
            goto fail;
        }
        namespace = yang_find_mynamespace(ymod);
        /* It would be possible to use canonical prefixes here, but probably not
         * necessary or even right. Therefore, the namespace given by the JSON prefix / module
         * is always the default namespace with prefix NULL.
         * If not, this would be the prefix to pass instead of NULL
         * prefix = yang_find_myprefix(ymod);
         */
        if (xml_namespace_change(x, namespace, NULL) < 0)
            goto done;
    }
    xc = NULL;
    while ((xc = xml_child_each(x, xc, CX_ELMNT)) != NULL){
        if ((ret = json_xmlns_translate(yspec, xc, xerr)) < 0)
            goto done;
        if (ret == 0)
            goto fail;
    }
    retval = 1;
 done:
    return retval;
 fail:
    retval = 0;
    goto done;
}

/*! Parse a string containing JSON and return an XML tree
 *
 * Parsing using yacc according to JSON syntax. Names with <prefix>:<id>
 * are split and interpreted as in RFC7951
 *
 * @param[in]  str    Input string containing JSON
 * @param[in]  rfc7951 Do sanity checks according to RFC 7951 JSON Encoding of Data Modeled with YANG
 * @param[in]  yb     How to bind yang to XML top-level when parsing (if rfc7951)
 * @param[in]  yspec  Yang specification (if rfc 7951)
 * @param[out] xt     XML top of tree typically w/o children on entry (but created)
 * @param[out] xerr   Reason for invalid returned as netconf err msg
 * @retval     1      OK and valid
 * @retval     0      Invalid (only if yang spec)
 * @retval    -1      Error
 *
 * @see _xml_parse for XML variant
 * @see http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf
 * @see RFC 7951
 */
static int
_json_parse(char      *str,
            int        rfc7951,
            yang_bind  yb,
            yang_stmt *yspec,
            cxobj     *xt,
            cxobj    **xerr)
{
    int              retval = -1;
    clixon_json_yacc jy = {0,};
    cxobj           *x;
    cbuf            *cberr = NULL;
    int              i;
    int              failed = 0; /* yang assignment */
    yang_stmt       *yspec1;
    int              ret;

    if (clixon_debug_get() & CLIXON_DBG_DETAIL)
        clixon_debug(CLIXON_DBG_PARSE|CLIXON_DBG_DETAIL, "%s", str);
    else
        clixon_debug(CLIXON_DBG_PARSE|CLIXON_DBG_TRUNC, "%s", str);
    jy.jy_parse_string = str;
    jy.jy_linenum = 1;
    jy.jy_current = xt;
    jy.jy_xtop = xt;
    if (json_scan_init(&jy) < 0)
        goto done;
    if (json_parse_init(&jy) < 0)
        goto done;
    if (clixon_json_parseparse(&jy) != 0) { /* yacc returns 1 on error */
        clixon_log(NULL, LOG_NOTICE, "JSON error: line %d", jy.jy_linenum);
        if (clixon_err_category() == 0)
            clixon_err(OE_JSON, 0, "JSON parser error with no error code (should not happen)");
        goto done;
    }
    if (xml_spec(xt))
        yspec1 = ys_spec(xml_spec(xt));
    else
        yspec1 = yspec;
    /* Traverse new objects */
    for (i = 0; i < jy.jy_xlen; i++) {
        x = jy.jy_xvec[i];
        /* RFC 7951 Section 4: A namespace-qualified member name MUST be used for all
         * members of a top-level JSON object
         */
        if (rfc7951 && xml_prefix(x) == NULL){
            /* XXX: For top-level config file: */
            if (yb != YB_NONE || strcmp(xml_name(x),DATASTORE_TOP_SYMBOL)!=0){
                if ((cberr = cbuf_new()) == NULL){
                    clixon_err(OE_UNIX, errno, "cbuf_new");
                    goto done;
                }
                cprintf(cberr, "Top-level JSON object %s is not qualified with namespace which is a MUST according to RFC 7951", xml_name(x));
                if (xerr && netconf_malformed_message_xml(xerr, cbuf_get(cberr)) < 0)
                    goto done;
                goto fail;
            }
        }
        /* Names are split into name/prefix, but now add namespace info */
        // XXX yspec is top-level but x may be across mtpoint
        if ((ret = json_xmlns_translate(yspec1, x, xerr)) < 0)
            goto done;
        if (ret == 0)
            goto fail;
        /* Now assign yang stmts to each XML node
         * XXX should be xml_bind_yang0_parent() sometimes.
         */
        switch (yb){
        case YB_NONE:
            break;
        case YB_MODULE:
            if ((ret = xml_bind_yang0(NULL, x, yb, yspec, xerr)) < 0)
                goto done;
            if (ret == 0)
                failed++;
            break;
        case YB_MODULE_NEXT:
            if ((ret = xml_bind_yang(NULL, x, YB_MODULE, yspec, xerr)) < 0)
                goto done;
            if (ret == 0)
                failed++;
            break;
        case YB_PARENT:
            if ((ret = xml_bind_yang0(NULL, x, yb, yspec, xerr)) < 0)
                goto done;
            if (ret == 0)
                failed++;
            break;
        case YB_RPC:
            if ((ret = xml_bind_yang_rpc(NULL, x, yspec, xerr)) < 0)
                goto done;
            if (ret == 0)
                failed++;
            break;
        }
        /* Now find leafs with identityrefs (+transitive) and translate
         * prefixes in values to XML namespaces */
        if ((ret = json2xml_decode(x, xerr)) < 0)
            goto done;
        if (ret == 0) /* XXX necessary? */
            goto fail;
    }
    if (failed)
        goto fail;
    /* Sort the complete tree after parsing. Sorting is not really meaningful if Yang
       not bound */
    if (yb != YB_NONE)
        if (xml_sort_recurse(xt) < 0)
            goto done;
    retval = 1;
 done:
    clixon_debug(CLIXON_DBG_PARSE|CLIXON_DBG_DETAIL, "retval:%d", retval);
    if (cberr)
        cbuf_free(cberr);
    json_parse_exit(&jy);
    json_scan_exit(&jy);
    if (jy.jy_xvec)
        free(jy.jy_xvec);
    return retval;
 fail: /* invalid */
    retval = 0;
    goto done;
}

/*! Parse string containing JSON and return an XML tree
 *
 * @param[in]     str   String containing JSON
 * @param[in]  rfc7951  Do sanity checks according to RFC 7951 JSON Encoding of Data Modeled with YANG
 * @param[in]     yb    How to bind yang to XML top-level when parsing
 * @param[in]     yspec Yang specification, mandatory to make module->xmlns translation
 * @param[in,out] xt    Top object, if not exists, on success it is created with name 'top'
 * @param[out]    xerr  Reason for invalid returned as netconf err msg
 * @retval        1     OK and valid
 * @retval        0     Invalid (only if yang spec) w xerr set
 * @retval       -1     Error
 *
 * @code
 *  cxobj *x = NULL;
 *  if (clixon_json_parse_string(str, 1, YB_MODULE, yspec, &x, &xerr) < 0)
 *    err;
 *  xml_free(x);
 * @endcode
 * @note  you need to free the xml parse tree after use, using xml_free()
 * @see clixon_xml_parse_string  XML instead of JSON
 * @see clixon_json_parse_file   From a file
 */
int
clixon_json_parse_string(char      *str,
                         int        rfc7951,
                         yang_bind  yb,
                         yang_stmt *yspec,
                         cxobj    **xt,
                         cxobj    **xerr)
{
    clixon_debug(CLIXON_DBG_DEFAULT, "");
    if (xt==NULL){
        clixon_err(OE_JSON, EINVAL, "xt is NULL");
        return -1;
    }
    if (*xt == NULL){
        if ((*xt = xml_new("top", NULL, CX_ELMNT)) == NULL)
            return -1;
    }
    return _json_parse(str, rfc7951, yb, yspec, *xt, xerr);
}

/*! Read a JSON definition from file and parse it into a parse-tree.
 *
 * File will be parsed as follows:
 *   (1) parsed according to JSON; # Only this check if yspec is NULL
 *   (2) sanity checked wrt yang
 *   (3) namespaces check (using <ns>:<name> notation
 *   (4) an xml parse tree will be returned
 * Note, only (1) and (4) will be done if yspec is NULL.
 * Part of (3) is to split json names if they contain colon,
 *   eg: name="a:b" -> prefix="a", name="b"
 * But this is not done if yspec=NULL, and is not part of the JSON spec
 *
 * @param[in]     fp    File descriptor to the JSON file (ASCII string)
 * @param[in]  rfc7951 Do sanity checks according to RFC 7951 JSON Encoding of Data Modeled with YANG
 * @param[in]     yb    How to bind yang to XML top-level when parsing
 * @param[in]     yspec Yang specification, or NULL
 * @param[in,out] xt    Pointer to (XML) parse tree. If empty, create.
 * @param[out]    xerr  Reason for invalid returned as netconf err msg
 * @retval        1     OK and valid
 * @retval        0     Invalid (only if yang spec) w xerr set
 * @retval       -1     Error
 *
 * @code
 *  cxobj *xt = NULL;
 *  if (clixon_json_parse_file(stdin, 1, YB_MODULE, yspec, &xt) < 0)
 *    err;
 *  xml_free(xt);
 * @endcode
 * @note  you need to free the xml parse tree after use, using xml_free()
 * @note, If xt empty, a top-level symbol will be added so that <tree../> will be:  <top><tree.../></tree></top>
 * @note May block on file I/O
 * @see clixon_json_parse_string
 * @see RFC7951
 */
int
clixon_json_parse_file(FILE      *fp,
                       int        rfc7951,
                       yang_bind  yb,
                       yang_stmt *yspec,
                       cxobj    **xt,
                       cxobj    **xerr)
{
    int       retval = -1;
    int       ret;
    char     *jsonbuf = NULL;
    int       jsonbuflen = BUFLEN; /* start size */
    int       oldjsonbuflen;
    char     *ptr;
    char      ch;
    int       len = 0;

    if (xt==NULL){
        clixon_err(OE_JSON, EINVAL, "xt is NULL");
        return -1;
    }
    if ((jsonbuf = malloc(jsonbuflen)) == NULL){
        clixon_err(OE_JSON, errno, "malloc");
        goto done;
    }
    memset(jsonbuf, 0, jsonbuflen);
    ptr = jsonbuf;
    while (1){
        if ((ret = fread(&ch, 1, 1, fp)) < 0){
            clixon_err(OE_JSON, errno, "read");
            break;
        }
        if (ret != 0)
            jsonbuf[len++] = ch;
        if (ret == 0){
            if (*xt == NULL)
                if ((*xt = xml_new(JSON_TOP_SYMBOL, NULL, CX_ELMNT)) == NULL)
                    goto done;
            if (len){
                if ((ret = _json_parse(ptr, rfc7951, yb, yspec, *xt, xerr)) < 0)
                    goto done;
                if (ret == 0)
                    goto fail;
            }
            break;
        }
        if (len >= jsonbuflen-1){ /* Space: one for the null character */
            oldjsonbuflen = jsonbuflen;
            jsonbuflen *= 2;
            if ((jsonbuf = realloc(jsonbuf, jsonbuflen)) == NULL){
                clixon_err(OE_JSON, errno, "realloc");
                goto done;
            }
            memset(jsonbuf+oldjsonbuflen, 0, jsonbuflen-oldjsonbuflen);
            ptr = jsonbuf;
        }
    }
    retval = 1;
 done:
    if (retval < 0 && *xt){
        free(*xt);
        *xt = NULL;
    }
    if (jsonbuf)
        free(jsonbuf);
    return retval;
 fail:
    retval = 0;
    goto done;
}