Made regex configuration same way as in Nginx.

Implement searching in chunked TfwStr.

Author: biathlon3

fw/cfg.c

@@ -243,6 +243,7 @@ entry_set_name(TfwCfgEntry *e)
 
 	BUG_ON(!e);
 	BUG_ON(e->name);
+	//pr_notice("rule=%i",rule);
 
 	if (!rule) {
 		name = e->ftoken;
@@ -253,6 +254,7 @@ entry_set_name(TfwCfgEntry *e)
 	}
 
 	T_DBG3("set name: %.*s\n", len, name);
+	//pr_notice("set name: %.*s\n", len, name);
 
 	if (!check_identifier(name, len))
 		return -EINVAL;
@@ -276,6 +278,7 @@ entry_set_first_token(TfwCfgEntry *e, const char *src, int len)
 	BUG_ON(e->ftoken);
 
 	T_DBG3("set first token: %.*s\n", len, src);
+	//pr_notice("set first token: %.*s\n", len, src);
 
 	if (!src || !len)
 		return -EINVAL;
@@ -360,6 +363,7 @@ entry_add_rule_param(const char **param, const char *src, size_t len)
 	if (!(dst = alloc_and_copy_literal(src, len)))
 		return -ENOMEM;
 	*param = dst;
+	//pr_notice("entry_add_rule_param param=%s\n", dst);
 	return 0;
 }
 
@@ -400,6 +404,9 @@ typedef enum {
 	TOKEN_SEMICOLON,
 	TOKEN_LITERAL,
 	TOKEN_ARROW,
+	TOKEN_TILDA,
+	TOKEN_REGEX,
+	TOKEN_REGEX_CI,
 	_TOKEN_COUNT,
 } token_t;
 
@@ -591,9 +598,12 @@ read_next_token(TfwCfgParserState *ps)
 				    TOKEN_NEQSIGN);
 		TFSM_COND_MOVE_EXIT(ps->c == '>' && ps->prev_c == '-',
 				    TOKEN_ARROW);
+		TFSM_COND_MOVE_EXIT(ps->c == '*' && ps->prev_c == '~',
+		                    TOKEN_REGEX_CI);
 
 		/* Special case to differ single equal sign from double one. */
-		TFSM_COND_MOVE(ps->c == '=', TS_EQSIGN);
+		TFSM_COND_MOVE(ps->c == '=', TS_EQSIGN);		
+		TFSM_COND_MOVE(ps->c == '~', TS_TILDA);
 
 		/* Everything else is not a special character and therefore
 		 * it starts a literal. */
@@ -622,6 +632,14 @@ read_next_token(TfwCfgParserState *ps)
 		TFSM_JMP_EXIT(TOKEN_EQSIGN);
 	}
 
+	FSM_STATE(TS_TILDA) {
+		TFSM_COND_JMP_EXIT(!ps->c, TOKEN_REGEX);
+
+		/* If this is double equal sign, eat second sign and exit. */
+		TFSM_COND_MOVE_EXIT(ps->c == '*', TOKEN_REGEX_CI);
+		TFSM_JMP_EXIT(TOKEN_REGEX);
+	}
+
 	FSM_STATE(TS_COMMENT) {
 		TFSM_COND_JMP_EXIT(!ps->c, TOKEN_NA);
 
@@ -716,6 +734,7 @@ entry_set_cond(TfwCfgEntry *e, token_t cond_type, const char *src, int len)
 	int name_len = sizeof(TFW_CFG_RULE_NAME) - 1;
 	TfwCfgRule *rule = &e->rule;
 
+	//pr_notice("entry_set_cond cond_type=%u\n", (unsigned int)cond_type);
 	BUG_ON(!e->ftoken);
 	BUG_ON(e->name);
 
@@ -735,7 +754,23 @@ entry_set_cond(TfwCfgEntry *e, token_t cond_type, const char *src, int len)
 	if (!(e->name = alloc_and_copy_literal(name, name_len)))
 		return -ENOMEM;
 
-	rule->inv = cond_type == TOKEN_DEQSIGN ? false : true;
+
+	switch (cond_type) {
+	case TOKEN_REGEX:
+		rule->regex = TFW_REGEX_REGULAR;
+		rule->inv = false;
+		break;
+	case TOKEN_REGEX_CI:
+		rule->regex = TFW_REGEX_CI;
+		rule->inv = false;
+		break;
+	default:
+		rule->regex = TFW_REGEX_NO;
+		rule->inv = cond_type == TOKEN_DEQSIGN ? false : true;
+		break;
+	}
+
+
 	return 0;
 }
 
