refactor: Restructure CBOR implementation to match libyang conventions

- Reorganize high-level parser code in parser_cbor.c
- Add common high-level context variables to parser_internal.h
- Create lcbor.c and lcbor.h as a consistent wrapper over libcbor
- Maintain coding style consistency with existing libyang modules

Author: MeherRushi

src/lcbor.c

@@ -23,16 +23,71 @@
 #include "log.h"
 #include "ly_common.h"
 
+const char *
+lycbor_token2str(enum cbor_type cbortype)
+{
+    switch (cbortype) {
+    case CBOR_TYPE_UINT:
+        return "unsigned integer";
+    case CBOR_TYPE_NEGINT:
+        return "negative integer";
+    case CBOR_TYPE_BYTESTRING:
+        return "byte string";
+    case CBOR_TYPE_STRING:
+        return "string";
+    case CBOR_TYPE_ARRAY:
+        return "array";
+    case CBOR_TYPE_MAP:
+        return "map";
+    case CBOR_TYPE_TAG:
+        return "tag";
+    case CBOR_TYPE_FLOAT_CTRL:
+        return "decimals and special values (true, false, nil, ...)";
+    }
+
+    return "";
+}
+
+        return "object";
+    case LYJSON_OBJECT_NEXT:
+        return "object next";
+    case LYJSON_OBJECT_CLOSED:
+        return "object closed";
+    case LYJSON_ARRAY:
+        return "array";
+    case LYJSON_ARRAY_NEXT:
+        return "array next";
+    case LYJSON_ARRAY_CLOSED:
+        return "array closed";
+    case LYJSON_OBJECT_NAME:
+        return "object name";
+    case LYJSON_NUMBER:
+        return "number";
+    case LYJSON_STRING:
+        return "string";
+    case LYJSON_TRUE:
+        return "true";
+    case LYJSON_FALSE:
+        return "false";
+    case LYJSON_NULL:
+        return "null";
+    case LYJSON_END:
+        return "end of input";
+    }
+
+    return "";
+}
+
 /**
  * @brief Free CBOR context.
  *
- * @param[in] cbor_ctx CBOR context to free.
+ * @param[in] cborctx CBOR context to free.
  */
-void lycbor_ctx_free(struct lycbor_ctx *cbor_ctx)
+void lycbor_ctx_free(struct lycbor_ctx *cborctx)
 {
-    if (cbor_ctx)
+    if (cborctx)
     {
-        free(cbor_ctx);
+        free(cborctx);
     }
 }
 
@@ -58,31 +113,48 @@ lydcbor_detect_format(struct ly_in *in, enum lyd_cbor_format *format)
  *
  * @param[in] ctx libyang context.
  * @param[in] in Input handler.
- * @param[out] cbor_ctx_p Pointer to store the created CBOR context.
+ * @param[out] cborctx_p Pointer to store the created CBOR context.
  * @return LY_ERR value.
  */
 LY_ERR
