RepoMirrors
/
haproxy
mirror of http://git.haproxy.org/git/haproxy.git/
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
haproxy/include/proto/pattern.h

204 lines
8.3 KiB
C
Raw Normal View History

REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/*
* include/proto/pattern.h
* This file provides structures and types for pattern matching.
*
* Copyright (C) 2000-2013 Willy Tarreau - w@1wt.eu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _PROTO_PATTERN_H
#define _PROTO_PATTERN_H
MINOR: pattern: import acl_find_match_name() into pattern.h It's only dedicated to pattern match lookups, so it was renamed pat_find_match_name().
2013-11-28 21:24:25 +00:00
#include <string.h>
MINOR: acl/pattern: use types different from int to clarify who does what. We now have the following enums and all related functions return them and consume them : enum pat_match_res { PAT_NOMATCH = 0, /* sample didn't match any pattern */ PAT_MATCH = 3, /* sample matched at least one pattern */ }; enum acl_test_res { ACL_TEST_FAIL = 0, /* test failed */ ACL_TEST_MISS = 1, /* test may pass with more info */ ACL_TEST_PASS = 3, /* test passed */ }; enum acl_cond_pol { ACL_COND_NONE, /* no polarity set yet */ ACL_COND_IF, /* positive condition (after 'if') */ ACL_COND_UNLESS, /* negative condition (after 'unless') */ }; It's just in order to avoid doubts when reading some code.
2013-11-28 21:21:02 +00:00
#include <common/config.h>
#include <common/standard.h>
#include <types/pattern.h>
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
void pattern_finalize_config(void);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
MINOR: pattern: import acl_find_match_name() into pattern.h It's only dedicated to pattern match lookups, so it was renamed pat_find_match_name().
2013-11-28 21:24:25 +00:00
/* return the PAT_MATCH_* index for match name "name", or < 0 if not found */
static inline int pat_find_match_name(const char *name)
{
int i;
for (i = 0; i < PAT_MATCH_NUM; i++)
if (strcmp(name, pat_match_names[i]) == 0)
return i;
return -1;
}
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* This function executes a pattern match on a sample. It applies pattern <expr>
MEDIUM: pattern: The function pattern_exec_match() returns "struct pattern" if the patten match. Before this commit, the pattern_exec_match() function returns the associate sample, the associate struct pattern or the associate struct pattern_tree. This is complex to use, because we can check the type of information returned. Now the function return always a "struct pattern". If <fill> is not set, only the value of the pointer can be used as boolean (NULL or other). If <fill> is set, you can use the <smp> pointer and the pattern information. If information must be duplicated, it is stored in trash buffer. Otherwise, the pattern can point on existing strings.
2014-01-17 14:25:13 +00:00
* to sample <smp>. The function returns NULL if the sample dont match. It returns
* non-null if the sample match. If <fill> is true and the sample match, the
* function returns the matched pattern. In many cases, this pattern can be a
* static buffer.
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
*/
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
struct pattern *pattern_exec_match(struct pattern_head *head, struct sample *smp, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
MEDIUM: pattern: add indexation function. Before this patch, the indexation function check the declared patttern matching function and index the data according with this function. This is not useful to add some indexation mode. This commit adds dedicated indexation function. Each struct pattern is associated with one indexation function. This function permit to index data according with the type of pattern and with the type of match.
2013-12-13 14:12:32 +00:00
/*
*
* The following function gets "pattern", duplicate it and index it in "expr"
*
*/
int pat_idx_list_val(struct pattern_expr *expr, struct pattern *pat, char **err);
int pat_idx_list_ptr(struct pattern_expr *expr, struct pattern *pat, char **err);
int pat_idx_list_str(struct pattern_expr *expr, struct pattern *pat, char **err);
int pat_idx_list_reg(struct pattern_expr *expr, struct pattern *pat, char **err);
int pat_idx_tree_ip(struct pattern_expr *expr, struct pattern *pat, char **err);
int pat_idx_tree_str(struct pattern_expr *expr, struct pattern *pat, char **err);
MEDIUM: pattern: add delete functions This commit adds a delete function for patterns. It looks up all instances of the pattern to delete and deletes them all. The fetch keyword declarations have been extended to point to the appropriate delete function.
2014-01-15 10:38:49 +00:00
/*
*
* The following functions search pattern <pattern> into the pattern
* expression <expr>. If the pattern is found, delete it. This function
* never fails.
*
*/
MEDIUM: pattern: delete() function uses the pat_ref_elt to find the element to be removed 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().
2014-01-28 15:43:36 +00:00
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);
MEDIUM: pattern: add delete functions This commit adds a delete function for patterns. It looks up all instances of the pattern to delete and deletes them all. The fetch keyword declarations have been extended to point to the appropriate delete function.
2014-01-15 10:38:49 +00:00
MEDIUM: pattern: add prune function This path add specific pointer to each expression to point on prune function. Now, each pattern expression embed his own prune function.
2014-01-14 15:24:51 +00:00
/*
*
* The following functions clean all entries of a pattern expression and
* reset the tree and list root.
*
*/
void pat_prune_val(struct pattern_expr *expr);
void pat_prune_ptr(struct pattern_expr *expr);
void pat_prune_reg(struct pattern_expr *expr);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/*
*
* The following functions are general purpose pattern matching functions.
*
*/
/* ignore the current line */
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_nothing(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse an integer. It is put both in min and max. */
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_int(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse an version. It is put both in min and max. */
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_dotted_ver(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse a range of integers delimited by either ':' or '-'. If only one
* integer is read, it is set as both min and max.
*/
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_range(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse a string. It is allocated and duplicated. */
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_str(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse a hexa binary definition. It is allocated and duplicated. */
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_bin(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse a regex. It is allocated. */
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_reg(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Parse an IP address and an optional mask in the form addr[/mask].
* The addr may either be an IPv4 address or a hostname. The mask
* may either be a dotted mask or a number of bits. Returns 1 if OK,
* otherwise 0.
*/
MEDIUM: pattern: The parse functions just return "struct pattern" without memory allocation The pattern parse functions put the parsed result in a "struct pattern" without memory allocation. If the pattern must reference the input data without changes, the pattern point to the parsed string. If buffers are needed to store translated data, it use th trash buffer. The indexation function that allocate the memory later if it is needed.
2013-12-13 14:36:59 +00:00
int pat_parse_ip(const char *text, struct pattern *pattern, char **err);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
MINOR: pattern: move functions for grouping pat_match_* and pat_parse_* and add documentation.
2014-01-21 10:25:41 +00:00
/* NB: For two strings to be identical, it is required that their lengths match */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_str(struct sample *smp, struct pattern_expr *expr, int fill);
MINOR: pattern: move functions for grouping pat_match_* and pat_parse_* and add documentation.
2014-01-21 10:25:41 +00:00
/* NB: For two binary buffers to be identical, it is required that their lengths match */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_bin(struct sample *smp, struct pattern_expr *expr, int fill);
MINOR: pattern: move functions for grouping pat_match_* and pat_parse_* and add documentation.
2014-01-21 10:25:41 +00:00
/* Checks that the length of the pattern in <test> is included between min and max */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_len(struct sample *smp, struct pattern_expr *expr, int fill);
MINOR: pattern: move functions for grouping pat_match_* and pat_parse_* and add documentation.
2014-01-21 10:25:41 +00:00
/* Checks that the integer in <test> is included between min and max */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_int(struct sample *smp, struct pattern_expr *expr, int fill);
MINOR: pattern: move functions for grouping pat_match_* and pat_parse_* and add documentation.
2014-01-21 10:25:41 +00:00
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* always return false */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_nothing(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Checks that the pattern matches the end of the tested string. */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_end(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Checks that the pattern matches the beginning of the tested string. */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_beg(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Checks that the pattern is included inside the tested string. */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_sub(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Checks that the pattern is included inside the tested string, but enclosed
* between slashes or at the beginning or end of the string. Slashes at the
* beginning or end of the pattern are ignored.
*/
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_dir(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Checks that the pattern is included inside the tested string, but enclosed
* between dots or at the beginning or end of the string. Dots at the beginning
* or end of the pattern are ignored.
*/
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_dom(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Check that the IPv4 address in <test> matches the IP/mask in pattern */
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_ip(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
/* Executes a regex. It temporarily changes the data to add a trailing zero,
* and restores the previous character when leaving.
*/
MEDIUM: pattern: The match function browse itself the list or the tree. The match function known the format of the pattern. The pattern can be stored in a list or in a tree. The pattern matching function use itself the good entry point and indexation type. Each pattern matching function return the struct pattern that match. If the flag "fill" is set, the struct pattern is filled, otherwise the content of this struct must not be used. With this feature, the general pattern matching function cannot have exceptions for building the "struct pattern".
2013-12-16 13:22:13 +00:00
struct pattern *pat_match_reg(struct sample *smp, struct pattern_expr *expr, int fill);
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
/*
* pattern_ref manipulation.
*/
struct pat_ref *pat_ref_lookup(const char *reference);
MINOR: pattern: Each pattern is identified by unique id. The pattern reference are stored with two identifiers: the unique_id and the reference. The reference identify a file. Each file with the same name point to the same reference. We can register many times one file. If the file is modified, all his dependencies are also modified. The reference can be used with map or acl. The unique_id identify inline acl. The unique id is unique for each acl. You cannot force the same id in the configuration file, because this repport an error. The format of the acl and map listing through the "socket" has changed for displaying these new ids.
2014-03-11 13:29:22 +00:00
struct pat_ref *pat_ref_lookupid(int unique_id);
MINOR: pattern: store configuration reference for each acl or map pattern. This patch permit to add reference for each pattern reference. This is useful to identify the acl listed.
2014-02-11 02:31:34 +00:00
struct pat_ref *pat_ref_new(const char *reference, const char *display, unsigned int flags);
struct pat_ref *pat_ref_newid(int unique_id, const char *display, unsigned int flags);
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
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);
MEDIUM: dumpstats: Display error message during add of values. This patch adds new display type. This display returns allocated string, when the string is flush into buffers, it is freed. This permit to return the content of "memprintf(err, ...)" messages. The pat_ref_add functions has changed to return error.
2014-01-29 18:08:49 +00:00
int pat_ref_set(struct pat_ref *ref, const char *pattern, const char *sample, char **err);
int pat_ref_set_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt, const char *value, char **err);
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
int pat_ref_delete(struct pat_ref *ref, const char *key);
MEDIUM: pattern: delete() function uses the pat_ref_elt to find the element to be removed 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().
2014-01-28 15:43:36 +00:00
int pat_ref_delete_by_id(struct pat_ref *ref, struct pat_ref_elt *refelt);
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
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);
MINOR: pattern: Add function to prune and reload pattern list. This function it is used for dynamically update all the patterns attached to one file. This function is atomic. All parsing or indexation failures are reported in the haproxy logs.
2014-03-21 20:45:15 +00:00
void pat_ref_reload(struct pat_ref *ref, struct pat_ref *replace);
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
/*
* pattern_head manipulation.
*/
void pattern_init_head(struct pattern_head *head);
void pattern_prune(struct pattern_head *head);
MINOR: dumpstat/conf: display all the configuration lines that using pattern reference
2014-02-11 13:36:45 +00:00
int pattern_read_from_file(struct pattern_head *head, unsigned int refflags, const char *filename, int patflags, int load_smp, char **err, const char *file, int line);
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
/*
* pattern_expr manipulation.
*/
MEDIUM: pattern: rename "acl" prefix to "pat" This patch just renames functions, types and enums. No code was changed. A significant number of files were touched, especially the ACL arrays, so it is likely that some external patches will not apply anymore. One important thing is that we had to split ACL_PAT_* into two groups : - ACL_TEST_{PASS|MISS|FAIL} - PAT_{MATCH|UNMATCH} A future patch will enforce enums on all these places to avoid confusion.
2013-11-28 17:22:00 +00:00
void pattern_init_expr(struct pattern_expr *expr);
MAJOR: pattern/map: Extends the map edition system in the patterns This patch add the following socket command line options: show acl [<id>] clear acl <id> get acl <id> <pattern> del acl <id> <pattern> add acl <id> <pattern> The system used for maps is backported in the pattern functions.
2014-02-11 10:31:40 +00:00
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);
MEDIUM: pattern_find_smp: functions find_smp uses the pat_ref_elt to find the element to be removed The find_smp search the smp using the value of the pat_ref_elt pointer. The pat_find_smp_* are no longer used. The function pattern_find_smp() known all pattern indexation, and can be found
2014-01-29 15:24:55 +00:00
struct sample_storage **pattern_find_smp(struct pattern_expr *expr, struct pat_ref_elt *elt);
MEDIUM: pattern: delete() function uses the pat_ref_elt to find the element to be removed 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().
2014-01-28 15:43:36 +00:00
int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref);
MINOR: pattern: add function to lookup a specific entry in pattern list This is used to dynamically delete or update map entry.
2013-12-10 14:08:01 +00:00
REORG: acl/pattern: extract pattern matching from the acl file and create pattern.c This patch just moves code without any change. The ACL are just the association between sample and pattern. The pattern contains the match method and the parse method. These two things are different. This patch cleans the code by splitting it.
2013-11-28 10:05:19 +00:00
#endif