@@ -795,22 +830,29 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	 * condition key for rule; in last three cases predefined rule name is used.
 	 */
 	FSM_STATE(PS_START_NEW_ENTRY) {
+
+		//pr_notice("FSM_STATE(PS_START_NEW_ENTRY)\n");
 		entry_reset(&ps->e);
 		ps->e.line_no = ps->line_no;
 		ps->e.line = ps->line;
 
 		PFSM_COND_MOVE(ps->t == TOKEN_ARROW, PS_RULE_PURE_ACTION);
 
 		ps->err = entry_set_first_token(&ps->e, ps->lit, ps->lit_len);
+		//pr_notice("ps->e.ftoken=%s\n", ps->e.ftoken);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 
 		PFSM_MOVE(PS_PLAIN_OR_RULE);
 	}
 
 	FSM_STATE(PS_PLAIN_OR_RULE) {
+		//pr_notice("FSM_STATE(PS_PLAIN_OR_RULE)\n");
+		//pr_notice("ps->e.ftoken=%s\n", ps->e.ftoken);
 		PFSM_COND_MOVE(ps->t == TOKEN_DEQSIGN ||
-			       ps->t == TOKEN_NEQSIGN,
-			       PS_RULE_COND);
+		               ps->t == TOKEN_NEQSIGN ||
+		               ps->t == TOKEN_REGEX ||
+		               ps->t == TOKEN_REGEX_CI,
+		               PS_RULE_COND);
 		PFSM_COND_MOVE(ps->t == TOKEN_LITERAL, PS_PLAIN_OR_LONG_RULE);
 
 		/* Jump to plain val/attr scheme to make remained checks
@@ -821,67 +863,82 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	}
 
 	FSM_STATE(PS_PLAIN_OR_LONG_RULE) {
+		//pr_notice("FSM_STATE(PS_PLAIN_OR_LONG_RULE)\n");
 		FSM_COND_JMP(ps->t == TOKEN_DEQSIGN ||
-			     ps->t == TOKEN_NEQSIGN,
-			     PS_LONG_RULE_COND);
+		             ps->t == TOKEN_NEQSIGN ||
+		             ps->t == TOKEN_REGEX ||
+		             ps->t == TOKEN_REGEX_CI,
+		             PS_LONG_RULE_COND);
 
 		/* This is not rule (simple or extended), so jump to
 		 * plain val/attr scheme. */
 		ps->err = entry_set_name(&ps->e);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 		FSM_COND_JMP(ps->t == TOKEN_EQSIGN, PS_STORE_ATTR_PREV);
 		FSM_COND_JMP(ps->t == TOKEN_LITERAL ||
-			     ps->t == TOKEN_SEMICOLON ||
-			     ps->t == TOKEN_LBRACE,
-			     PS_STORE_VAL_PREV);
+		             ps->t == TOKEN_SEMICOLON ||
+		             ps->t == TOKEN_LBRACE,
+		             PS_STORE_VAL_PREV);
 
 		ps->err = -EINVAL;
 		FSM_JMP(PS_EXIT);
 	}
 
 	FSM_STATE(PS_LONG_RULE_COND) {
+		//pr_notice("FSM_STATE(PS_LONG_RULE_COND)\n");
 		ps->err = entry_add_rule_param(&ps->e.rule.fst_ext,
-					       ps->prev_lit,
-					       ps->prev_lit_len);
+		                               ps->prev_lit,
+		                               ps->prev_lit_len);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 		PFSM_MOVE(PS_RULE_COND);
 	}
 
 	FSM_STATE(PS_RULE_COND) {
+		//pr_notice("FSM_STATE(PS_RULE_COND) ps->t=%u\n", (unsigned)ps->t);
+		//pr_notice("ps->e.ftoken=%s\n", ps->e.ftoken);
+
+		FSM_COND_JMP(ps->prev_t == TOKEN_REGEX ||
+		             ps->prev_t == TOKEN_REGEX_CI,
+		             PS_STORE_VAL_PREV_REGEX);
+
 		PFSM_COND_JMP_EXIT_ERROR(ps->t != TOKEN_LITERAL);
 		ps->err = entry_set_cond(&ps->e, ps->prev_t, ps->lit,
-					 ps->lit_len);
+		                         ps->lit_len);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 		PFSM_MOVE(PS_RULE_COND_END);
 	}
 
 	FSM_STATE(PS_RULE_COND_END) {
+		//pr_notice("FSM_STATE(PS_RULE_COND_END)\n");;
 		PFSM_COND_JMP_EXIT_ERROR(ps->t != TOKEN_ARROW);
 		PFSM_MOVE(PS_RULE_ACTION);
 	}
 
 	FSM_STATE(PS_RULE_PURE_ACTION) {
+		//pr_notice("FSM_STATE(PS_RULE_PURE_ACTION)\n");
 		ps->err = entry_set_name(&ps->e);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 		FSM_JMP(PS_RULE_ACTION);
 	}
 
 	FSM_STATE(PS_RULE_ACTION) {
+		//pr_notice("FSM_STATE(PS_RULE_ACTION)\n");
 		PFSM_COND_JMP_EXIT_ERROR(ps->t != TOKEN_LITERAL);
 		ps->err = entry_add_rule_param(&ps->e.rule.act, ps->lit,
-					       ps->lit_len);
+		                               ps->lit_len);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 		PFSM_MOVE(PS_RULE_ACTION_VAL);
 	}
 
 	FSM_STATE(PS_RULE_ACTION_VAL) {
+		//pr_notice("FSM_STATE(PS_RULE_ACTION_VAL)\n");
 		FSM_COND_JMP(ps->t == TOKEN_SEMICOLON, PS_SEMICOLON);
 		PFSM_COND_JMP_EXIT_ERROR(ps->t != TOKEN_EQSIGN);
 		read_next_token(ps);
 		PFSM_COND_JMP_EXIT_ERROR(ps->t != TOKEN_LITERAL);
 
 		ps->err = entry_add_rule_param(&ps->e.rule.val, ps->lit,
-					       ps->lit_len);
+		                               ps->lit_len);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 
 		read_next_token(ps);
