client_class: add split()

libs/client-classification/src/ast.rs

@@ -42,6 +42,7 @@ pub enum Expr {
     Concat(Box<Expr>, Box<Expr>),
     IfElse(Box<Expr>, Box<Expr>, Box<Expr>),
     Hexstring(Box<Expr>, String),
+    Split(Box<Expr>, Box<Expr>, usize),
     // prefix
     Not(Box<Expr>),
     // postfix
@@ -82,6 +83,8 @@ pub enum ParseErr {
     IfElse(String),
     #[error("'concat parse error with: {0}")]
     Concat(String),
+    #[error("'split parse error with: {0}")]
+    Split(String),
     #[error("expected option but found: {0}")]
     Option(Expr),
     #[error("bool parse error with: {0}")]
@@ -177,6 +180,23 @@ fn parse_expr(pairs: Pairs<Rule>, pratt: &PrattParser<Rule>) -> ParseResult<Expr
                         Box::new(parse_expr(b.into_inner(), pratt)?),
                     )
                 }
+                Rule::split => {
+                    let mut inner = primary.into_inner();
+                    let n = inner
+                        .next_back()
+                        .ok_or_else(|| ParseErr::Split(inner.to_string()))?;
+                    let del = inner
+                        .next_back()
+                        .ok_or_else(|| ParseErr::Split(inner.to_string()))?;
+                    let s = inner
+                        .next_back()
+                        .ok_or_else(|| ParseErr::Split(inner.to_string()))?;
+                    Expr::Split(
+                        Box::new(parse_expr(s.into_inner(), pratt)?),
+                        Box::new(parse_expr(del.into_inner(), pratt)?),
+                        n.as_str().parse()?,
+                    )
+                }
                 Rule::hexstring => {
                     let mut inner = primary.into_inner();
                     let separator = parse_string(

libs/client-classification/src/grammar.pest

@@ -25,20 +25,6 @@ option = { "option[" ~ integer ~ "]" }
 relay = { "relay4[" ~ integer ~ "]" }
 member = { "member(" ~ string ~ ")" }
 
-// builtin = _{
-//     builtin_bootp
-//     | builtin_known
-//     | builtin_unknown
-//     | builtin_all
-//     | builtin_drop
-//     | builtin_vendor
-// }
-//     builtin_bootp = @{ "BOOTP" }
-//     builtin_known = @{ "KNOWN" }
-//     builtin_unknown = @{ "UNKNOWN" }
-//     builtin_all = @{ "ALL" }
-//     builtin_vendor = @{ "VENDOR_CLASS_" ~ ANY }
-
 pkt = _{
     pkt_mac
     | pkt_hlen
@@ -77,6 +63,7 @@ end = _{
 
 
 substring = { "substring(" ~ expr ~ "," ~ signed_int ~ "," ~ end ~ ")" }
+split = { "split(" ~ expr ~ "," ~ expr ~ "," ~ integer ~ ")" }
 concat = { "concat(" ~ expr ~ "," ~ expr ~ ")" }
 hexstring = { "hexstring(" ~ expr ~ "," ~ string ~ ")" }
 ifelse = { "ifelse(" ~ expr ~ "," ~ expr ~ "," ~ expr ~ ")" }
@@ -92,7 +79,24 @@ postfix  =  _{ to_hex | to_text | exists | sub_opt }
     exists    =   { ".exists" }
     sub_opt   =   { "." ~ option }
 
-primary = _{ hex | ip | integer | string | boolean | option | relay | pkt | pkt_base | substring | concat | ifelse | hexstring | member | "(" ~ expr ~ ")" }
+primary = _{ hex
+    | ip
+    | integer
+    | string
+    | boolean
+    | option
+    | relay
+    | pkt
+    | pkt_base
+    | substring
+    | concat
+    | split
+    | ifelse
+    | hexstring
+    | member
+    | "(" ~ expr ~ ")"
+}
+
 predicate = _{ SOI ~ expr ~ EOI }
 
 WHITESPACE = _{ " " | "\t" | "\r" | "\n" }

libs/client-classification/src/lib.rs

@@ -274,6 +274,12 @@ pub fn eval(expr: &Expr, args: &Args) -> Result<Val, EvalErr> {
             }
             (a, _b) => return Err(EvalErr::ExpectedString(a)),
         },
+        E::Split(lhs, del, n) => match (eval(lhs, args)?, eval(del, args)?) {
+            (Val::String(a), Val::String(del)) => split(a, &del, *n),
+            (Val::String(a), Val::Bytes(b)) => split(a, str::from_utf8(&b)?, *n),
+            // TODO: split() handling bytes?
+            (a, _b) => return Err(EvalErr::ExpectedString(a)),
+        },
         E::IfElse(expr, a, b) => {
             if is_bool(eval(expr, args)?)? {
                 eval(a, args)?
@@ -293,6 +299,16 @@ pub fn eval(expr: &Expr, args: &Args) -> Result<Val, EvalErr> {
     })
 }
 
+// expects `n` to start at 1
+fn split(a: String, del: &str, n: usize) -> Val {
+    Val::String(
+        a.split(del)
+            .nth(n - 1)
+            .map(ToString::to_string)
+            .unwrap_or(String::new()),
+    )
+}
+
 fn substring(s: &str, start: isize, j: Option<isize>) -> String {
     match get_pos(s.len(), start, j) {
         None => String::default(),
@@ -831,6 +847,75 @@ mod tests {
         assert_eq!(substring("foobar", 0, Some(10)), "foobar");
     }
 
+    #[test]
+    fn test_split() {
+        // from kea docs:
+        // split ('one.two..four', '.', 1) == 'one'
+        // split ('one.two..four', '.', 2) == 'two'
+        // split ('one.two..four', '.', 3) == ''
+        // split ('one.two..four', '.', 4) == 'four'
+        // split ('one.two..four', '.', 5) == ''
+        //
+        assert_eq!(
+            split("one.two..four".to_string(), ".", 1),
+            Val::String("one".to_string())
+        );
+        assert_eq!(
+            split("one.two..four".to_string(), ".", 2),
+            Val::String("two".to_string())
+        );
+        assert_eq!(
+            split("one.two..four".to_string(), ".", 3),
+            Val::String("".to_string())
+        );
+        assert_eq!(
+            split("one.two..four".to_string(), ".", 4),
+            Val::String("four".to_string())
+        );
+        assert_eq!(
+            split("one.two..four".to_string(), ".", 5),
+            Val::String("".to_string())
+        );
+    }
+
+    #[test]
+    fn test_split_expr() {
+        let args = Args {
+            chaddr: &hex::decode("DEADBEEF").unwrap(),
+            opts: HashMap::new(),
+            msg: &v4::Message::default(),
+            member: HashSet::new(),
+            pkt: PacketDetails::default(),
+        };
+
+        assert_eq!(
+            eval(
+                &ast::parse("split('one.two..four', '.', 1) == 'one'").unwrap(),
+                &args,
+            )
+            .unwrap(),
+            Val::Bool(true)
+        );
+
+        assert_eq!(
+            eval(
+                &ast::parse("split('one.two..four', '.', 2) == 'two'").unwrap(),
+                &args,
+            )
+            .unwrap(),
+            Val::Bool(true)
+        );
+
+        assert_eq!(
+            eval(
+                &ast::parse("split('one.two..four', '.', 3) == ''").unwrap(),
+                &args,
+            )
+            .unwrap(),
+            Val::Bool(true)
+        );
+    }
+
     #[test]
     fn test_concat() {
         let args = Args {