common BUGFIX free cached pattern pcodes

... in case the patterns were only temporary.

Fixes sysrepo/sysrepo#3680

Author: michalvasko

src/ly_common.c

@@ -304,8 +304,10 @@ ly_ctx_shared_data_remove_and_free(struct ly_ctx_shared_data *shared_data)
         return;
     }
 
-    /* free members */
+    /* free all the cached pattern pcodes */
     lyht_free(shared_data->pattern_ht, ly_ctx_ht_pattern_free_cb);
+
+    /* free rest of the members */
     lydict_clean(shared_data->data_dict);
     free(shared_data->data_dict);
     lyht_free(shared_data->leafref_links_ht, ly_ctx_ht_leafref_links_rec_free);
@@ -543,7 +545,7 @@ ly_ctx_data_del(const struct ly_ctx *ctx)
 }
 
 LY_ERR
-ly_ctx_get_or_compile_pattern_code(const struct ly_ctx *ctx, const char *pattern, const pcre2_code **pcode)
+ly_ctx_shared_data_pattern_get(const struct ly_ctx *ctx, const char *pattern, const pcre2_code **pcode)
 {
     LY_ERR rc = LY_SUCCESS;
     struct ly_ctx_shared_data *ctx_data;
@@ -593,6 +595,37 @@ ly_ctx_get_or_compile_pattern_code(const struct ly_ctx *ctx, const char *pattern
     return rc;
 }
 
+void
+ly_ctx_shared_data_pattern_del(const struct ly_ctx *ctx, const char *pattern)
+{
+    struct ly_ctx_shared_data *ctx_data;
+    struct ly_pattern_ht_rec rec = {0}, *found_rec = NULL;
+    uint32_t hash;
+
+    assert(ctx && pattern);
+
+    /* get the context shared data */
+    ctx_data = ly_ctx_shared_data_get(ctx);
+    LY_CHECK_ERR_RET(!ctx_data, LOGINT(ctx), );
+
+    /* 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)) {
+        /* pattern code not cached yet */
+        return;
+    }
+
+    /* found it, free the pcode */
+    pcre2_code_free(found_rec->pcode);
+
+    /* free the pattern HT record */
+    if (lyht_remove(ctx_data->pattern_ht, &rec, hash)) {
+        LOGINT(ctx);
+    }
+}
+
 void *
 ly_realloc(void *ptr, size_t size)
 {

src/ly_common.h

@@ -474,7 +474,7 @@ 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 or compile a PCRE2 pattern code.
+ * @brief Get a PCRE2 pattern code.
  *
  * If the pattern is not found in the context, it is compiled and cached.
  *
@@ -483,7 +483,15 @@ struct lys_module *ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, cons
  * @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_get_or_compile_pattern_code(const struct ly_ctx *ctx, const char *pattern, const pcre2_code **pcode);
+LY_ERR ly_ctx_shared_data_pattern_get(const struct ly_ctx *ctx, const char *pattern, const pcre2_code **pcode);
+
+/**
+ * @brief Free a PCRE2 pattern code, if found in the context cache.
+ *
+ * @param[in] ctx Context of the pattern.
+ * @param[in] pattern Pattern string to use.
+ */
+void ly_ctx_shared_data_pattern_del(const struct ly_ctx *ctx, const char *pattern);
 
 /******************************************************************************
  * Dictionary

src/parser_common.c

@@ -114,6 +114,11 @@ lyd_parser_notif_eventtime_validate(const struct lyd_node *node)
         /* validate */
         value = lyd_get_value(node);
         rc = lyplg_type_validate_patterns(ctx, patterns, value, strlen(value), &err);
+
+        /* free pcodes that were just cached */
+        LY_ARRAY_FOR(patterns, u) {
+            ly_ctx_shared_data_pattern_del(cctx.ctx, patterns[u]->expr);
+        }
     }
 
 cleanup:

src/plugins_types.c

@@ -552,7 +552,7 @@ lyplg_type_validate_patterns(const struct ly_ctx *ctx, struct lysc_pattern **pat
     LY_ARRAY_FOR(patterns, u) {
         /* 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));
+        LY_CHECK_RET(ly_ctx_shared_data_pattern_get(ctx, patterns[u]->expr, &pcode));
 
         /* match the pattern */
         r = ly_pattern_code_match(pcode, str, str_len, err);

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_get_or_compile_pattern_code(ctx->ctx, &patterns_p[u].arg.str[1], NULL), done);
+        LY_CHECK_GOTO(ret = ly_ctx_shared_data_pattern_get(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/xpath.c

@@ -4997,6 +4997,7 @@ xpath_re_match(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_s
     rc = lyxp_set_cast(args[1], LYXP_SET_STRING);
     LY_CHECK_RET(rc);
 
+    /* create a temporary pattern */
     LY_ARRAY_NEW_RET(set->ctx, patterns, pattern, LY_EMEM);
     *pattern = calloc(1, sizeof **pattern);
     if (set->cur_node) {
@@ -5007,9 +5008,13 @@ xpath_re_match(struct lyxp_set **args, uint32_t UNUSED(arg_count), struct lyxp_s
     (*pattern)->expr = args[1]->val.str;
     rc = lyplg_type_validate_patterns(set->ctx, patterns, args[0]->val.str, strlen(args[0]->val.str), &err);
 
+    /* free the pattern */
     free(*pattern);
     LY_ARRAY_FREE(patterns);
+    ly_ctx_shared_data_pattern_del(set->ctx, args[1]->val.str);
+
     if (rc && (rc != LY_EVALID)) {
+        /* error */
         ly_err_print(set->ctx, err);
         ly_err_free(err);
         return rc;