MEDIUM: pattern: delete() function uses the pat_ref_elt to find the element to be...

All the pattern delete function can use her reference to the original
"struct pat_ref_elt" to find the element to be remove. The functions
pat_del_list_str() and pat_del_meth() were deleted because after
applying this modification, they have the same code than pat_del_list_ptr().

diff --git a/include/proto/pattern.h b/include/proto/pattern.h
index e6afa51697df57f7654010f39b07d79c5c760407..be9975ebfdca6d47e05d56fee223e59cf69c50e6 100644 (file)
--- a/include/proto/pattern.h
+++ b/include/proto/pattern.h
@@ -68,12 +68,11 @@ int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err)
  * never fails.
  *
  */
-void pat_del_list_val(struct pattern_expr *expr, struct pattern *pat);
-void pat_del_tree_ip(struct pattern_expr *expr, struct pattern *pat);
-void pat_del_list_ptr(struct pattern_expr *expr, struct pattern *pat);
-void pat_del_tree_str(struct pattern_expr *expr, struct pattern *pat);
-void pat_del_list_str(struct pattern_expr *expr, struct pattern *pat);
-void pat_del_list_reg(struct pattern_expr *expr, struct pattern *pat);
+void pat_del_list_val(struct pattern_expr *expr, struct pat_ref_elt *ref);
+void pat_del_tree_ip(struct pattern_expr *expr, struct pat_ref_elt *ref);
+void pat_del_list_ptr(struct pattern_expr *expr, struct pat_ref_elt *ref);
+void pat_del_tree_str(struct pattern_expr *expr, struct pat_ref_elt *ref);
+void pat_del_list_reg(struct pattern_expr *expr, struct pat_ref_elt *ref);
 
 /*
  *
@@ -191,6 +190,7 @@ int pat_ref_append(struct pat_ref *ref, char *pattern, char *sample, int line);
 int pat_ref_add(struct pat_ref *ref, const char *pattern, const char *sample, char **err);
 int pat_ref_set(struct pat_ref *ref, const char *pattern, const char *sample);
 int pat_ref_delete(struct pat_ref *ref, const char *key);
+int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt);
 void pat_ref_prune(struct pat_ref *ref);
 int pat_ref_load(struct pat_ref *ref, struct pattern_expr *expr, int patflags, int soe, char **err);
 
@@ -208,7 +208,7 @@ void pattern_init_expr(struct pattern_expr *expr);
 struct pattern_expr *pattern_lookup_expr(struct pattern_head *head, struct pat_ref *ref);
 struct pattern_expr *pattern_new_expr(struct pattern_head *head, struct pat_ref *ref, char **err);
 struct sample_storage **pattern_find_smp(const char *key, struct pattern_expr *expr, char **err);
-int pattern_delete(const char *key, struct pattern_expr *expr, char **err);
+int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref);
 
 
 #endif

diff --git a/include/types/acl.h b/include/types/acl.h
index c0b5ace4fc8bd3964b84a606ac3c371adb1e4955..1956ec3dfc0b72b48cdee2167fabeb0350f4edca 100644 (file)
--- a/include/types/acl.h
+++ b/include/types/acl.h
@@ -94,7 +94,7 @@ struct acl_keyword {
        char *fetch_kw;
        int (*parse)(const char *text, struct pattern *pattern, char **err);
        int (*index)(struct pattern_expr *expr, struct pattern *pattern, char **err);
-       void (*delete)(struct pattern_expr *expr, struct pattern *pattern);
+       void (*delete)(struct pattern_expr *expr, struct pat_ref_elt *);
        struct sample_storage **(*find_smp)(struct pattern_expr *, struct pattern *);
        void (*prune)(struct pattern_expr *expr);
        struct pattern *(*match)(struct sample *smp, struct pattern_expr *expr, int fill);

diff --git a/include/types/pattern.h b/include/types/pattern.h
index 7fa860feb279f6e5f7cdf29af0b8b6bcc08874db..a9dd0330f9b959e8592bb2dcdef1e75bbbb8d344 100644 (file)
--- a/include/types/pattern.h
+++ b/include/types/pattern.h
@@ -207,7 +207,7 @@ struct pattern_head {
        int (*parse)(const char *text, struct pattern *pattern, char **err);
        int (*parse_smp)(const char *text, struct sample_storage *smp);
        int (*index)(struct pattern_expr *, struct pattern *, char **);
-       void (*delete)(struct pattern_expr *, struct pattern *);
+       void (*delete)(struct pattern_expr *, struct pat_ref_elt *);
        struct sample_storage **(*find_smp)(struct pattern_expr *, struct pattern *);
        void (*prune)(struct pattern_expr *);
        struct pattern *(*match)(struct sample *, struct pattern_expr *, int);
@@ -219,7 +219,7 @@ struct pattern_head {
 extern char *pat_match_names[PAT_MATCH_NUM];
 extern int (*pat_parse_fcts[PAT_MATCH_NUM])(const char *, struct pattern *, char **);
 extern int (*pat_index_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *, char **);
-extern void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *);
+extern void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pat_ref_elt *);
 extern struct sample_storage **(*pat_find_smp_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *);
 void (*pat_prune_fcts[PAT_MATCH_NUM])(struct pattern_expr *);
 extern struct pattern *(*pat_match_fcts[PAT_MATCH_NUM])(struct sample *, struct pattern_expr *, int);

diff --git a/src/pattern.c b/src/pattern.c
index eac123dac7f4d0183abf7e1f52757db333749215..8ea102fb456c1abdc460e79e73a4c6eb477594b6 100644 (file)
--- a/src/pattern.c
+++ b/src/pattern.c
@@ -72,7 +72,7 @@ int (*pat_index_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *, ch
        [PAT_MATCH_REG]   = pat_idx_list_reg,
 };
 
-void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *) = {
+void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pat_ref_elt *) = {
        [PAT_MATCH_FOUND] = pat_del_list_val,
        [PAT_MATCH_BOOL]  = pat_del_list_val,
        [PAT_MATCH_INT]   = pat_del_list_val,
@@ -80,11 +80,11 @@ void (*pat_delete_fcts[PAT_MATCH_NUM])(struct pattern_expr *, struct pattern *)
        [PAT_MATCH_BIN]   = pat_del_list_ptr,
        [PAT_MATCH_LEN]   = pat_del_list_val,
        [PAT_MATCH_STR]   = pat_del_tree_str,
-       [PAT_MATCH_BEG]   = pat_del_list_str,
-       [PAT_MATCH_SUB]   = pat_del_list_str,
-       [PAT_MATCH_DIR]   = pat_del_list_str,
-       [PAT_MATCH_DOM]   = pat_del_list_str,
-       [PAT_MATCH_END]   = pat_del_list_str,
+       [PAT_MATCH_BEG]   = pat_del_list_ptr,
+       [PAT_MATCH_SUB]   = pat_del_list_ptr,
+       [PAT_MATCH_DIR]   = pat_del_list_ptr,
+       [PAT_MATCH_DOM]   = pat_del_list_ptr,
+       [PAT_MATCH_END]   = pat_del_list_ptr,
        [PAT_MATCH_REG]   = pat_del_list_reg,
 };
 
@@ -1357,22 +1357,14 @@ struct sample_storage **pat_find_smp_list_reg(struct pattern_expr *expr, struct
        return NULL;
 }
 
-void pat_del_list_val(struct pattern_expr *expr, struct pattern *pattern)
+void pat_del_list_val(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
        struct pattern_list *pat;
        struct pattern_list *safe;
 
        list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
                /* Check equality. */
