Merge pull request #540 from tempesta-tech/ab-match-suffix

Implement "suffix" operation for string matching. (#495, #471)

Author: keshonok

README.md

@@ -282,12 +282,14 @@ header. Host part in URI takes priority over the `Host` header value.
 * **hdr_conn**  The value of `Connection` header.
 * **hdr_raw** The contents of any other HTTP header field as specified by
 `ARG`. `ARG` must include contents of an HTTP header starting with the header
-field name. Processing of `hdr_raw` may be slow because it requires walking
-over all headers of an HTTP request.
+field name. The `suffix` `OP` is not supported for this `FIELD`. Processing
+of `hdr_raw` may be slow because it requires walking over all headers of an
+HTTP request.
 
 The following `OP` keywords are supported:
 * **eq** `FIELD` is fully equal to the string specified in `ARG`.
 * **prefix** `FIELD` starts with the string specified in `ARG`.
+* **suffix** `FIELD` ends with the string specified in `ARG`.
 
 Below are examples of pattern-matching rules that define the HTTP scheduler:
 ```
@@ -297,10 +299,14 @@ srv_group bar_app { ... }
 
 sched_http_rules {
 	match static   uri       prefix  "/static";
+	match static   uri       suffix  ".php";
 	match static   host      prefix  "static.";
+	match static   host      suffix  "tempesta-tech.com";
 	match foo_app  host      eq      "foo.example.com";
 	match bar_app  hdr_conn  eq      "keep-alive";
 	match bar_app  hdr_host  prefix  "bar.";
+	match bar_app  hdr_host  suffix  "natsys-lab.com";
+	match bar_app  hdr_host  eq      "bar.natsys-lab.com";
 	match bar_app  hdr_raw   prefix  "X-Custom-Bar-Hdr: ";
 }
 ```

tempesta_fw/http_match.c

@@ -86,7 +86,7 @@
 
 /**
  * Look up a header in the @req->h_tbl by given @id,
- * and compare @val with the header's value (skipping name and LWS).
+ * and compare @str with the header's value (skipping name and LWS).
  *
  * For example:
  *   hdr_val_eq(req, TFW_HTTP_HDR_HOST, "natsys-lab", 10, TFW_STR_EQ_PREFIX);
@@ -96,8 +96,8 @@
  *   "Host  :  natsys-lab.com"
  */
 static bool
-hdr_val_eq(const TfwHttpReq *req, tfw_http_hdr_t id, const char *val,
-	   int val_len, tfw_str_eq_flags_t f)
+hdr_val_eq(const TfwHttpReq *req, tfw_http_hdr_t id, tfw_http_match_op_t op,
+	   const char *str, int str_len, tfw_str_eq_flags_t flags)
 {
 	TfwStr *hdr;
 	TfwStr hdr_val;
@@ -110,7 +110,11 @@ hdr_val_eq(const TfwHttpReq *req, tfw_http_hdr_t id, const char *val,
 
 	tfw_http_msg_clnthdr_val(hdr, id, &hdr_val);
 
-	return tfw_str_eq_cstr(&hdr_val, val, val_len, f);
+	if (op == TFW_HTTP_MATCH_O_SUFFIX)
+		return tfw_str_eq_cstr_off(&hdr_val, hdr_val.len - str_len,
+					   str, str_len, flags);
+
+	return tfw_str_eq_cstr(&hdr_val, str, str_len, flags);
 }
 
 /**
@@ -123,6 +127,7 @@ map_op_to_str_eq_flags(tfw_http_match_op_t op)
 		[ 0 ... _TFW_HTTP_MATCH_O_COUNT ] = -1,
 		[TFW_HTTP_MATCH_O_EQ]     = TFW_STR_EQ_DEFAULT,
 		[TFW_HTTP_MATCH_O_PREFIX] = TFW_STR_EQ_PREFIX,
+		[TFW_HTTP_MATCH_O_SUFFIX] = TFW_STR_EQ_DEFAULT,
 	};
 	BUG_ON(flags_tbl[op] < 0);
 	return flags_tbl[op];
@@ -142,6 +147,8 @@ match_method(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 static bool
 match_uri(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 {
+	const TfwStr *uri_path = &req->uri_path;
+	const TfwHttpMatchArg *arg = &rule->arg;
 	tfw_str_eq_flags_t flags = map_op_to_str_eq_flags(rule->op);
 
 	/* RFC 7230:
@@ -152,12 +159,18 @@ match_uri(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 	 */
 	flags |= TFW_STR_EQ_CASEI;
 
-	return tfw_str_eq_cstr(&req->uri_path, rule->arg.str, rule->arg.len, flags);
+	if (rule->op == TFW_HTTP_MATCH_O_SUFFIX)
+		return tfw_str_eq_cstr_off(uri_path, uri_path->len - arg->len,
+					   arg->str, arg->len, flags);
+
+	return tfw_str_eq_cstr(uri_path, arg->str, arg->len, flags);
 }
 
 static bool
 match_host(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 {
+	const TfwStr *host = &req->host;
+	const TfwHttpMatchArg *arg = &rule->arg;
 	tfw_str_eq_flags_t flags = map_op_to_str_eq_flags(rule->op);
 
 	/*
@@ -172,12 +185,15 @@ match_host(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 
 	flags |= TFW_STR_EQ_CASEI;
 
-	if (req->host.len)
-		return tfw_str_eq_cstr(&req->host, rule->arg.str,
-				       rule->arg.len, flags);
+	if (host->len == 0)
+		return hdr_val_eq(req, TFW_HTTP_HDR_HOST,
+				  rule->op, arg->str, arg->len, flags);
+
+	if (rule->op == TFW_HTTP_MATCH_O_SUFFIX)
+		return tfw_str_eq_cstr_off(host, host->len - arg->len,
+					   arg->str, arg->len, flags);
 
-	return hdr_val_eq(req, TFW_HTTP_HDR_HOST, rule->arg.str,
-			  rule->arg.len, flags);
+	return tfw_str_eq_cstr(host, arg->str, arg->len, flags);
 }
 
 static bool
@@ -189,6 +205,7 @@ match_hdr(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 		[TFW_HTTP_MATCH_F_HDR_HOST] = TFW_HTTP_HDR_HOST,
 	};
 
+	const TfwHttpMatchArg *arg = &rule->arg;
 	tfw_str_eq_flags_t flags = map_op_to_str_eq_flags(rule->op);
 	tfw_http_hdr_t id = id_tbl[rule->field];
 	BUG_ON(id < 0);
@@ -197,7 +214,7 @@ match_hdr(const TfwHttpReq *req, const TfwHttpMatchRule *rule)
 	 * TODO: case-sensitive matching for headers when required by RFC. */
 	flags |= TFW_STR_EQ_CASEI;
 
-	return hdr_val_eq(req, id, rule->arg.str, rule->arg.len, flags);
+	return hdr_val_eq(req, id, rule->op, arg->str, arg->len, flags);
 }
 
 #define _MOVE_TO_COND(p, end, cond)			\

tempesta_fw/http_match.h

@@ -43,6 +43,7 @@ typedef enum {
 	TFW_HTTP_MATCH_O_WILDCARD,
 	TFW_HTTP_MATCH_O_EQ,
 	TFW_HTTP_MATCH_O_PREFIX,
+	TFW_HTTP_MATCH_O_SUFFIX,
 	_TFW_HTTP_MATCH_O_COUNT
 } tfw_http_match_op_t;
 

tempesta_fw/sched/tfw_sched_http.c

@@ -173,7 +173,8 @@ static const TfwCfgEnum __read_mostly tfw_sched_http_cfg_op_enum[] = {
 	{ "*",		TFW_HTTP_MATCH_O_WILDCARD },
 	{ "eq",		TFW_HTTP_MATCH_O_EQ },
 	{ "prefix",	TFW_HTTP_MATCH_O_PREFIX },
-	/* TODO: suffix, substr, regex, case sensitive/insensitive versions. */
+	{ "suffix",	TFW_HTTP_MATCH_O_SUFFIX },
+	/* TODO: substr, regex, case sensitive/insensitive versions. */
 	{}
 };
 

tempesta_fw/str.c

@@ -394,7 +394,7 @@ tfw_str_eq_cstr_pos(const TfwStr *str, const char *pos, const char *cstr,
 
 			r = tfw_str_eq_cstr(&tmp, cstr, cstr_len, flags);
 
-			*v = t; /* restore chunk */
+			*v = t; /* Restore the chunk */
 			goto out;
 		}
 
@@ -410,8 +410,57 @@ tfw_str_eq_cstr_pos(const TfwStr *str, const char *pos, const char *cstr,
 }
 EXPORT_SYMBOL(tfw_str_eq_cstr_pos);
 
+/*
+ * Compare @str starting at offset @offset with a plain C string
+ * @cstr of size @len. Obey the comparison flags @flags.
+ *
+ * The function prepares a substring of @str and then calls
+ * tfw_str_eq_cstr(). Note that a chunk of @str is modified in the
+ * process, but the original contents is restored before the result
+ * is returned to the caller.
+ */
+bool
+tfw_str_eq_cstr_off(const TfwStr *str, ssize_t offset, const char *cstr,
+		    int cstr_len, tfw_str_eq_flags_t flags)
+{
+	bool ret = false;
+	TfwStr t, tmp = *str;
+	TfwStr *c, *end;
+
+	BUG_ON(TFW_STR_DUP(str));
+	BUG_ON(!cstr || !cstr_len);
+
+	if (offset < 0)
+		return false;
+	if (offset == 0)
+		return tfw_str_eq_cstr(str, cstr, cstr_len, flags);
+	if (unlikely(offset + cstr_len > str->len))
+		return false;
+
+	TFW_STR_FOR_EACH_CHUNK(c, &tmp, end) {
+		if (offset >= c->len) {
+			offset -= c->len;
+			tmp.len -= c->len;
+			tmp.ptr += sizeof(TfwStr);
+			TFW_STR_CHUNKN_SUB(&tmp, 1);
+			continue;
+		}
+		t = *c;
+		c->ptr += offset;
+		c->len -= offset;
+
+		ret = tfw_str_eq_cstr(&tmp, cstr, cstr_len, flags);
+
+		*c = t; /* Restore the chunk */
+		break;
+	}
+
+	return ret;
+}
+EXPORT_SYMBOL(tfw_str_eq_cstr_off);
+
 /**
- * The function intentionaly brokes zero-copy string design. And should
+ * The function intentionaly breaks zero-copy string design. And should
  * be used for short-strings only.
  *
  * Join all chunks of @str to a single plain C string.

tempesta_fw/str.h

@@ -245,6 +245,8 @@ bool tfw_str_eq_cstr(const TfwStr *str, const char *cstr, int cstr_len,
                      tfw_str_eq_flags_t flags);
 bool tfw_str_eq_cstr_pos(const TfwStr *str, const char *pos, const char *cstr,
 			 int cstr_len, tfw_str_eq_flags_t flags);
+bool tfw_str_eq_cstr_off(const TfwStr *str, ssize_t offset, const char *cstr,
+			 int cstr_len, tfw_str_eq_flags_t flags);
 
 size_t tfw_str_to_cstr(const TfwStr *str, char *out_buf, int buf_size);
 

tempesta_fw/t/unit/test_http_match.c

@@ -135,6 +135,37 @@ TEST(http_match, uri_prefix)
 	EXPECT_EQ(-1, match_id);
 }
 
+TEST(http_match, uri_suffix)
+{
+	int match_id;
+
+	test_mlst_add(1, TFW_HTTP_MATCH_F_URI, TFW_HTTP_MATCH_O_SUFFIX,
+	              ".jpg");
+	test_mlst_add(2, TFW_HTTP_MATCH_F_URI, TFW_HTTP_MATCH_O_SUFFIX,
+	              "/people.html");
+	test_mlst_add(3, TFW_HTTP_MATCH_F_URI, TFW_HTTP_MATCH_O_SUFFIX,
+	              "/bar/folks.html");
+
+	set_tfw_str(&test_req->uri_path, "/foo/bar/picture.jpg");
+	match_id = test_mlst_match();
+	EXPECT_EQ(1, match_id);
+
+	set_tfw_str(&test_req->uri_path, "/foo/bar/people.html");
+	match_id = test_mlst_match();
+	EXPECT_EQ(2, match_id);
+
+	set_tfw_str(&test_req->uri_path, "/foo/bar/folks.html");
+	match_id = test_mlst_match();
+	EXPECT_EQ(3, match_id);
+
+	set_tfw_str(&test_req->uri_path, "../foo");
+	match_id = test_mlst_match();
+	EXPECT_EQ(-1, match_id);
+
+	set_tfw_str(&test_req->uri_path, "/foo/bar/picture.png");
+	match_id = test_mlst_match();
+	EXPECT_EQ(-1, match_id);
+}
 TEST(http_match, host_eq)
 {
 	int match_id;
@@ -217,6 +248,64 @@ TEST(http_match, hdr_host_prefix)
 	free_all_str();
 }
 
+TEST(http_match, hdr_host_suffix)
+{
+	create_str_pool();
+
+	{
+		int match_id;
+
+		/* Special headers must be compound */
+		TFW_STR2(hdr1, "Host: ", "example.biz");
+		TFW_STR2(hdr2, "Host: ", "example.com");
+		TFW_STR2(hdr3, "Host: ", "example.ru");
+		TFW_STR2(hdr4, "Host: ", "eXample.COM");
+		TFW_STR2(hdr5, "Host: ", "www");
+		TFW_STR2(hdr6, "Host: ", "TEST.FOLKS.COM");
+
+		test_mlst_add(1, TFW_HTTP_MATCH_F_HDR_CONN,
+			      TFW_HTTP_MATCH_O_EQ, "Connection:  Keep-Alive");
+		test_mlst_add(2, TFW_HTTP_MATCH_F_HDR_HOST,
+			      TFW_HTTP_MATCH_O_SUFFIX, ".ru");
+		test_mlst_add(3, TFW_HTTP_MATCH_F_HDR_HOST,
+			      TFW_HTTP_MATCH_O_SUFFIX, ".biz");
+		test_mlst_add(4, TFW_HTTP_MATCH_F_HDR_HOST,
+			      TFW_HTTP_MATCH_O_SUFFIX, ".folks.com");
+		test_mlst_add(5, TFW_HTTP_MATCH_F_HDR_HOST,
+			      TFW_HTTP_MATCH_O_SUFFIX, ".com");
+
+		set_tfw_str(&test_req->host, "example.com");
+		match_id = test_mlst_match();
+		EXPECT_EQ(-1, match_id);
+
+		test_req->h_tbl->tbl[TFW_HTTP_HDR_HOST] = *hdr1;
+		match_id = test_mlst_match();
+		EXPECT_EQ(3, match_id);
+
+		test_req->h_tbl->tbl[TFW_HTTP_HDR_HOST] = *hdr2;
+		match_id = test_mlst_match();
+		EXPECT_EQ(5, match_id);
+
+		test_req->h_tbl->tbl[TFW_HTTP_HDR_HOST] = *hdr3;
+		match_id = test_mlst_match();
+		EXPECT_EQ(2, match_id);
+
+		test_req->h_tbl->tbl[TFW_HTTP_HDR_HOST] = *hdr4;
+		match_id = test_mlst_match();
+		EXPECT_EQ(5, match_id);
+
+		test_req->h_tbl->tbl[TFW_HTTP_HDR_HOST] = *hdr5;
+		match_id = test_mlst_match();
+		EXPECT_EQ(-1, match_id);
+
+		test_req->h_tbl->tbl[TFW_HTTP_HDR_HOST] = *hdr6;
+		match_id = test_mlst_match();
+		EXPECT_EQ(4, match_id);
+	}
+
+	free_all_str();
+}
+
 TEST(http_match, method_eq)
 {
 	int match_id;
@@ -259,8 +348,10 @@ TEST_SUITE(http_match)
 
 	TEST_RUN(tfw_http_match_req, returns_first_matching_rule);
 	TEST_RUN(http_match, uri_prefix);
+	TEST_RUN(http_match, uri_suffix);
 	TEST_RUN(http_match, host_eq);
 	TEST_RUN(http_match, headers_eq);
 	TEST_RUN(http_match, hdr_host_prefix);
+	TEST_RUN(http_match, hdr_host_suffix);
 	TEST_RUN(http_match, method_eq);
 }