From: Ondrej Zajicek <santiago@crfreenet.org>
Date: Tue, 3 Jun 2025 02:04:47 +0000 (+0200)
Subject: Filter: Add 'append' operator
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=8cdbe42c763bb0af239fe5aa574d1861483ce16a;p=thirdparty%2Fbird.git

Filter: Add 'append' operator

We need append() operator to concatenate strings / bytestrings.
Can be also written as '++', (e.g. "abcd" ++ "1234").
---

diff --git a/conf/cf-lex.l b/conf/cf-lex.l
index 0119e1f55..f13b1c12b 100644
--- a/conf/cf-lex.l
+++ b/conf/cf-lex.l
@@ -380,6 +380,7 @@ else: {
 \&\& return AND;
 \|\| return OR;
 \-\> return IMP;
+\+\+ return PP;
 
 \[\= return PO;
 \=\] return PC;
diff --git a/conf/confbase.Y b/conf/confbase.Y
index b2ba3cafb..27c422eab 100644
--- a/conf/confbase.Y
+++ b/conf/confbase.Y
@@ -130,7 +130,7 @@ CF_DECLS
 }
 
 %token END CLI_MARKER INVALID_TOKEN ELSECOL DDOT
-%token GEQ LEQ NEQ AND OR IMP
+%token GEQ LEQ NEQ AND OR IMP PP
 %token PO PC
 %token <i> NUM ENUM_TOKEN
 %token <ip4> IP4
@@ -158,7 +158,7 @@ CF_DECLS
 %nonassoc PREFIX_DUMMY
 %left AND OR
 %nonassoc '=' '<' '>' '~' GEQ LEQ NEQ NMA IMP PO PC
-%left '+' '-'
+%left '+' '-' PP
 %left '*' '/' '%'
 %left '!'
 %nonassoc '.'
diff --git a/doc/bird.sgml b/doc/bird.sgml
index 5f91a8fd4..d981936af 100644
--- a/doc/bird.sgml
+++ b/doc/bird.sgml
@@ -1613,17 +1613,21 @@ in the foot).
 	This is a string of characters. There are no ways to modify strings in
 	filters. You can pass them between functions, assign them to variables
 	of type <cf/string/, print such variables, use standard string
-	comparison operations (e.g. <cf/=, !=, &lt;, &gt;, &lt;=, &gt;=/), but
-	you can't concatenate two strings. String literals are written as
-	<cf/"This is a string constant"/. Additionally matching (<cf/&tilde;,
-	!&tilde;/) operators could be used to match a string value against
-	a shell pattern (represented also as a string).
+	comparison operations (e.g. <cf/=, !=, &lt;, &gt;, &lt;=, &gt;=/), and
+	concatenate two strings with <cf>append(<m/A/, <m/B/)</cf> function or
+	<cf/++/ operator.
+
+	String literals are written as <cf/"This is a string constant"/.
+	Additionally matching (<cf/&tilde;, !&tilde;/) operators could be used
+	to match a string value against a shell pattern (represented also as a
+	string).
 
 	<tag><label id="type-bytestring">bytestring</tag>
 	This is a sequence of arbitrary bytes. There are no ways to modify
 	bytestrings in filters. You can pass them between functions, assign
-	them to variables of type <cf/bytestring/, print such values, and
-	compare bytestings (<cf/=, !=/).
+	them to variables of type <cf/bytestring/, print such values, compare
+	bytestings (<cf/=, !=/), and concatenate two bytestrings with
+	<cf>append(<m/A/, <m/B/)</cf> function or <cf/++/ operator.
 
 	Bytestring literals are written as a sequence of hexadecimal digit
 	pairs, optionally colon-separated. A bytestring specified this way
@@ -1920,6 +1924,8 @@ parentheses <cf/(a*(b+c))/, comparison <cf/(a=b, a!=b, a&lt;b, a&gt;=b)/.</p>
 <p>Logical operations include unary not (<cf/!/), and (<cf/&amp;&amp;/), and or
 (<cf/&verbar;&verbar;/).</p>
 
+<p>Strings and bytestrings can be concatenated with <cf/++/ operator.</p>
+
 <p>Special operators include (<cf/&tilde;/, <cf/!&tilde;/) for "is (not) element
 of a set" operation - it can be used on:
 <itemize>
diff --git a/filter/config.Y b/filter/config.Y
index 562530e2d..d4ffa2043 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -368,6 +368,7 @@ CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
 	DEFINED,
 	ADD, DELETE, RESET,
 	PREPEND,
+	APPEND,
 	EMPTY,
 	FILTER, WHERE, EVAL, ATTRIBUTE,
 	FROM_HEX,
@@ -950,10 +951,13 @@ term:
  | '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_LCLIST)); }
 
  | PREPEND '(' term ',' term ')' { $$ = f_dispatch_method_x("prepend", $3->type, $3, $5); }
+ | APPEND '(' term ',' term ')' { $$ = f_dispatch_method_x("append", $3->type, $3, $5); }
  | ADD '(' term ',' term ')' { $$ = f_dispatch_method_x("add", $3->type, $3, $5); }
  | DELETE '(' term ',' term ')' { $$ = f_dispatch_method_x("delete", $3->type, $3, $5); }
  | FILTER '(' term ',' term ')' { $$ = f_dispatch_method_x("filter", $3->type, $3, $5); }
 