-               if (pattern->val.range.min_set != pat->pat.val.range.min_set)
-                       continue;
-               if (pattern->val.range.max_set != pat->pat.val.range.max_set)
-                       continue;
-               if (pattern->val.range.min_set &&
-                   pattern->val.range.min != pat->pat.val.range.min)
-                       continue;
-               if (pattern->val.range.max_set &&
-                   pattern->val.range.max != pat->pat.val.range.max)
+               if (pat->pat.ref != ref)
                        continue;
 
                /* Delete and free entry. */
@@ -1382,94 +1374,57 @@ void pat_del_list_val(struct pattern_expr *expr, struct pattern *pattern)
        }
 }
 
-void pat_del_tree_ip(struct pattern_expr *expr, struct pattern *pattern)
+void pat_del_tree_ip(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
        struct ebmb_node *node, *next_node;
        struct pattern_tree *elt;
-       struct pattern_list *pat;
-       struct pattern_list *safe;
-       unsigned int mask;
 
        /* browse each node of the tree for IPv4 addresses. */
-       if (pattern->type == SMP_T_IPV4) {
-               /* Convert mask. If the mask is contiguous, browse each node
-                * of the tree for IPv4 addresses.
-                */
-               mask = ntohl(pattern->val.ipv4.mask.s_addr);
-               if (mask + (mask & -mask) == 0) {
-                       mask = mask ? 33 - flsnz(mask & -mask) : 0; /* equals cidr value */
-
-                       for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
-                            node;
-                            node = next_node, next_node = node ? ebmb_next(node) : NULL) {
-                               /* Extract container of the tree node. */
-                               elt = container_of(node, struct pattern_tree, node);
+       for (node = ebmb_first(&expr->pattern_tree), next_node = node ? ebmb_next(node) : NULL;
+            node;
+            node = next_node, next_node = node ? ebmb_next(node) : NULL) {
+               /* Extract container of the tree node. */
+               elt = container_of(node, struct pattern_tree, node);
 
-                               /* Check equality. */
-                               if (memcmp(&pattern->val.ipv4.addr, elt->node.key,
-                                          sizeof(pattern->val.ipv4.addr)) != 0)
-                                       continue;
-                               if (elt->node.node.pfx != mask)
-                                       continue;
+               /* Check equality. */
+               if (elt->ref != ref)
+                       continue;
 
-                               /* Delete and free entry. */
-                               ebmb_delete(node);
-                               free(elt->smp);
-                               free(elt);
-                       }
-               }
-               else {
-                       /* Browse each node of the list for IPv4 addresses. */
-                       list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
-                               /* Check equality, addr then mask */
-                               if (memcmp(&pattern->val.ipv4.addr, &pat->pat.val.ipv4.addr,
-                                          sizeof(pat->pat.val.ipv4.addr)) != 0)
-                                       continue;
+               /* Delete and free entry. */
+               ebmb_delete(node);
+               free(elt->smp);
+               free(elt);
+       }
 
-                               if (memcmp(&pattern->val.ipv4.mask, &pat->pat.val.ipv4.mask,
-                                          sizeof(pat->pat.val.ipv4.addr)) != 0)
-                                       continue;
+       /* Browse each node of the list for IPv4 addresses. */
+       pat_del_list_val(expr, ref);
 
-                               /* Delete and free entry. */
-                               LIST_DEL(&pat->list);
-                               free(pat->pat.smp);
-                               free(pat);
-                       }
-               }
-       }
-       else if (pattern->type == SMP_T_IPV6) {
-               /* browse each node of the tree for IPv6 addresses. */
-               for (node = ebmb_first(&expr->pattern_tree_2), next_node = node ? ebmb_next(node) : NULL;
-                    node;
-                    node = next_node, next_node = node ? ebmb_next(node) : NULL) {
-                       /* Extract container of the tree node. */
-                       elt = container_of(node, struct pattern_tree, node);
+       /* browse each node of the tree for IPv6 addresses. */
+       for (node = ebmb_first(&expr->pattern_tree_2), next_node = node ? ebmb_next(node) : NULL;
+            node;
+            node = next_node, next_node = node ? ebmb_next(node) : NULL) {
+               /* Extract container of the tree node. */
+               elt = container_of(node, struct pattern_tree, node);
 
-                       /* Check equality. */
-                       if (memcmp(&pattern->val.ipv6.addr, elt->node.key,
-                                  sizeof(pattern->val.ipv6.addr)) != 0)
-                               continue;
-                       if (elt->node.node.pfx != pattern->val.ipv6.mask)
-                               continue;
+               /* Check equality. */
+               if (elt->ref != ref)
+                       continue;
 
-                       /* Delete and free entry. */
-                       ebmb_delete(node);
-                       free(elt->smp);
-                       free(elt);
-               }
+               /* Delete and free entry. */
+               ebmb_delete(node);
+               free(elt->smp);
+               free(elt);
        }
 }
 
