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);