+ | term PP term { $$ = f_dispatch_method_x("append", $1->type, $1, $3); }
+
  | ROA_CHECK '(' rtable ')' { $$ = f_new_inst(FI_ROA_CHECK_IMPLICIT, $3); }
  | ROA_CHECK '(' rtable ',' term ',' term ')' { $$ = f_new_inst(FI_ROA_CHECK_EXPLICIT, $5, $7, $3); }
  | ASPA_CHECK '(' rtable ',' term ',' term ')' { $$ = f_new_inst(FI_ASPA_CHECK_EXPLICIT, $5, $7, $3); }
diff --git a/filter/data.c b/filter/data.c
index f5a9e5eec..9b052f894 100644
--- a/filter/data.c
+++ b/filter/data.c
@@ -668,3 +668,15 @@ val_dump(const struct f_val *v) {
   val_format(v, &b);
   return val_dump_buffer;
 }
+
+const struct adata *
+bytestring_append(struct linpool *pool, const struct adata *v1, const struct adata *v2)
+{
+  if (!v1 || !v2)
+    return v1 ?: v2;
+
+  struct adata *res = lp_alloc_adata(pool, v1->length + v2->length);
+  memcpy(res->data, v1->data, v1->length);
+  memcpy(res->data + v1->length, v2->data, v2->length);
+  return res;
+}
diff --git a/filter/data.h b/filter/data.h
index f36820cba..82871daf2 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -325,6 +325,8 @@ const struct adata *clist_filter(struct linpool *pool, const struct adata *list,
 const struct adata *eclist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos);
 const struct adata *lclist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos);
 
+const struct adata *bytestring_append(struct linpool *pool, const struct adata *v1, const struct adata *v2);
+
 
 /* Special undef value for paths and clists */
 
diff --git a/filter/f-inst.c b/filter/f-inst.c
index f94580a66..234a36103 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -1294,6 +1294,22 @@
     RESULT(T_PATH, ad, [[ as_path_prepend(fpool, v1.val.ad, v2.val.i) ]]);
   }
 
+  /* String append */
+  INST(FI_STRING_APPEND, 2, 1) {
+    ARG(1, T_STRING);
+    ARG(2, T_STRING);
+    METHOD_CONSTRUCTOR("append");
+    RESULT(T_STRING, s, [[ lp_strcat(fpool, v1.val.s, v2.val.s) ]]);
+  }
+
+  /* Bytestring append */
+  INST(FI_BYTESTRING_APPEND, 2, 1) {
+    ARG(1, T_BYTESTRING);
+    ARG(2, T_BYTESTRING);
+    METHOD_CONSTRUCTOR("append");
+    RESULT(T_BYTESTRING, ad, [[ bytestring_append(fpool, v1.val.ad, v2.val.ad) ]]);
+  }
+
   /* Community list add */
   INST(FI_CLIST_ADD_PAIR, 2, 1) {
     ARG(1, T_CLIST);
diff --git a/filter/test.conf b/filter/test.conf
index 3df9b6975..0540b111a 100644
--- a/filter/test.conf
+++ b/filter/test.conf
@@ -241,8 +241,8 @@ bt_test_suite(t_int_set, "Testing sets of integers");
 
 
 /*
- * 	Testing string matching
- * 	-----------------------
+ * 	Testing strings
+ * 	---------------
  */
 
 function t_string()
@@ -254,9 +254,13 @@ function t_string()
 	bt_assert(st ~ "Hello");
 	bt_assert(st ~ "Hell?");
 	bt_assert(st !~ "ell*");
+
+	bt_assert("abcd".append(format(1234)) = "abcd1234");
+	bt_assert(append("He", "llo") = st);
+	bt_assert("Hello" ++ " " ++ "world" = "Hello world");
 }
 
-bt_test_suite(t_string, "Testing string matching");
+bt_test_suite(t_string, "Testing strings");
 
 
 
@@ -284,6 +288,11 @@ function t_bytestring()
 	bt_assert(from_hex("01:12:23:34:45:56:67:78:89:9a:ab:bc:cd:de:ef:f0") = bs2);
 	bt_assert(from_hex(format(bs2)) = bs2);
 	bt_assert(from_hex(" 0112:23-34455667 78-89 - 9a-ab bc:cd : de:eff0 ") = bs2);
+
+	bt_assert(hex:6778899a.append(hex:01122334) = hex:6778899a01122334);
+	bt_assert(append(hex:01122334, hex:6778899a) = hex:011223346778899a);
+	bt_assert(hex:01:12:23:34:45:56 ++ hex:67:78:89:9a:ab ++ hex:bc:cd:de:ef:f0 = bs2);
+
 }
 
 bt_test_suite(t_bytestring, "Testing bytestrings");
diff --git a/lib/string.h b/lib/string.h
index 8831666c7..0107c5949 100644
--- a/lib/string.h
+++ b/lib/string.h
@@ -66,6 +66,17 @@ lp_strdup(linpool *lp, const char *c)
   return z;
 }
 
+static inline char *
+lp_strcat(linpool *lp, const char *s1, const char *s2)
+{
+  size_t l1 = strlen(s1);
+  size_t l2 = strlen(s2);
+  char *z = lp_allocu(lp, l1 + l2 + 1);
+  memcpy(z, s1, l1);
+  memcpy(z + l1, s2, l2 + 1);
+  return z;
+}
+
 static inline void
 memset32(void *D, u32 val, uint n)
 {