-void pat_del_list_ptr(struct pattern_expr *expr, struct pattern *pattern)
+void pat_del_list_ptr(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
        struct pattern_list *pat;
        struct pattern_list *safe;
 
        list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
                /* Check equality. */
-               if (pattern->len != pat->pat.len)
-                       continue;
-               if (memcmp(pattern->ptr.ptr, pat->pat.ptr.ptr, pat->pat.len) != 0)
+               if (pat->pat.ref != ref)
                        continue;
 
                /* Delete and free entry. */
@@ -1480,7 +1435,7 @@ void pat_del_list_ptr(struct pattern_expr *expr, struct pattern *pattern)
        }
 }
 
-void pat_del_tree_str(struct pattern_expr *expr, struct pattern *pattern)
+void pat_del_tree_str(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
        struct ebmb_node *node, *next_node;
        struct pattern_tree *elt;
@@ -1493,7 +1448,7 @@ void pat_del_tree_str(struct pattern_expr *expr, struct pattern *pattern)
                elt = container_of(node, struct pattern_tree, node);
 
                /* Check equality. */
-               if (strcmp(pattern->ptr.str, (char *)elt->node.key) != 0)
+               if (elt->ref != ref)
                        continue;
 
                /* Delete and free entry. */
@@ -1503,47 +1458,15 @@ void pat_del_tree_str(struct pattern_expr *expr, struct pattern *pattern)
        }
 }
 
