summaryrefslogtreecommitdiffstats
path: root/src/lib/eval/parser.yy
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/lib/eval/parser.yy649
1 files changed, 649 insertions, 0 deletions
diff --git a/src/lib/eval/parser.yy b/src/lib/eval/parser.yy
new file mode 100644
index 0000000..2015e83
--- /dev/null
+++ b/src/lib/eval/parser.yy
@@ -0,0 +1,649 @@
+/* Copyright (C) 2015-2023 Internet Systems Consortium, Inc. ("ISC")
+
+ This Source Code Form is subject to the terms of the Mozilla Public
+ License, v. 2.0. If a copy of the MPL was not distributed with this
+ file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+%skeleton "lalr1.cc" /* -*- C++ -*- */
+%require "3.3.0"
+%defines
+%define api.parser.class {EvalParser}
+%define api.prefix {eval}
+%define api.token.constructor
+%define api.value.type variant
+%define api.namespace {isc::eval}
+%define parse.assert
+%code requires
+{
+#include <string>
+#include <eval/token.h>
+#include <eval/eval_context_decl.h>
+#include <dhcp/option.h>
+#include <boost/lexical_cast.hpp>
+
+using namespace isc::dhcp;
+using namespace isc::eval;
+}
+// The parsing context.
+%param { EvalContext& ctx }
+%locations
+%define parse.trace
+%define parse.error verbose
+%code
+{
+# include "eval_context.h"
+
+// Avoid warnings with the error counter.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+}
+
+%define api.token.prefix {TOKEN_}
+// Tokens in an order which makes sense and related to the intended use.
+%token
+ END 0 "end of file"
+ LPAREN "("
+ RPAREN ")"
+ NOT "not"
+ AND "and"
+ OR "or"
+ EQUAL "=="
+ OPTION "option"
+ RELAY4 "relay4"
+ RELAY6 "relay6"
+ MEMBER "member"
+ PEERADDR "peeraddr"
+ LINKADDR "linkaddr"
+ LBRACKET "["
+ RBRACKET "]"
+ DOT "."
+ TEXT "text"
+ HEX "hex"
+ EXISTS "exists"
+ PKT "pkt"
+ IFACE "iface"
+ SRC "src"
+ DST "dst"
+ LEN "len"
+ PKT4 "pkt4"
+ CHADDR "mac"
+ HLEN "hlen"
+ HTYPE "htype"
+ CIADDR "ciaddr"
+ GIADDR "giaddr"
+ YIADDR "yiaddr"
+ SIADDR "siaddr"
+ SUBSTRING "substring"
+ SPLIT "split"
+ ALL "all"
+ COMA ","
+ CONCAT "concat"
+ PLUS "+"
+ IFELSE "ifelse"
+ TOHEXSTRING "hexstring"
+ ADDRTOTEXT "addrtotext"
+ INT8TOTEXT "int8totext"
+ INT16TOTEXT "int16totext"
+ INT32TOTEXT "int32totext"
+ UINT8TOTEXT "uint8totext"
+ UINT16TOTEXT "uint16totext"
+ UINT32TOTEXT "uint32totext"
+ PKT6 "pkt6"
+ MSGTYPE "msgtype"
+ TRANSID "transid"
+ VENDOR_CLASS "vendor-class"
+ VENDOR "vendor"
+ ANY "*"
+ DATA "data"
+ ENTERPRISE "enterprise"
+
+ TOPLEVEL_BOOL "top-level bool"
+ TOPLEVEL_STRING "top-level string"
+;
+
+%token <std::string> STRING "constant string"
+%token <std::string> INTEGER "integer"
+%token <std::string> HEXSTRING "constant hexstring"
+%token <std::string> OPTION_NAME "option name"
+%token <std::string> IP_ADDRESS "ip address"
+
+%type <uint16_t> option_code
+%type <uint16_t> sub_option_code
+%type <uint32_t> enterprise_id
+%type <uint32_t> integer_expr
+%type <TokenOption::RepresentationType> option_repr_type
+%type <TokenRelay6Field::FieldType> relay6_field
+%type <int8_t> nest_level
+%type <TokenPkt::MetadataType> pkt_metadata
+%type <TokenPkt4::FieldType> pkt4_field
+%type <TokenPkt6::FieldType> pkt6_field
+
+%left PLUS
+%left OR
+%left AND
+%precedence NOT
+
+%printer { yyoutput << $$; } <*>;
+
+%%
+
+// The whole grammar starts with a 'start' symbol...
+%start start;
+
+// ... that expects either TOPLEVEL_BOOL or TOPLEVEL_STRING. Depending on which
+// token appears first, it will determine what is allowed and what it not.
+start: TOPLEVEL_BOOL expression
+ | TOPLEVEL_STRING string_expr
+;
+
+// Expression can either be a single token or a (something == something) expression
+
+expression : bool_expr
+ ;
+
+bool_expr : "(" bool_expr ")"
+ | NOT bool_expr
+ {
+ TokenPtr neg(new TokenNot());
+ ctx.expression.push_back(neg);
+ }
+ | bool_expr AND bool_expr
+ {
+ TokenPtr neg(new TokenAnd());
+ ctx.expression.push_back(neg);
+ }
+ | bool_expr OR bool_expr
+ {
+ TokenPtr neg(new TokenOr());
+ ctx.expression.push_back(neg);
+ }
+ | string_expr EQUAL string_expr
+ {
+ TokenPtr eq(new TokenEqual());
+ ctx.expression.push_back(eq);
+ }
+ | OPTION "[" option_code "]" "." EXISTS
+ {
+ TokenPtr opt(new TokenOption($3, TokenOption::EXISTS));
+ ctx.expression.push_back(opt);
+ }
+ | OPTION "[" option_code "]" "." OPTION "[" sub_option_code "]" "." EXISTS
+ {
+ TokenPtr opt(new TokenSubOption($3, $8, TokenOption::EXISTS));
+ ctx.expression.push_back(opt);
+ }
+ | RELAY4 "[" sub_option_code "]" "." EXISTS
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V4:
+ {
+ TokenPtr opt(new TokenRelay4Option($3, TokenOption::EXISTS));
+ ctx.expression.push_back(opt);
+ break;
+ }
+ case Option::V6:
+ // We will have relay6[123] for the DHCPv6.
+ // In a very distant future we'll possibly be able
+ // to mix both if we have DHCPv4-over-DHCPv6, so it
+ // has some sense to make it explicit whether we
+ // talk about DHCPv4 relay or DHCPv6 relay. However,
+ // for the time being relay4 can be used in DHCPv4
+ // only.
+ error(@1, "relay4 can only be used in DHCPv4.");
+ }
+ }
+ | RELAY6 "[" nest_level "]" "." OPTION "[" sub_option_code "]" "." EXISTS
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V6:
+ {
+ TokenPtr opt(new TokenRelay6Option($3, $8, TokenOption::EXISTS));
+ ctx.expression.push_back(opt);
+ break;
+ }
+ case Option::V4:
+ // For now we only use relay6 in DHCPv6.
+ error(@1, "relay6 can only be used in DHCPv6.");
+ }
+ }
+ | VENDOR_CLASS "[" enterprise_id "]" "." EXISTS
+ {
+ // Expression: vendor-class[1234].exists
+ //
+ // This token will find option 124 (DHCPv4) or 16 (DHCPv6),
+ // and will check if enterprise-id equals specified value.
+ TokenPtr exist(new TokenVendorClass(ctx.getUniverse(), $3, TokenOption::EXISTS));
+ ctx.expression.push_back(exist);
+ }
+ | VENDOR "[" enterprise_id "]" "." EXISTS
+ {
+ // Expression: vendor[1234].exists
+ //
+ // This token will find option 125 (DHCPv4) or 17 (DHCPv6),
+ // and will check if enterprise-id equals specified value.
+ TokenPtr exist(new TokenVendor(ctx.getUniverse(), $3, TokenOption::EXISTS));
+ ctx.expression.push_back(exist);
+ }
+ | VENDOR "[" enterprise_id "]" "." OPTION "[" sub_option_code "]" "." EXISTS
+ {
+ // Expression vendor[1234].option[123].exists
+ //
+ // This token will check if specified vendor option
+ // exists, has specified enterprise-id and if has
+ // specified suboption.
+ TokenPtr exist(new TokenVendor(ctx.getUniverse(), $3, TokenOption::EXISTS, $8));
+ ctx.expression.push_back(exist);
+ }
+ | MEMBER "(" STRING ")"
+ {
+ // Expression member('foo')
+ //
+ // This token will check if the packet is a member of
+ // the specified client class.
+ // To avoid loops at evaluation only already defined and
+ // built-in classes are allowed.
+ std::string cc = $3;
+ if (!ctx.isClientClassDefined(cc)) {
+ error(@3, "Not defined client class '" + cc + "'");
+ }
+ TokenPtr member(new TokenMember(cc));
+ ctx.expression.push_back(member);
+ }
+ ;
+
+string_expr : STRING
+ {
+ TokenPtr str(new TokenString($1));
+ ctx.expression.push_back(str);
+ }
+ | HEXSTRING
+ {
+ TokenPtr hex(new TokenHexString($1));
+ ctx.expression.push_back(hex);
+ }
+ | IP_ADDRESS
+ {
+ TokenPtr ip(new TokenIpAddress($1));
+ ctx.expression.push_back(ip);
+ }
+ | OPTION "[" option_code "]" "." option_repr_type
+ {
+ TokenPtr opt(new TokenOption($3, $6));
+ ctx.expression.push_back(opt);
+ }
+ | OPTION "[" option_code "]" "." OPTION "[" sub_option_code "]" "." option_repr_type
+ {
+ TokenPtr opt(new TokenSubOption($3, $8, $11));
+ ctx.expression.push_back(opt);
+ }
+ | RELAY4 "[" sub_option_code "]" "." option_repr_type
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V4:
+ {
+ TokenPtr opt(new TokenRelay4Option($3, $6));
+ ctx.expression.push_back(opt);
+ break;
+ }
+ case Option::V6:
+ // We will have relay6[123] for the DHCPv6.
+ // In a very distant future we'll possibly be able
+ // to mix both if we have DHCPv4-over-DHCPv6, so it
+ // has some sense to make it explicit whether we
+ // talk about DHCPv4 relay or DHCPv6 relay. However,
+ // for the time being relay4 can be used in DHCPv4
+ // only.
+ error(@1, "relay4 can only be used in DHCPv4.");
+ }
+ }
+
+ | RELAY6 "[" nest_level "]" "." OPTION "[" sub_option_code "]" "." option_repr_type
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V6:
+ {
+ TokenPtr opt(new TokenRelay6Option($3, $8, $11));
+ ctx.expression.push_back(opt);
+ break;
+ }
+ case Option::V4:
+ // For now we only use relay6 in DHCPv6.
+ error(@1, "relay6 can only be used in DHCPv6.");
+ }
+ }
+
+ | PKT "." pkt_metadata
+ {
+ TokenPtr pkt_metadata(new TokenPkt($3));
+ ctx.expression.push_back(pkt_metadata);
+ }
+ | PKT4 "." pkt4_field
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V4:
+ {
+ TokenPtr pkt4_field(new TokenPkt4($3));
+ ctx.expression.push_back(pkt4_field);
+ break;
+ }
+ case Option::V6:
+ // For now we only use pkt4 in DHCPv4.
+ error(@1, "pkt4 can only be used in DHCPv4.");
+ }
+ }
+ | PKT6 "." pkt6_field
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V6:
+ {
+ TokenPtr pkt6_field(new TokenPkt6($3));
+ ctx.expression.push_back(pkt6_field);
+ break;
+ }
+ case Option::V4:
+ // For now we only use pkt6 in DHCPv6.
+ error(@1, "pkt6 can only be used in DHCPv6.");
+ }
+ }
+ | RELAY6 "[" nest_level "]" "." relay6_field
+ {
+ switch (ctx.getUniverse()) {
+ case Option::V6:
+ {
+ TokenPtr relay6field(new TokenRelay6Field($3, $6));
+ ctx.expression.push_back(relay6field);
+ break;
+ }
+ case Option::V4:
+ // For now we only use relay6 in DHCPv6.
+ error(@1, "relay6 can only be used in DHCPv6.");
+ }
+ }
+
+ | SUBSTRING "(" string_expr "," start_expr "," length_expr ")"
+ {
+ TokenPtr sub(new TokenSubstring());
+ ctx.expression.push_back(sub);
+ }
+ | SPLIT "(" string_expr "," string_expr "," int_expr ")"
+ {
+ TokenPtr split(new TokenSplit());
+ ctx.expression.push_back(split);
+ }
+ | CONCAT "(" string_expr "," string_expr ")"
+ {
+ TokenPtr conc(new TokenConcat());
+ ctx.expression.push_back(conc);
+ }
+ | string_expr PLUS string_expr
+ {
+ TokenPtr conc(new TokenConcat());
+ ctx.expression.push_back(conc);
+ }
+ | IFELSE "(" bool_expr "," string_expr "," string_expr ")"
+ {
+ TokenPtr cond(new TokenIfElse());
+ ctx.expression.push_back(cond);
+ }
+ | TOHEXSTRING "(" string_expr "," string_expr ")"
+ {
+ TokenPtr tohex(new TokenToHexString());
+ ctx.expression.push_back(tohex);
+ }
+ | ADDRTOTEXT "(" string_expr ")"
+ {
+ TokenPtr addrtotext(new TokenIpAddressToText());
+ ctx.expression.push_back(addrtotext);
+ }
+ | INT8TOTEXT "(" string_expr ")"
+ {
+ TokenPtr int8totext(new TokenInt8ToText());
+ ctx.expression.push_back(int8totext);
+ }
+ | INT16TOTEXT "(" string_expr ")"
+ {
+ TokenPtr int16totext(new TokenInt16ToText());
+ ctx.expression.push_back(int16totext);
+ }
+ | INT32TOTEXT "(" string_expr ")"
+ {
+ TokenPtr int32totext(new TokenInt32ToText());
+ ctx.expression.push_back(int32totext);
+ }
+ | UINT8TOTEXT "(" string_expr ")"
+ {
+ TokenPtr uint8totext(new TokenUInt8ToText());
+ ctx.expression.push_back(uint8totext);
+ }
+ | UINT16TOTEXT "(" string_expr ")"
+ {
+ TokenPtr uint16totext(new TokenUInt16ToText());
+ ctx.expression.push_back(uint16totext);
+ }
+ | UINT32TOTEXT "(" string_expr ")"
+ {
+ TokenPtr uint32totext(new TokenUInt32ToText());
+ ctx.expression.push_back(uint32totext);
+ }
+ | VENDOR "." ENTERPRISE
+ {
+ // expression: vendor.enterprise
+ //
+ // This token will return enterprise-id number of
+ // received vendor option.
+ TokenPtr vendor(new TokenVendor(ctx.getUniverse(), 0, TokenVendor::ENTERPRISE_ID));
+ ctx.expression.push_back(vendor);
+ }
+ | VENDOR_CLASS "." ENTERPRISE
+ {
+ // expression: vendor-class.enterprise
+ //
+ // This token will return enterprise-id number of
+ // received vendor class option.
+ TokenPtr vendor(new TokenVendorClass(ctx.getUniverse(), 0,
+ TokenVendor::ENTERPRISE_ID));
+ ctx.expression.push_back(vendor);
+ }
+ | VENDOR "[" enterprise_id "]" "." OPTION "[" sub_option_code "]" "." option_repr_type
+ {
+ // This token will search for vendor option with
+ // specified enterprise-id. If found, will search
+ // for specified suboption and finally will return
+ // its content.
+ TokenPtr opt(new TokenVendor(ctx.getUniverse(), $3, $11, $8));
+ ctx.expression.push_back(opt);
+ }
+ | VENDOR_CLASS "[" enterprise_id "]" "." DATA
+ {
+ // expression: vendor-class[1234].data
+ //
+ // Vendor class option does not have suboptions,
+ // but chunks of data (typically 1, but the option
+ // structure allows multiple of them). If chunk
+ // offset is not specified, we assume the first (0th)
+ // is requested.
+ TokenPtr vendor_class(new TokenVendorClass(ctx.getUniverse(), $3,
+ TokenVendor::DATA, 0));
+ ctx.expression.push_back(vendor_class);
+ }
+ | VENDOR_CLASS "[" enterprise_id "]" "." DATA "[" INTEGER "]"
+ {
+ // expression: vendor-class[1234].data[5]
+ //
+ // Vendor class option does not have suboptions,
+ // but chunks of data (typically 1, but the option
+ // structure allows multiple of them). This syntax
+ // specifies which data chunk (tuple) we want.
+ uint8_t index = ctx.convertUint8($8, @8);
+ TokenPtr vendor_class(new TokenVendorClass(ctx.getUniverse(), $3,
+ TokenVendor::DATA, index));
+ ctx.expression.push_back(vendor_class);
+ }
+ | integer_expr
+ {
+ TokenPtr integer(new TokenInteger($1));
+ ctx.expression.push_back(integer);
+ }
+ | "(" string_expr ")"
+ ;
+
+integer_expr : INTEGER
+ {
+ $$ = ctx.convertUint32($1, @1);
+ }
+ ;
+
+option_code : INTEGER
+ {
+ $$ = ctx.convertOptionCode($1, @1);
+ }
+ | OPTION_NAME
+ {
+ $$ = ctx.convertOptionName($1, @1);
+ }
+ ;
+
+sub_option_code : INTEGER
+ {
+ $$ = ctx.convertOptionCode($1, @1);
+ }
+ ;
+
+option_repr_type : TEXT
+ {
+ $$ = TokenOption::TEXTUAL;
+ }
+ | HEX
+ {
+ $$ = TokenOption::HEXADECIMAL;
+ }
+ ;
+
+nest_level : INTEGER
+ {
+ $$ = ctx.convertNestLevelNumber($1, @1);
+ }
+ // Eventually we may add strings to handle different
+ // ways of choosing from which relay we want to extract
+ // an option or field.
+ ;
+
+pkt_metadata : IFACE
+ {
+ $$ = TokenPkt::IFACE;
+ }
+ | SRC
+ {
+ $$ = TokenPkt::SRC;
+ }
+ | DST
+ {
+ $$ = TokenPkt::DST;
+ }
+ | LEN
+ {
+ $$ = TokenPkt::LEN;
+ }
+ ;
+
+enterprise_id : INTEGER
+ {
+ $$ = ctx.convertUint32($1, @1);
+ }
+ | "*"
+ {
+ $$ = 0;
+ }
+ ;
+
+pkt4_field : CHADDR
+ {
+ $$ = TokenPkt4::CHADDR;
+ }
+ | HLEN
+ {
+ $$ = TokenPkt4::HLEN;
+ }
+ | HTYPE
+ {
+ $$ = TokenPkt4::HTYPE;
+ }
+ | CIADDR
+ {
+ $$ = TokenPkt4::CIADDR;
+ }
+ | GIADDR
+ {
+ $$ = TokenPkt4::GIADDR;
+ }
+ | YIADDR
+ {
+ $$ = TokenPkt4::YIADDR;
+ }
+ | SIADDR
+ {
+ $$ = TokenPkt4::SIADDR;
+ }
+ | MSGTYPE
+ {
+ $$ = TokenPkt4::MSGTYPE;
+ }
+ | TRANSID
+ {
+ $$ = TokenPkt4::TRANSID;
+ }
+ ;
+
+pkt6_field : MSGTYPE
+ {
+ $$ = TokenPkt6::MSGTYPE;
+ }
+ | TRANSID
+ {
+ $$ = TokenPkt6::TRANSID;
+ }
+ ;
+
+relay6_field : PEERADDR
+ {
+ $$ = TokenRelay6Field::PEERADDR;
+ }
+ | LINKADDR
+ {
+ $$ = TokenRelay6Field::LINKADDR;
+ }
+ ;
+
+start_expr : INTEGER
+ {
+ TokenPtr str(new TokenString($1));
+ ctx.expression.push_back(str);
+ }
+ ;
+
+length_expr : INTEGER
+ {
+ TokenPtr str(new TokenString($1));
+ ctx.expression.push_back(str);
+ }
+ | ALL
+ {
+ TokenPtr str(new TokenString("all"));
+ ctx.expression.push_back(str);
+ }
+ ;
+int_expr : INTEGER
+ {
+ TokenPtr str(new TokenString($1));
+ ctx.expression.push_back(str);
+ }
+ ;
+
+%%
+void
+isc::eval::EvalParser::error(const location_type& loc,
+ const std::string& what)
+{
+ ctx.error(loc, what);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-27 05:26:05 +0000