-lycbor_ctx_new(const struct ly_ctx *ctx, struct ly_in *in, struct lycbor_ctx **cbor_ctx_p)
+lycbor_ctx_new(const struct ly_ctx *ctx, struct ly_in *in, struct lycbor_ctx **cborctx_p)
 {
     /* TODO : Need to restructure error handling here */
     LY_ERR ret = LY_SUCCESS;
-    struct lycbor_ctx *cbor_ctx;
+    struct lycbor_ctx *cborctx;
+    struct cbor_load_result result = {0};
     enum lyd_cbor_format format;
 
-    assert(ctx && in && cbor_ctx_p);
+    assert(ctx && in && cborctx_p);
 
     /* TODO : error handling after the detect_format function call */
     ret = lydcbor_detect_format(in, &format);
 
     /* Allocate and initialize CBOR context */
-    cbor_ctx = calloc(1, sizeof *cbor_ctx);
-    LY_CHECK_ERR_RET(!cbor_ctx, LOGMEM(ctx), LY_EMEM);
+    cborctx = calloc(1, sizeof *cborctx);
+    LY_CHECK_ERR_RET(!cborctx, LOGMEM(ctx), LY_EMEM);
+    cborctx->ctx = ctx;
+    cborctx->in = in;
+    cborctx->format = format;
+
+    /* load and parse CBOR data */
+    cborctx->cbor_data = cbor_load(in->current, in->length, &result);
+    if (!cborctx->cbor_data) {
+        LOGVAL(ctx, LYVE_SYNTAX, "Failed to parse CBOR data.");
+        free(cborctx);
+        return LY_EVALID;
+    }
+    if (result.error.code != CBOR_ERR_NONE) {
+        LOGVAL(ctx, LYVE_SYNTAX, "CBOR parsing error (code %d).", result.error.code);
+        cbor_decref(&cborctx->cbor_data);
+        free(cborctx);
+        return LY_EVALID;
+    }
 
-    cbor_ctx->ctx = ctx;
-    cbor_ctx->in = in;
-    cbor_ctx->format = format;
+    /* input line logging */
+    ly_log_location(NULL, NULL, NULL, in);
 
-    *cbor_ctx_p = cbor_ctx;
+    *cborctx_p = cborctx;
     return ret;
 }
 

src/lcbor.h

@@ -41,30 +41,36 @@ enum lyd_cbor_format
 struct lycbor_ctx {
     const struct ly_ctx *ctx; /**< libyang context */
     struct ly_in *in;   /**< input structure */
+    
     cbor_item_t *cbor_data; /**< parsed CBOR data */
+    
     enum lyd_cbor_format format; /**< CBOR format variant */
-    uint32_t parse_opts; /**< parser options */
-    uint32_t val_opts;   /**< validation options */
+    
+    struct {
+        cbor_item_t *cbor_data; /**< parsed CBOR data */
+        enum lyd_cbor_format format; /**< CBOR format variant */
+        const char *input;
+    } backup;
 };
 
 /**
  * @brief Create new CBOR context for parsing.
  *
  * @param[in] ctx libyang context.
  * @param[in] in Input handler.
- * @param[out] cbor_ctx_p Pointer to store the created CBOR context.
+ * @param[out] cborctx_p Pointer to store the created CBOR context.
  * @return LY_ERR value.
  */
 LY_ERR
-lycbor_ctx_new(const struct ly_ctx *ctx, struct ly_in *in, struct lycbor_ctx **cbor_ctx_p);
+lycbor_ctx_new(const struct ly_ctx *ctx, struct ly_in *in, struct lycbor_ctx **cborctx_p);
 
 /**
  * @brief Free CBOR context.
  *
- * @param[in] cbor_ctx CBOR context to free.
+ * @param[in] cborctx CBOR context to free.
  */
 void
-lycbor_ctx_free(struct lycbor_ctx *cbor_ctx);
+lycbor_ctx_free(struct lycbor_ctx *cborctx);
 
 #endif /* ENABLE_CBOR_SUPPORT */
 

src/log.h