-void pat_del_list_str(struct pattern_expr *expr, struct pattern *pattern)
+void pat_del_list_reg(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
        struct pattern_list *pat;
        struct pattern_list *safe;
 
        list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
                /* Check equality. */
-               if (pattern->len != pat->pat.len)
+               if (pat->pat.ref != ref)
                        continue;
-               if (pat->pat.flags & PAT_F_IGNORE_CASE) {
-                       if (strncasecmp(pattern->ptr.str, pat->pat.ptr.str, pat->pat.len) != 0)
-                               continue;
-               }
-               else {
-                       if (strncmp(pattern->ptr.str, pat->pat.ptr.str, pat->pat.len) != 0)
-                               continue;
-               }
-
-               /* Delete and free entry. */
-               LIST_DEL(&pat->list);
-               free(pat->pat.ptr.str);
-               free(pat->pat.smp);
-               free(pat);
-       }
-}
-
-void pat_del_list_reg(struct pattern_expr *expr, struct pattern *pattern)
-{
-       struct pattern_list *pat;
-       struct pattern_list *safe;
-
-       list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
-               /* Check equality. */
-               if (pat->pat.flags & PAT_F_IGNORE_CASE) {
-                       if (strcasecmp(pattern->ptr.reg->regstr, pat->pat.ptr.reg->regstr) != 0)
-                               continue;
-               }
-               else {
-                       if (strcmp(pattern->ptr.reg->regstr, pat->pat.ptr.reg->regstr) != 0)
-                               continue;
-               }
 
                /* Delete and free entry. */
                LIST_DEL(&pat->list);
@@ -1615,6 +1538,33 @@ struct pat_ref *pat_ref_lookupid(int unique_id)
        return NULL;
 }
 
+/* This function remove all pattern matching the pointer <refelt> from
+ * the the reference and from each expr member of the reference. This
+ * function returns 1 if the deletion is done and return 0 is the entry
+ * is not found.
+ */
+int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt)
+{
+       struct pattern_expr *expr;
+       struct pat_ref_elt *elt, *safe;
+
+       /* delete pattern from reference */
+       list_for_each_entry_safe(elt, safe, &ref->head, list) {
+               if (elt == refelt) {
+                       LIST_DEL(&elt->list);
+                       free(elt->sample);
+                       free(elt->pattern);
+                       free(elt);
+
+                       list_for_each_entry(expr, &ref->pat, list)
+                               pattern_delete(expr, elt);
+
+                       return 1;
+               }
+       }
+       return 0;
+}
+
 /* This function remove all pattern match <key> from the the reference
  * and from each expr member of the reference. This fucntion returns 1
  * if the deletion is done and return 0 is the entry is not found.
@@ -1632,16 +1582,16 @@ int pat_ref_delete(struct pat_ref *ref, const char *key)
                        free(elt->sample);
                        free(elt->pattern);
                        free(elt);
+
+                       list_for_each_entry(expr, &ref->pat, list)
+                               pattern_delete(expr, elt);
+
                        found = 1;
                }
        }
 
        if (!found)
                return 0;
-
-       list_for_each_entry(expr, &ref->pat, list)
-               pattern_delete(key, expr, NULL);
-
        return 1;
 }
 
@@ -1890,7 +1840,7 @@ int pat_ref_add(struct pat_ref *ref,
        list_for_each_entry(expr, &ref->pat, list) {
                if (!pat_ref_push(elt, expr, 0, err)) {
                        /* Try to delete all the added entries. */