@@ -904,6 +961,7 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	 */
 
 	FSM_STATE(PS_VAL_OR_ATTR) {
+		//pr_notice("FSM_STATE(PS_VAL_OR_ATTR)\n");
 		PFSM_COND_MOVE(ps->t == TOKEN_LITERAL, PS_MAYBE_EQSIGN);
 		FSM_COND_JMP(ps->t == TOKEN_SEMICOLON, PS_SEMICOLON);
 		FSM_COND_JMP(ps->t == TOKEN_LBRACE, PS_LBRACE);
@@ -913,23 +971,65 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	}
 
 	FSM_STATE(PS_MAYBE_EQSIGN) {
+		//pr_notice("FSM_STATE(PS_MAYBE_EQSIGN)\n");
 		FSM_COND_JMP(ps->t == TOKEN_EQSIGN, PS_STORE_ATTR_PREV);
 		FSM_JMP(PS_STORE_VAL_PREV);
 	}
 
+	FSM_STATE(PS_STORE_VAL_PREV_REGEX) {
+		//pr_notice("FSM_STATE(PS_STORE_VAL_PREV_REGEX)\n");
+		/* name val1 val2;
+		 *           ^
+		 *           We are here (but still need to store val1)
+		 *           and name or condition.
+		*/
+		T_DBG3("add value: %.*s\n", ps->prev_lit_len, ps->prev_lit);
+
+		//pr_notice("prev value: %.*s\n", ps->prev_lit_len, ps->prev_lit);
+		//pr_notice("cur value: %.*s\n", ps->lit_len, ps->lit);
+
+		if (ps->e.ftoken && !strcmp(ps->e.ftoken, "location")) {
+			ps->err = entry_set_name(&ps->e);
+
+			if (!ps->err) {
+				if (ps->prev_t == TOKEN_REGEX)
+					ps->err = entry_add_val(&ps->e, "regex",
+					                        sizeof("regex"));
+				if (ps->prev_t == TOKEN_REGEX_CI)
+					ps->err = entry_add_val(&ps->e,
+					                        "regex_ci",
+					                        sizeof("regex_ci"));
+			}
+			FSM_COND_JMP(ps->err, PS_EXIT);
+			FSM_JMP(PS_VAL_OR_ATTR);
+		}
+
+		/*If it is not location*/
+		//pr_notice("ps->e.ftoken=%s\n", ps->e.ftoken);
+		ps->err = entry_set_cond(&ps->e, ps->prev_t,
+		                                         ps->lit, ps->lit_len);
+		FSM_COND_JMP(ps->err, PS_EXIT);
+		PFSM_MOVE(PS_RULE_COND_END);
+
+	}
+
 	FSM_STATE(PS_STORE_VAL_PREV) {
+		//pr_notice("FSM_STATE(PS_STORE_VAL_PREV)\n");
 		/* name val1 val2;
 		 *           ^
 		 *           We are here (but still need to store val1). */
 		T_DBG3("add value: %.*s\n", ps->prev_lit_len, ps->prev_lit);
 
+		//pr_notice("prev value: %.*s\n", ps->prev_lit_len, ps->prev_lit);
+		//pr_notice("cur value: %.*s\n", ps->lit_len, ps->lit);
 		ps->err = entry_add_val(&ps->e, ps->prev_lit, ps->prev_lit_len);
 		FSM_COND_JMP(ps->err, PS_EXIT);
 
 		FSM_JMP(PS_VAL_OR_ATTR);
 	}
 
 	FSM_STATE(PS_STORE_ATTR_PREV) {
+		//pr_notice("FSM_STATE(PS_STORE_ATTR_PREV)\n");
 		/* name key = val;
 		 *          ^
 		 *          We are here. */
@@ -951,6 +1051,7 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	}
 
 	FSM_STATE(PS_LBRACE) {
+		//pr_notice("FSM_STATE(PS_LBRACE)\n");
 		/* Simply exit on '{' leaving nested nodes untouched and
 		 * surrounded with braces. The caller should detect it and parse
 		 * them in a loop. */
@@ -959,6 +1060,7 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	}
 
 	FSM_STATE(PS_SEMICOLON) {
+		//pr_notice("FSM_STATE(PS_SEMICOLON)\n");
 		/* Simply eat ';'. Don't MOVE because the next character may be
 		 * '\0' and that triggers an error (because we expect more input
 		 * tokens when we do _PFSM_MOVE()). */
@@ -967,11 +1069,18 @@ parse_cfg_entry(TfwCfgParserState *ps)
 	}
 
 	FSM_STATE(PS_EXIT) {
+		//pr_notice("FSM_STATE(PS_EXIT)\n");
 		/* Cleanup of entry is done in tfw_cfg_parse_mods() */
+
+		//pr_notice("ps->e.name=%s\n", ps->e.name);
+		//pr_notice("ps->e.line=%s\n", ps->e.line);
+
+
 		T_DBG3("pfsm: exit\n");
 	}
 }
 
+
 /*
  * ------------------------------------------------------------------------
  *	Configuration Parser - TfwCfgSpec helpers.

fw/cfg.h

@@ -149,6 +149,7 @@ typedef struct {
 	const char *act;
 	const char *val;
 	bool inv;
+	int regex;
 } TfwCfgRule;
 
 typedef struct {
@@ -415,6 +416,12 @@ enum {
 	TFW_CFG_B_KEEP,		/* Keep an entry */
 };
 
+enum {
+	TFW_REGEX_NO = 0,
+	TFW_REGEX_REGULAR,
+	TFW_REGEX_CI,
+};
+
 #define TFW_CFG_F_ADD		(1 << TFW_CFG_B_ADD)
 #define TFW_CFG_F_DEL		(1 << TFW_CFG_B_DEL)
 #define TFW_CFG_F_MOD		(1 << TFW_CFG_B_MOD)