@@ -271,6 +271,7 @@ typedef enum {
     LYVE_SEMANTICS,    /**< generic semantic error */
     LYVE_SYNTAX_XML,   /**< XML-related syntax error */
     LYVE_SYNTAX_JSON,  /**< JSON-related syntax error */
+    LYVE_SYNTAX_CBOR,  /**< CBOR-related syntax error */
     LYVE_DATA,         /**< YANG data does not reflect some of the module restrictions */
 
     LYVE_OTHER         /**< Unknown error */

src/parser_cbor.c

@@ -1058,15 +1058,6 @@ lydcbor_subtree_r(struct lyd_cbor_ctx *lydctx, struct lyd_node *parent,
 
     assert(lydctx && first_p && parsed && cbor_obj);
 
-    /* assuming that the top level structure is always a map
-    to be modified to include anything else that it can support */
-
-    if (!cbor_isa_map(cbor_obj))
-    {
-        LOGVAL(lydctx->cborctx->ctx, LYVE_SYNTAX, "Expected CBOR map");
-        return LY_EVALID;
-    }
-
     size_t map_size = cbor_map_size(cbor_obj);
     struct cbor_pair *pairs = cbor_map_handle(cbor_obj);
 
@@ -1159,28 +1150,37 @@ lydcbor_ctx_init(const struct ly_ctx *ctx, struct ly_in *in, uint32_t parse_opts
                  uint32_t val_opts, struct lyd_cbor_ctx **lydctx_p)
 {
     LY_ERR ret = LY_SUCCESS;
-    struct lyd_cbor_ctx *lydctx = NULL;
+    struct lyd_cbor_ctx *lydctx;
+    enum cbor_type cbortype;
 
     assert(lydctx_p);
 
-    /* Initialize context with calloc to ensure all fields are zero */
+    /* init context */
     lydctx = calloc(1, sizeof *lydctx);
     LY_CHECK_ERR_RET(!lydctx, LOGMEM(ctx), LY_EMEM);
     lydctx->parse_opts = parse_opts;
     lydctx->val_opts = val_opts;
     lydctx->free = lyd_cbor_ctx_free;
 
-    /* Create low-level CBOR context */
-    LY_CHECK_GOTO(ret = lycbor_ctx_new(ctx, in, &lydctx->cborctx), cleanup);
-
-    *lydctx_p = lydctx;
-    return ret;
+    /* Create low-level CBOR context (includes CBOR parsing) */
+    LY_CHECK_ERR_RET(ret = lycbor_ctx_new(ctx, in, &lydctx->cborctx),  free(lydctx), ret);
+    cbortype = cbor_typeof(lydctx->cborctx->cbor_data);
 
-cleanup:
-    if (lydctx)
+    /* assuming that the top level structure is always a map
+    - though this is not mentioned explicitly in RFC9254 - it is implied
+    and it is almost always the case - This is a similar assumption made
+    to the RFC 7951 where JSON Encoding of data modeled by YANG is always assumed
+    to a have a top-level structure as an object */    
+    if (!cbor_isa_map(lydctx->cborctx->cbor_data))
     {
+        /* expecting top-level map */
+        LOGVAL(ctx, LYVE_SYNTAX_CBOR, "Expected top-level CBOR map, but %s found.", lycbor_token2str(cbortype));
+        *lydctx_p = NULL;
         lyd_cbor_ctx_free((struct lyd_ctx *)lydctx);
+        return LY_EVALID;
     }
+
+    *lydctx_p = lydctx;
     return ret;
 }
 
@@ -1189,72 +1189,43 @@ lyd_parse_cbor(const struct ly_ctx *ctx, const struct lysc_ext_instance *ext, st
                struct lyd_node **first_p, struct ly_in *in, uint32_t parse_opts, uint32_t val_opts, uint32_t int_opts,
                struct ly_set *parsed, ly_bool *subtree_sibling, struct lyd_ctx **lydctx_p)
 {
-    LY_ERR ret = LY_SUCCESS;
+    LY_ERR r, rc = LY_SUCCESS;
     struct lyd_cbor_ctx *lydctx = NULL;
-    cbor_item_t *cbor_data = NULL;
-    struct cbor_load_result result = {0};
+    printf("Entering lyd_parse_cbor\n AHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH\n");
 
-    /* Initialize context */
-    LY_CHECK_GOTO(ret = lydcbor_ctx_init(ctx, in, parse_opts, val_opts, &lydctx), cleanup);
+    /* Initialize context (CBOR parsing happens in lycbor_ctx_new) */
+    rc = lydcbor_ctx_init(ctx, in, parse_opts, val_opts, &lydctx);
+    LY_CHECK_GOTO(rc, cleanup);
 
     lydctx->int_opts = int_opts;
     lydctx->ext = ext;
 
     /* find the operation node if it exists already */
-    LY_CHECK_GOTO(ret = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup);
-
-
-    /*
-     * Loads CBOR data from the current input buffer.
-     *
-     * Parameters:
-     *   in->current - Pointer to the current position in the input buffer.
-     *   in->length  - Length of the data to be loaded.
-     *   &result     - Pointer to a variable where the result status will be stored.
-     *
-     * Returns:
-     *   cbor_data - Pointer to the loaded CBOR data structure, or NULL on failure.
-     */
-    /* need to convert in->current from  const char* to cbor_data type */
-    cbor_data = cbor_load(in->current, in->length, &result);
-    lydctx->cborctx->cbor_data = cbor_data;
-
-    if (!cbor_data)
-    {
-        LOGVAL(ctx, LYVE_SYNTAX, "Failed to parse CBOR data: no data returned from cbor_load().");
-        ret = LY_EVALID;
-        goto cleanup;
-    }
-    if (result.error.code != CBOR_ERR_NONE)
-    {
-        LOGVAL(ctx, LYVE_SYNTAX, "Failed to parse CBOR data: parsing error (code %d).", result.error.code);
-        ret = LY_EVALID;
-        goto cleanup;
-    }
+    LY_CHECK_GOTO(rc = lyd_parser_find_operation(parent, int_opts, &lydctx->op_node), cleanup);
 
-    /* Probably need to check if the obtained data is a operational node and
-    then write functions to parse them accordingly. If not then continue below */
+    /* Parse the CBOR structure - read subtrees */
+    r = lydcbor_subtree_r(lydctx, parent, first_p, parsed, lydctx->cborctx->cbor_data);
+    LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
 
-    /* Parse the CBOR structure */
-    ret = lydcbor_subtree_r(lydctx, parent, first_p, parsed, cbor_data);
+    /* Unexpected sibling node error handling */
 
-cleanup:
-    if (cbor_data)
-    {
-        cbor_decref(&cbor_data);
+    /* Validate operation node presence */
+    if ((int_opts & (LYD_INTOPT_RPC | LYD_INTOPT_ACTION | LYD_INTOPT_NOTIF | LYD_INTOPT_REPLY)) && 
+        !lydctx->op_node) {
+        LOGVAL(ctx, LYVE_DATA, "Missing the operation node.");
+        r = LY_EVALID;
+        LY_DPARSER_ERR_GOTO(r, rc = r, lydctx, cleanup);
     }
+    /* also need to deal with metadata linking etc*/
 
-    if (ret)
-    {
-        if (lydctx)
-        {
-            lyd_cbor_ctx_free((struct lyd_ctx *)lydctx);
-            lydctx = NULL;
-        }
+cleanup:
+    if (rc && (!lydctx || !(lydctx->val_opts & LYD_VALIDATE_MULTI_ERROR) || (rc != LY_EVALID))) {
+        lyd_cbor_ctx_free((struct lyd_ctx *)lydctx);
+        lydctx = NULL;
     }
 
     *lydctx_p = (struct lyd_ctx *)lydctx;
-    return ret;
+    return rc;
 }
 
 #endif /* ENABLE_CBOR_SUPPORT */

src/parser_data.h

@@ -44,7 +44,8 @@ struct ly_in;
  * - CBOR
  *
  *   The reference documentation would be `Encoding of Data Modeled with YANG in the Concise Binary Object 
- *   Representation (CBOR)` : [RFC 9254](https://datatracker.ietf.org/doc/html/rfc9254)
+ *   Representation (CBOR)` : [RFC 9254](https://datatracker.ietf.org/doc/html/rfc9254).  < $TODO$ Look at the edge cases of 
+ *   RPCs, actions and Notifications and maybe like json only - where we make a proprietary representation>
  *
  * While the parsers themselves process the input data only syntactically, all the parser functions actually incorporate
  * the [common validator](@ref howtoDataValidation) checking the input data semantically. Therefore, the parser functions

src/parser_internal.h

@@ -204,6 +204,7 @@ struct lyd_cbor_ctx
     lyd_ctx_free_clb free; /**< destructor */
 
     struct lycbor_ctx *cborctx; /**< CBOR context for low-level operations */    
+    const struct lysc_node *any_schema; /**< parent anyxml/anydata schema node if parsing nested data tree */
 };
 #endif /* ENABLE_CBOR_SUPPORT */