-                       pat_ref_delete(ref, pattern);
+                       pat_ref_delete_by_id(ref, elt);
                        return 0;
                }
        }
@@ -2188,13 +2138,9 @@ struct sample_storage **pattern_find_smp(const char *key, struct pattern_expr *e
  * If the parsing of the input key fails, the function returns 0 and the
  * <err> is filled, else return 1;
  */
-int pattern_delete(const char *key, struct pattern_expr *expr, char **err)
+int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
-       struct pattern pattern;
-
-       if (!expr->pat_head->parse(key, &pattern, err))
-               return 0;
-       expr->pat_head->delete(expr, &pattern);
+       expr->pat_head->delete(expr, ref);
        return 1;
 }
 

diff --git a/src/proto_http.c b/src/proto_http.c
index feaf475b682f1fce43097f982b55bb59d7e2f117..742b27bbd97a213c0213a89c2df080f50a84842e 100644 (file)
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -9073,36 +9073,6 @@ static struct pattern *pat_match_meth(struct sample *smp, struct pattern_expr *e
        return NULL;
 }
 
-static
-void pat_del_meth(struct pattern_expr *expr, struct pattern *pattern)
-{
-       struct pattern_list *pat;
-       struct pattern_list *safe;
-
-       list_for_each_entry_safe(pat, safe, &expr->patterns, list) {
-               /* Check equality. */
-               if (pattern->val.i != pat->pat.val.i)
-                       continue;
-               if (pattern->val.i == HTTP_METH_OTHER) {
-                       if (pattern->len != pat->pat.len)
-                               continue;
-                       if (pat->pat.flags & PAT_F_IGNORE_CASE) {
-                               if (strncasecmp(pattern->ptr.str, pat->pat.ptr.str, pat->pat.len) != 0)
-                                       continue;
-                       }
-                       else {
-                               if (strncmp(pattern->ptr.str, pat->pat.ptr.str, pat->pat.len) != 0)
-                                       continue;
-                       }
-               }
-
-               /* Delete and free entry. */
-               LIST_DEL(&pat->list);
-               free(pat->pat.ptr.str);
-               free(pat);
-       }
-}
-
 static int
 smp_fetch_rqver(struct proxy *px, struct session *l4, void *l7, unsigned int opt,
                 const struct arg *args, struct sample *smp, const char *kw)
