ly common UPDATE do not store serialized pcodes

Author: Roytak

src/ly_common.c

@@ -124,9 +124,9 @@ ly_ctx_ht_pattern_free_cb(void *val_p)
 {
     struct ly_pattern_ht_rec *val = val_p;
 
-    if (val->serialized_pattern) {
+    if (val->pcode) {
         /* free the pcode */
-        pcre2_serialize_free(val->serialized_pattern);
+        pcre2_code_free(val->pcode);
     }
 }
 
@@ -488,160 +488,54 @@ ly_ctx_data_del(const struct ly_ctx *ctx)
     pthread_rwlock_unlock(&ly_ctx_data_rwlock);
 }
 
-/**
- * @brief Serialize a PCRE2 compiled code.
- *
- * @param[in] pcode PCRE2 compiled code to serialize.
- * @param[out] serialized_code Pointer to the serialized code, must be freed by the caller.
- * @return LY_SUCCESS on success, LY_EINT on serialization error.
- */
-static LY_ERR
-ly_pcode_serialize(const pcre2_code *pcode, uint8_t **serialized_code)
-{
-    int r;
-    uint8_t *ser_code = NULL;
-    PCRE2_SIZE ser_code_size = 0;
-
-    *serialized_code = NULL;
-
-    r = pcre2_serialize_encode(&pcode, 1, &ser_code, &ser_code_size, NULL);
-    if (r < 0) {
-        PCRE2_UCHAR err_msg[LY_PCRE2_MSG_LIMIT] = {0};
-
-        pcre2_get_error_message(r, err_msg, LY_PCRE2_MSG_LIMIT);
-        LOGERR(NULL, LY_EINT, "PCRE2 compiled code serialization failed (%s).", err_msg);
-        return LY_EINT;
-    }
-
-    *serialized_code = ser_code;
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Deserialize a PCRE2 compiled code from its serialized form.
- *
- * This code does not have to be recompiled, it can be used directly.
- *
- * @param[in] serialized_code Serialized PCRE2 compiled code.
- * @param[out] pcode Pointer to the deserialized PCRE2 code, must be freed by the caller.
- * @return LY_SUCCESS on success, LY_EINT on deserialization error.
- */
-static LY_ERR
-ly_pcode_deserialize(const uint8_t *serialized_code, pcre2_code **pcode)
-{
-    int r;
-    pcre2_code *pcode_tmp = NULL;
-
-    *pcode = NULL;
-
-    /* deserialize the pcode */
-    r = pcre2_serialize_decode(&pcode_tmp, 1, serialized_code, NULL);
-    if (r < 0) {
-        PCRE2_UCHAR err_msg[LY_PCRE2_MSG_LIMIT] = {0};
-
-        pcre2_get_error_message(r, err_msg, LY_PCRE2_MSG_LIMIT);
-        LOGERR(NULL, LY_EINT, "PCRE2 compiled code deserialization failed (%s).", err_msg);
-        return LY_EINT;
-    }
-
-    *pcode = pcode_tmp;
-    return LY_SUCCESS;
-}
-
-/**
- * @brief Get a compiled PCRE2 pattern code from the context's pattern hash table.
- *
- * @param[in] ctx Context to get the pattern code from.
- * @param[in] pattern Pattern string to search for.
- * @param[in] pattern_ht Pattern hash table to search in.
- * @param[out] pcode Optional compiled pattern code, must be freed by the caller.
- * If NULL, the function only checks if the pattern exists in the hash table.
- * @return LY_SUCCESS on success, LY_ENOTFOUND if the pattern was not found,
- * other LY_ERR values on error.
- */
-static LY_ERR
-_ly_ctx_get_pattern_code(const struct ly_ctx *ctx, const char *pattern,
-        struct ly_ht *pattern_ht, pcre2_code **pcode)
-{
-    LY_ERR rc = LY_SUCCESS;
-    uint32_t hash;
-    struct ly_pattern_ht_rec rec = {0}, *found_rec = NULL;
-
-    assert(ctx && pattern && pattern_ht);
-
-    /* use the pattern as a key */
-    rec.pattern = pattern;
-    rec.serialized_pattern = NULL;
-    hash = lyht_hash(pattern, strlen(pattern));
-
-    /* try to find the record */
-    LY_CHECK_GOTO(rc = lyht_find(pattern_ht, &rec, hash, (void **)&found_rec), cleanup);
-
-    if (pcode) {
-        /* found it, deserialize the pcode */
-        LY_CHECK_GOTO(rc = ly_pcode_deserialize(found_rec->serialized_pattern, pcode), cleanup);
-    }
-
-cleanup:
-    return rc;
-}
-
 LY_ERR
-ly_ctx_get_pattern_code(const struct ly_ctx *ctx, const char *pattern, pcre2_code **pcode)
+ly_ctx_get_or_compile_pattern_code(const struct ly_ctx *ctx, const char *pattern, const pcre2_code **pcode)
 {
     LY_ERR rc = LY_SUCCESS;
     struct ly_ctx_shared_data *ctx_data;
+    struct ly_pattern_ht_rec rec = {0}, *found_rec = NULL;
+    uint32_t hash;
+    pcre2_code *pcode_tmp = NULL;
 
-    ctx_data = ly_ctx_shared_data_get(ctx);
-    LY_CHECK_RET(!ctx_data, LY_EINT);
+    assert(ctx && pattern);
 
-    rc = _ly_ctx_get_pattern_code(ctx, pattern, ctx_data->pattern_ht, pcode);
-    if (rc) {
-        LOGERR(ctx, rc, "Failed to get pattern code for \"%s\".", pattern);
+    if (pcode) {
+        *pcode = NULL;
     }
 
-    return rc;
-}
-
-LY_ERR
-ly_ctx_compile_and_cache_pattern_code(const struct ly_ctx *ctx, const char *pattern)
-{
-    LY_ERR rc = LY_SUCCESS;
-    struct ly_ctx_shared_data *ctx_data;
-    uint8_t *serialized_pcode = NULL;
-    pcre2_code *pcode_tmp = NULL;
-    struct ly_pattern_ht_rec rec = {0};
-    uint32_t hash;
-
     ctx_data = ly_ctx_shared_data_get(ctx);
     LY_CHECK_RET(!ctx_data, LY_EINT);
 
-    /* check for existing pattern code */
-    rc = _ly_ctx_get_pattern_code(ctx, pattern, ctx_data->pattern_ht, NULL);
-    LY_CHECK_GOTO(rc && (rc != LY_ENOTFOUND), cleanup);
-    if (!rc) {
-        /* pattern is already compiled and stored, nothing to do */
+    /* try to find the pattern code in the pattern ht */
+    hash = lyht_hash(pattern, strlen(pattern));
+    rec.pattern = pattern;
+    if (!lyht_find(ctx_data->pattern_ht, &rec, hash, (void **)&found_rec)) {
+        /* found it, return it */
+        if (pcode) {
+            *pcode = found_rec->pcode;
+        }
         goto cleanup;
     }
 
-    /* record not found, we need to compile the pattern and insert it */
+    /* didnt find it, need to compile it */
     LY_CHECK_GOTO(rc = lys_compile_type_pattern_check(ctx, pattern, &pcode_tmp), cleanup);
 
-    /* serialize the pcode */
-    LY_CHECK_GOTO(rc = ly_pcode_serialize(pcode_tmp, &serialized_pcode), cleanup);
-
-    /* insert the record */
+    /* store the compiled pattern code in the hash table */
     hash = lyht_hash(pattern, strlen(pattern));
     rec.pattern = pattern;
-    rec.serialized_pattern = serialized_pcode;
+    rec.pcode = pcode_tmp;
     LY_CHECK_GOTO(rc = lyht_insert_no_check(ctx_data->pattern_ht, &rec, hash, NULL), cleanup);
 
-    /* dont free the serialized pcode, it is now owned by the record in the hash table */
-    serialized_pcode = NULL;
+    if (pcode) {
+        *pcode = pcode_tmp;
+        pcode_tmp = NULL;
+    }
 
 cleanup:
-    pcre2_code_free(pcode_tmp);
-    pcre2_serialize_free(serialized_pcode);
+    if (rc) {
+        /* only free the pcode if we failed, because it belongs to the hash table */
+        pcre2_code_free(pcode_tmp);
+    }
     return rc;
 }
 

src/ly_common.h

@@ -476,25 +476,16 @@ void ly_ctx_ht_leafref_links_rec_free(void *val_p);
 struct lys_module *ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len);
 
 /**
- * @brief Get a compiled PCRE2 pattern code from the context's pattern hash table.
+ * @brief Get or compile a PCRE2 pattern code.
  *
- * @param[in] ctx Context to get the pattern code from.
- * @param[in] pattern Pattern string to search for.
- * @param[out] pcode Compiled pattern code.
- * @return LY_ERR value.
- */
-LY_ERR ly_ctx_get_pattern_code(const struct ly_ctx *ctx, const char *pattern, pcre2_code **pcode);
-
-/**
- * @brief Compile a pattern string into a PCRE2 code and store it in the context's pattern hash table.
- *
- * If the pattern is already compiled and stored, it is not recompiled.
+ * If the pattern is not found in the context, it is compiled and cached.
  *
  * @param[in] ctx Context to get or create the pattern code in.
  * @param[in] pattern Pattern string to search for or to compile and store.
+ * @param[out] pcode Optional compiled pattern code. DO NOT FREE IT, it is owned by the context.
  * @return LY_ERR value.
  */
-LY_ERR ly_ctx_compile_and_cache_pattern_code(const struct ly_ctx *ctx, const char *pattern);
+LY_ERR ly_ctx_get_or_compile_pattern_code(const struct ly_ctx *ctx, const char *pattern, const pcre2_code **pcode);
 
 /******************************************************************************
  * Dictionary

src/plugins_types.c

@@ -528,19 +528,19 @@ lyplg_type_validate_patterns(const struct ly_ctx *ctx, struct lysc_pattern **pat
 {
     LY_ERR r;
     LY_ARRAY_COUNT_TYPE u;
-    pcre2_code *pcode;
+    const pcre2_code *pcode;
 
     LY_CHECK_ARG_RET(NULL, str, err, LY_EINVAL);
 
     *err = NULL;
 
     LY_ARRAY_FOR(patterns, u) {
-        /* get the compiled pattern */
-        LY_CHECK_RET(ly_ctx_get_pattern_code(ctx, patterns[u]->expr, &pcode));
+        /* get (or compile) the compiled pattern. The pattern might not be found, because
+         * if ctx is printed, it did not inherit compiled patterns from the original context. */
+        LY_CHECK_RET(ly_ctx_get_or_compile_pattern_code(ctx, patterns[u]->expr, &pcode));
 
         /* match the pattern */
         r = ly_pattern_code_match(pcode, str, str_len, err);
-        pcre2_code_free(pcode);
         LY_CHECK_RET(r && (r != LY_ENOT), r);
 
         if (((r == LY_ENOT) && !patterns[u]->inverted) || ((r == LY_SUCCESS) && patterns[u]->inverted)) {

src/schema_compile_node.c

@@ -1388,7 +1388,7 @@ lys_compile_type_patterns(struct lysc_ctx *ctx, const struct lysp_restr *pattern
         ++(*pattern)->refcount;
 
         /* compile and insert the pattern into the context hash table, if it wasnt already compiled */
-        LY_CHECK_GOTO(ret = ly_ctx_compile_and_cache_pattern_code(ctx->ctx, &patterns_p[u].arg.str[1]), done);
+        LY_CHECK_GOTO(ret = ly_ctx_get_or_compile_pattern_code(ctx->ctx, &patterns_p[u].arg.str[1], NULL), done);
 
         if (patterns_p[u].arg.str[0] == LYSP_RESTR_PATTERN_NACK) {
             (*pattern)->inverted = 1;

src/tree_data_common.c

@@ -1855,7 +1855,7 @@ ly_time_ts2str(const struct timespec *ts, char **str)
 }
 
 LY_ERR
-ly_pattern_code_match(pcre2_code *pcode, const char *str, size_t str_len, struct ly_err_item **err)
+ly_pattern_code_match(const pcre2_code *pcode, const char *str, size_t str_len, struct ly_err_item **err)
 {
     int r, match_opts;
     pcre2_match_data *match_data = NULL;

src/tree_data_internal.h

@@ -797,6 +797,6 @@ void lyd_unlink_ignore_lyds(struct lyd_node **first_sibling, struct lyd_node *no
  * @return LY_ENOT if the string does not match;
  * @return LY_ERR on error.
  */
-LY_ERR ly_pattern_code_match(pcre2_code *pcode, const char *str, size_t str_len, struct ly_err_item **err);
+LY_ERR ly_pattern_code_match(const pcre2_code *pcode, const char *str, size_t str_len, struct ly_err_item **err);
 
 #endif /* LY_TREE_DATA_INTERNAL_H_ */

src/tree_schema_internal.h

@@ -186,9 +186,7 @@ struct lysp_yin_ctx {
  */
 struct ly_pattern_ht_rec {
     const char *pattern;            /**< Pattern string, used both as key to hash and value to search for. */
-    uint8_t *serialized_pattern;    /**< Serialized pattern code for this pattern.
-                                         Can be deserialized to a compiled pcre2_code that can be used directly,
-                                         see ::ly_pcode_deserialize(). */
+    pcre2_code *pcode;              /**< Compiled PCRE2 pattern code. */
 };
 
 /**