@@ -10390,83 +10360,83 @@ static int sample_conv_http_date(const struct arg *args, struct sample *smp)
  */
 static struct acl_kw_list acl_kws = {ILH, {
        { "base",            "base",     pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "base_beg",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "base_dir",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "base_dom",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "base_end",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "base_beg",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "base_dir",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "base_dom",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "base_end",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "base_len",        "base",     pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "base_reg",        "base",     pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "base_sub",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "base_sub",        "base",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { "cook",            "req.cook", pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "cook_beg",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "cook_dir",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "cook_dom",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "cook_end",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "cook_beg",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "cook_dir",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "cook_dom",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "cook_end",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "cook_len",        "req.cook", pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "cook_reg",        "req.cook", pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "cook_sub",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "cook_sub",        "req.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { "hdr",             "req.hdr",  pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "hdr_beg",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "hdr_dir",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "hdr_dom",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "hdr_end",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "hdr_beg",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "hdr_dir",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "hdr_dom",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "hdr_end",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "hdr_len",         "req.hdr",  pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "hdr_reg",         "req.hdr",  pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "hdr_sub",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "hdr_sub",         "req.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
-       { "http_auth_group", NULL,       pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_auth },
+       { "http_auth_group", NULL,       pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_auth },
 
-       { "method",          NULL,       pat_parse_meth, pat_idx_list_str, pat_del_meth,   pat_find_smp_list_str, pat_prune_ptr, pat_match_meth },
+       { "method",          NULL,       pat_parse_meth, pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_meth },
 
        { "path",            "path",     pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "path_beg",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "path_dir",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "path_dom",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "path_end",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "path_beg",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "path_dir",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "path_dom",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "path_end",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "path_len",        "path",     pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "path_reg",        "path",     pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "path_sub",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "path_sub",        "path",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { "req_ver",         "req.ver",  pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
        { "resp_ver",        "res.ver",  pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
 
        { "scook",           "res.cook", pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "scook_beg",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "scook_dir",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "scook_dom",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "scook_end",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "scook_beg",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "scook_dir",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "scook_dom",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "scook_end",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "scook_len",       "res.cook", pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "scook_reg",       "res.cook", pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "scook_sub",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "scook_sub",       "res.cook", pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { "shdr",            "res.hdr",  pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "shdr_beg",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "shdr_dir",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "shdr_dom",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "shdr_end",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "shdr_beg",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "shdr_dir",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "shdr_dom",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "shdr_end",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "shdr_len",        "res.hdr",  pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "shdr_reg",        "res.hdr",  pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "shdr_sub",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "shdr_sub",        "res.hdr",  pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { "url",             "url",      pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "url_beg",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "url_dir",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "url_dom",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "url_end",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "url_beg",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "url_dir",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "url_dom",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "url_end",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "url_len",         "url",      pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "url_reg",         "url",      pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "url_sub",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "url_sub",         "url",      pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { "urlp",            "urlp",     pat_parse_str,  pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str  },
-       { "urlp_beg",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
-       { "urlp_dir",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
-       { "urlp_dom",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
-       { "urlp_end",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
+       { "urlp_beg",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_beg  },
+       { "urlp_dir",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dir  },
+       { "urlp_dom",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_dom  },
+       { "urlp_end",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end  },
        { "urlp_len",        "urlp",     pat_parse_int,  pat_idx_list_val, pat_del_list_val, pat_find_smp_list_val, pat_prune_val, pat_match_len  },
        { "urlp_reg",        "urlp",     pat_parse_reg,  pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg  },
-       { "urlp_sub",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
+       { "urlp_sub",        "urlp",     pat_parse_str,  pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_sub  },
 
        { /* END */ },
 }};

diff --git a/src/ssl_sock.c b/src/ssl_sock.c
index 672bdc10f6fdc214ae88702c6eb92fce98c659a6..65be9e2f043e63abc49a990a99644f64dd7d7e26 100644 (file)
--- a/src/ssl_sock.c
+++ b/src/ssl_sock.c
@@ -3569,7 +3569,7 @@ static struct acl_kw_list acl_kws = {ILH, {
 #endif
        { "ssl_fc_protocol",        NULL,         pat_parse_str, pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str     },
        { "ssl_fc_sni",             "ssl_fc_sni", pat_parse_str, pat_idx_tree_str, pat_del_tree_str, pat_find_smp_tree_str, pat_prune_ptr, pat_match_str     },
-       { "ssl_fc_sni_end",         "ssl_fc_sni", pat_parse_str, pat_idx_list_str, pat_del_list_str, pat_find_smp_list_str, pat_prune_ptr, pat_match_end     },
+       { "ssl_fc_sni_end",         "ssl_fc_sni", pat_parse_str, pat_idx_list_str, pat_del_list_ptr, pat_find_smp_list_str, pat_prune_ptr, pat_match_end     },
        { "ssl_fc_sni_reg",         "ssl_fc_sni", pat_parse_reg, pat_idx_list_reg, pat_del_list_reg, pat_find_smp_list_reg, pat_prune_reg, pat_match_reg     },
        { /* END */ },
 }};