1998-11-27 19:36:06 +00:00
|
|
|
/*
|
|
|
|
* BIRD -- Configuration Parser Top
|
|
|
|
*
|
2000-03-01 11:42:13 +00:00
|
|
|
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
|
1998-11-27 19:36:06 +00:00
|
|
|
*
|
|
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
CF_HDR
|
|
|
|
|
2011-03-13 10:33:50 +00:00
|
|
|
#define PARSER 1
|
|
|
|
|
1998-11-27 19:36:06 +00:00
|
|
|
#include "nest/bird.h"
|
|
|
|
#include "conf/conf.h"
|
1998-11-27 21:09:57 +00:00
|
|
|
#include "lib/resource.h"
|
|
|
|
#include "lib/socket.h"
|
2022-09-09 13:04:36 +00:00
|
|
|
#include "lib/settle.h"
|
2017-06-06 14:47:30 +00:00
|
|
|
#include "lib/timer.h"
|
2000-03-31 23:30:21 +00:00
|
|
|
#include "lib/string.h"
|
1998-11-27 21:09:57 +00:00
|
|
|
#include "nest/protocol.h"
|
1998-11-29 22:03:58 +00:00
|
|
|
#include "nest/iface.h"
|
2023-10-29 15:25:01 +00:00
|
|
|
#include "nest/route.h"
|
2020-11-08 14:33:22 +00:00
|
|
|
#include "nest/bfd.h"
|
Parse CLI commands. We use the same parser as for configuration files (because
we want to allow filter and similar complex constructs to be used in commands
and we should avoid code duplication), only with CLI_MARKER token prepended
before the whole input.
Defined macro CF_CLI(cmd, args, help) for defining CLI commands in .Y files.
The first argument specifies the command itself, the remaining two arguments
are copied to the help file (er, will be copied after the help file starts
to exist). This macro automatically creates a skeleton rule for the command,
you only need to append arguments as in:
CF_CLI(STEAL MONEY, <$>, [[Steal <$> US dollars or equivalent in any other currency]]): NUM {
cli_msg(0, "%d$ stolen", $3);
} ;
Also don't forget to reset lexer state between inputs.
1999-10-31 17:47:47 +00:00
|
|
|
#include "nest/cli.h"
|
1999-01-15 16:49:17 +00:00
|
|
|
#include "filter/filter.h"
|
1998-11-27 19:36:06 +00:00
|
|
|
|
1999-12-02 14:03:25 +00:00
|
|
|
/* FIXME: Turn on YYERROR_VERBOSE and work around lots of bison bugs? */
|
|
|
|
|
2011-05-06 20:00:54 +00:00
|
|
|
CF_DEFINES
|
|
|
|
|
2024-06-26 15:19:24 +00:00
|
|
|
static bool this_sadr_from_hack_active;
|
2024-01-28 22:37:08 +00:00
|
|
|
|
2011-05-06 20:00:54 +00:00
|
|
|
static void
|
2017-05-23 15:22:53 +00:00
|
|
|
check_u16(uint val)
|
2011-05-06 20:00:54 +00:00
|
|
|
{
|
|
|
|
if (val > 0xFFFF)
|
2017-05-23 15:22:53 +00:00
|
|
|
cf_error("Value %u out of range (0-65535)", val);
|
2011-05-06 20:00:54 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 20:18:49 +00:00
|
|
|
#define cf_assert(cond, ...) do { if (!(cond)) cf_error(__VA_ARGS__); } while (0)
|
|
|
|
static inline void cf_assert_symbol(const struct symbol *sym, uint class) {
|
|
|
|
switch (class) {
|
|
|
|
case SYM_PROTO: cf_assert(sym->class == SYM_PROTO, "Protocol name required"); break;
|
|
|
|
case SYM_TEMPLATE: cf_assert(sym->class == SYM_TEMPLATE, "Protocol template name required"); break;
|
|
|
|
case SYM_FUNCTION: cf_assert(sym->class == SYM_FUNCTION, "Function name required"); break;
|
|
|
|
case SYM_FILTER: cf_assert(sym->class == SYM_FILTER, "Filter name required"); break;
|
|
|
|
case SYM_TABLE: cf_assert(sym->class == SYM_TABLE, "Table name required"); break;
|
|
|
|
case SYM_ATTRIBUTE: cf_assert(sym->class == SYM_ATTRIBUTE, "Custom attribute name required"); break;
|
2022-09-14 23:38:18 +00:00
|
|
|
case SYM_MPLS_DOMAIN: cf_assert(sym->class == SYM_MPLS_DOMAIN, "MPLS domain name required"); break;
|
|
|
|
case SYM_MPLS_RANGE: cf_assert(sym->class == SYM_MPLS_RANGE, "MPLS range name required"); break;
|
2019-05-17 20:18:49 +00:00
|
|
|
case SYM_VARIABLE: cf_assert((sym->class & ~0xff) == SYM_VARIABLE, "Variable name required"); break;
|
|
|
|
case SYM_CONSTANT: cf_assert((sym->class & ~0xff) == SYM_CONSTANT, "Constant name required"); break;
|
|
|
|
default: bug("This shall not happen");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-11-27 19:36:06 +00:00
|
|
|
CF_DECLS
|
|
|
|
|
|
|
|
%union {
|
2017-05-23 15:22:53 +00:00
|
|
|
uint i;
|
1999-08-03 19:36:06 +00:00
|
|
|
u32 i32;
|
2016-02-09 13:53:29 +00:00
|
|
|
u64 i64;
|
1998-11-27 19:36:06 +00:00
|
|
|
ip_addr a;
|
2015-11-05 11:48:52 +00:00
|
|
|
ip4_addr ip4;
|
|
|
|
ip6_addr ip6;
|
2015-12-24 14:52:03 +00:00
|
|
|
net_addr net;
|
2015-11-12 01:03:59 +00:00
|
|
|
net_addr *net_ptr;
|
1998-11-27 19:36:06 +00:00
|
|
|
struct symbol *s;
|
2020-04-08 20:25:15 +00:00
|
|
|
const char *t;
|
1999-05-17 20:14:52 +00:00
|
|
|
struct rtable_config *r;
|
2016-01-26 10:48:58 +00:00
|
|
|
struct channel_config *cc;
|
2020-12-07 21:19:40 +00:00
|
|
|
struct channel *c;
|
1999-03-17 14:29:39 +00:00
|
|
|
struct f_inst *x;
|
2019-07-02 23:23:49 +00:00
|
|
|
struct {
|
|
|
|
struct f_inst *begin, *end;
|
|
|
|
} xp;
|
2019-01-21 08:17:54 +00:00
|
|
|
enum filter_return fret;
|
|
|
|
enum ec_subtype ecs;
|
2022-03-19 15:23:42 +00:00
|
|
|
struct ea_class *ea_class;
|
2017-10-19 10:39:44 +00:00
|
|
|
struct f_static_attr fsa;
|
2022-03-19 15:23:42 +00:00
|
|
|
struct f_attr_bit fab;
|
2019-01-30 13:03:47 +00:00
|
|
|
struct f_lval flv;
|
2019-05-21 16:33:37 +00:00
|
|
|
struct f_line *fl;
|
2022-03-03 02:38:12 +00:00
|
|
|
struct f_arg *fa;
|
2019-02-15 12:53:17 +00:00
|
|
|
const struct filter *f;
|
1999-04-12 19:58:18 +00:00
|
|
|
struct f_tree *e;
|
2009-03-31 10:55:57 +00:00
|
|
|
struct f_trie *trie;
|
2023-11-02 13:33:00 +00:00
|
|
|
const struct f_trie *const_trie;
|
1999-04-12 19:58:18 +00:00
|
|
|
struct f_val v;
|
1999-05-26 14:24:32 +00:00
|
|
|
struct password_item *p;
|
1999-12-01 15:10:21 +00:00
|
|
|
struct rt_show_data *ra;
|
2012-03-16 11:47:12 +00:00
|
|
|
struct sym_show_data *sd;
|
2012-03-16 11:12:26 +00:00
|
|
|
struct lsadb_show_data *ld;
|
2018-11-20 16:38:19 +00:00
|
|
|
struct mrt_dump_data *md;
|
2023-09-18 15:32:24 +00:00
|
|
|
struct mpls_show_ranges_cmd *msrc;
|
2024-03-04 22:20:53 +00:00
|
|
|
struct bfd_show_sessions_cmd *bssc;
|
2012-01-01 11:02:20 +00:00
|
|
|
struct iface *iface;
|
1999-12-06 13:50:50 +00:00
|
|
|
void *g;
|
2017-06-06 14:47:30 +00:00
|
|
|
btime time;
|
2015-12-16 09:25:12 +00:00
|
|
|
struct f_prefix px;
|
2010-02-19 23:03:31 +00:00
|
|
|
struct proto_spec ps;
|
2016-01-26 10:48:58 +00:00
|
|
|
struct channel_limit cl;
|
2010-02-02 23:19:24 +00:00
|
|
|
struct timeformat *tf;
|
2022-09-09 13:04:36 +00:00
|
|
|
struct settle_config settle;
|
2022-05-05 17:28:56 +00:00
|
|
|
struct adata *ad;
|
2023-09-18 12:43:58 +00:00
|
|
|
const struct adata *bs;
|
2023-06-21 11:15:07 +00:00
|
|
|
struct aggr_item_node *ai;
|
1998-11-27 19:36:06 +00:00
|
|
|
}
|
|
|
|
|
2011-05-06 20:00:54 +00:00
|
|
|
%token END CLI_MARKER INVALID_TOKEN ELSECOL DDOT
|
2023-07-04 17:07:30 +00:00
|
|
|
%token GEQ LEQ NEQ AND OR IMP
|
2009-03-14 11:43:10 +00:00
|
|
|
%token PO PC
|
1999-11-15 11:35:41 +00:00
|
|
|
%token <i> NUM ENUM
|
2015-11-05 11:48:52 +00:00
|
|
|
%token <ip4> IP4
|
|
|
|
%token <ip6> IP6
|
2016-02-09 13:53:29 +00:00
|
|
|
%token <i64> VPN_RD
|
Filter: Methods rework
Methods can now be called as x.m(y), as long as x can have its type
inferred in config time. If used as a command, it modifies the object,
if used as a value, it keeps the original object intact.
Also functions add(x,y), delete(x,y), filter(x,y) and prepend(x,y) now
spit a warning and are considered deprecated.
It's also possible to call a method on a constant, see filter/test.conf
for examples like bgp_path = +empty+.prepend(1).
Inside instruction definitions (filter/f-inst.c), a METHOD_CONSTRUCTOR()
call is added, which registers the instruction as a method for the type
of its first argument. Each type has its own method symbol table and
filter parser switches between them based on the inferred type of the
object calling the method.
Also FI_CLIST_(ADD|DELETE|FILTER) instructions have been split to allow
for this method dispatch. With type inference, it's now possible.
2023-06-16 15:35:37 +00:00
|
|
|
%token <s> CF_SYM_KNOWN CF_SYM_UNDEFINED CF_SYM_METHOD_BARE CF_SYM_METHOD_ARGS
|
1998-11-27 19:36:06 +00:00
|
|
|
%token <t> TEXT
|
2023-08-24 02:30:42 +00:00
|
|
|
%token <bs> BYTETEXT
|
2012-01-01 11:02:20 +00:00
|
|
|
%type <iface> ipa_scope
|
1998-11-27 19:36:06 +00:00
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
%type <i> expr bool pxlen4
|
2017-06-20 13:55:39 +00:00
|
|
|
%type <time> expr_us time
|
2022-09-09 13:04:36 +00:00
|
|
|
%type <settle> settle
|
2024-01-28 22:37:08 +00:00
|
|
|
%type <a> ipa net_ip6_slash
|
2022-06-07 08:35:48 +00:00
|
|
|
%type <net> net_ip4_ net_ip4 net_ip6_ net_ip6 net_ip_ net_ip net_or_ipa
|
2023-10-15 14:04:36 +00:00
|
|
|
%type <net_ptr> net_ net_any net_vpn4_ net_vpn6_ net_vpn_ net_roa4_ net_roa6_ net_roa_ net_ip6_sadr_ net_mpls_ net_aspa_
|
2022-05-05 17:28:56 +00:00
|
|
|
%type <ad> label_stack_start label_stack
|
2015-11-12 01:03:59 +00:00
|
|
|
|
|
|
|
%type <t> text opttext
|
2023-08-24 14:59:23 +00:00
|
|
|
%type <bs> bytestring
|
2023-10-25 12:41:11 +00:00
|
|
|
%type <s> symbol
|
1998-11-27 21:32:45 +00:00
|
|
|
|
2023-08-25 02:32:01 +00:00
|
|
|
%type <v> bytestring_text text_or_ipa
|
2023-08-24 14:59:23 +00:00
|
|
|
%type <x> bytestring_expr
|
1998-11-27 21:32:45 +00:00
|
|
|
|
2000-05-16 14:24:33 +00:00
|
|
|
%nonassoc PREFIX_DUMMY
|
2010-01-27 22:45:36 +00:00
|
|
|
%left AND OR
|
2023-07-04 17:07:30 +00:00
|
|
|
%nonassoc '=' '<' '>' '~' GEQ LEQ NEQ NMA IMP PO PC
|
2022-03-25 18:15:11 +00:00
|
|
|
%left '|' '&'
|
2010-01-27 22:45:36 +00:00
|
|
|
%left '+' '-'
|
1998-11-27 21:32:45 +00:00
|
|
|
%left '*' '/' '%'
|
1999-04-07 12:11:08 +00:00
|
|
|
%left '!'
|
2010-10-08 12:25:53 +00:00
|
|
|
%nonassoc '.'
|
1998-11-27 21:32:45 +00:00
|
|
|
|
2019-05-17 20:18:49 +00:00
|
|
|
%start config
|
|
|
|
|
2023-06-13 07:39:29 +00:00
|
|
|
CF_KEYWORDS(DEFINE, ON, OFF, YES, NO, S, MS, US, PORT, VPN, MPLS, FROM, MAX, AS)
|
1998-11-27 21:32:45 +00:00
|
|
|
|
1998-11-27 19:36:06 +00:00
|
|
|
CF_GRAMMAR
|
|
|
|
|
1998-11-27 21:32:45 +00:00
|
|
|
/* Basic config file structure */
|
|
|
|
|
Parse CLI commands. We use the same parser as for configuration files (because
we want to allow filter and similar complex constructs to be used in commands
and we should avoid code duplication), only with CLI_MARKER token prepended
before the whole input.
Defined macro CF_CLI(cmd, args, help) for defining CLI commands in .Y files.
The first argument specifies the command itself, the remaining two arguments
are copied to the help file (er, will be copied after the help file starts
to exist). This macro automatically creates a skeleton rule for the command,
you only need to append arguments as in:
CF_CLI(STEAL MONEY, <$>, [[Steal <$> US dollars or equivalent in any other currency]]): NUM {
cli_msg(0, "%d$ stolen", $3);
} ;
Also don't forget to reset lexer state between inputs.
1999-10-31 17:47:47 +00:00
|
|
|
config: conf_entries END { return 0; }
|
1999-11-17 12:00:21 +00:00
|
|
|
| CLI_MARKER cli_cmd { return 0; }
|
1998-11-27 19:36:06 +00:00
|
|
|
;
|
|
|
|
|
|
|
|
conf_entries:
|
|
|
|
/* EMPTY */
|
1999-03-29 19:04:14 +00:00
|
|
|
| conf_entries conf
|
1998-11-27 19:36:06 +00:00
|
|
|
;
|
|
|
|
|
2018-06-26 12:29:03 +00:00
|
|
|
conf: ';' ;
|
1998-11-27 19:36:06 +00:00
|
|
|
|
2013-07-25 20:33:57 +00:00
|
|
|
|
1999-01-15 14:41:51 +00:00
|
|
|
/* Constant expressions */
|
1998-11-27 21:32:45 +00:00
|
|
|
|
2018-06-26 12:29:03 +00:00
|
|
|
conf: definition ;
|
|
|
|
|
2013-07-25 20:33:57 +00:00
|
|
|
definition:
|
2019-07-30 12:28:40 +00:00
|
|
|
DEFINE symbol '=' term ';' {
|
2023-10-13 11:36:47 +00:00
|
|
|
struct f_val *val = cf_eval($4, T_VOID);
|
2023-06-13 08:51:03 +00:00
|
|
|
cf_define_symbol(new_config, $2, SYM_CONSTANT | val->type, val, val);
|
2013-07-25 20:33:57 +00:00
|
|
|
}
|
|
|
|
;
|
|
|
|
|
1999-01-15 18:04:28 +00:00
|
|
|
expr:
|
1998-11-27 21:32:45 +00:00
|
|
|
NUM
|
2023-08-24 02:45:55 +00:00
|
|
|
| '(' term ')' { $$ = cf_eval_int($2); }
|
2023-10-25 12:41:11 +00:00
|
|
|
| CF_SYM_KNOWN {
|
2019-05-17 20:18:49 +00:00
|
|
|
if ($1->class != (SYM_CONSTANT | T_INT)) cf_error("Number constant expected");
|
2013-07-25 20:33:57 +00:00
|
|
|
$$ = SYM_VAL($1).i; }
|
1998-11-27 21:32:45 +00:00
|
|
|
;
|
|
|
|
|
2013-09-16 21:57:40 +00:00
|
|
|
expr_us:
|
2017-06-20 13:55:39 +00:00
|
|
|
expr S { $$ = $1 S_; }
|
|
|
|
| expr MS { $$ = $1 MS_; }
|
|
|
|
| expr US { $$ = $1 US_; }
|
2013-09-16 21:57:40 +00:00
|
|
|
;
|
|
|
|
|
2023-10-25 12:41:11 +00:00
|
|
|
symbol: CF_SYM_UNDEFINED | CF_SYM_KNOWN ;
|
2019-01-30 13:03:47 +00:00
|
|
|
|
1998-12-06 17:38:42 +00:00
|
|
|
/* Switches */
|
|
|
|
|
|
|
|
bool:
|
2016-11-08 16:46:29 +00:00
|
|
|
expr { $$ = !!$1; }
|
1998-12-06 17:38:42 +00:00
|
|
|
| ON { $$ = 1; }
|
|
|
|
| YES { $$ = 1; }
|
|
|
|
| OFF { $$ = 0; }
|
|
|
|
| NO { $$ = 0; }
|
|
|
|
| /* Silence means agreement */ { $$ = 1; }
|
|
|
|
;
|
|
|
|
|
2000-05-15 11:48:23 +00:00
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
/* Addresses */
|
2015-11-05 11:48:52 +00:00
|
|
|
|
2000-05-15 11:48:23 +00:00
|
|
|
ipa:
|
2015-12-24 14:52:03 +00:00
|
|
|
IP4 { $$ = ipa_from_ip4($1); }
|
|
|
|
| IP6 { $$ = ipa_from_ip6($1); }
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
|
|
|
if ($1->class != (SYM_CONSTANT | T_IP)) cf_error("IP address constant expected");
|
2015-12-16 09:25:12 +00:00
|
|
|
$$ = SYM_VAL($1).ip;
|
2000-05-15 11:48:23 +00:00
|
|
|
}
|
|
|
|
;
|
1998-12-06 23:10:45 +00:00
|
|
|
|
2012-01-01 11:02:20 +00:00
|
|
|
ipa_scope:
|
|
|
|
/* empty */ { $$ = NULL; }
|
2019-01-30 13:03:47 +00:00
|
|
|
| '%' symbol { $$ = if_get_by_name($2->name); }
|
2012-01-01 11:02:20 +00:00
|
|
|
;
|
|
|
|
|
2015-11-12 01:03:59 +00:00
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
/* Networks - internal */
|
2015-11-12 01:03:59 +00:00
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
pxlen4:
|
|
|
|
'/' NUM {
|
2017-05-23 15:22:53 +00:00
|
|
|
if ($2 > IP4_MAX_PREFIX_LENGTH) cf_error("Invalid prefix length %u", $2);
|
2015-12-24 14:52:03 +00:00
|
|
|
$$ = $2;
|
|
|
|
}
|
|
|
|
;
|
2015-11-12 01:03:59 +00:00
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
net_ip4_: IP4 pxlen4
|
|
|
|
{
|
|
|
|
net_fill_ip4(&($$), $1, $2);
|
2016-06-30 13:04:49 +00:00
|
|
|
|
|
|
|
net_addr_ip4 *n = (void *) &($$);
|
|
|
|
if (!net_validate_ip4(n))
|
|
|
|
cf_error("Invalid IPv4 prefix %I4/%d, maybe you wanted %I4/%d",
|
|
|
|
n->prefix, n->pxlen, ip4_and(n->prefix, ip4_mkmask(n->pxlen)), n->pxlen);
|
2015-12-24 14:52:03 +00:00
|
|
|
};
|
2015-11-12 01:03:59 +00:00
|
|
|
|
2024-01-28 22:37:08 +00:00
|
|
|
net_ip6_slash: IP6 '/'
|
2015-12-24 14:52:03 +00:00
|
|
|
{
|
2024-01-28 22:37:08 +00:00
|
|
|
this_sadr_from_hack_active = cf_maybe_exit_filters();
|
|
|
|
$$ = $1;
|
|
|
|
}
|
|
|
|
|
|
|
|
net_ip6_: net_ip6_slash NUM
|
|
|
|
{
|
|
|
|
if (this_sadr_from_hack_active)
|
|
|
|
{
|
|
|
|
cf_enter_filters();
|
|
|
|
this_sadr_from_hack_active = 0;
|
|
|
|
}
|
2016-06-30 13:04:49 +00:00
|
|
|
|
2024-01-28 22:37:08 +00:00
|
|
|
if ($2 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid prefix length %u", $2);
|
|
|
|
|
|
|
|
net_fill_ip6(&($$), $1, $2);
|
2016-06-30 13:04:49 +00:00
|
|
|
|
|
|
|
net_addr_ip6 *n = (void *) &($$);
|
|
|
|
if (!net_validate_ip6(n))
|
|
|
|
cf_error("Invalid IPv6 prefix %I6/%d, maybe you wanted %I6/%d",
|
|
|
|
n->prefix, n->pxlen, ip6_and(n->prefix, ip6_mkmask(n->pxlen)), n->pxlen);
|
2015-12-24 14:52:03 +00:00
|
|
|
};
|
2015-11-12 01:03:59 +00:00
|
|
|
|
2024-01-28 22:37:08 +00:00
|
|
|
net_ip6_sadr_: net_ip6_slash NUM FROM IP6 '/' NUM
|
2018-02-13 15:27:57 +00:00
|
|
|
{
|
2024-01-28 22:37:08 +00:00
|
|
|
if (this_sadr_from_hack_active)
|
|
|
|
{
|
|
|
|
cf_enter_filters();
|
|
|
|
this_sadr_from_hack_active = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (($3->class != SYM_KEYWORD) || ($3->keyword->value != FROM))
|
|
|
|
cf_error("Expected FROM after %I6/%d", $1, $2);
|
|
|
|
|
|
|
|
if ($2 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid prefix length %u", $2);
|
2018-02-13 15:27:57 +00:00
|
|
|
|
2024-01-28 22:37:08 +00:00
|
|
|
if ($6 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid prefix length %u", $6);
|
2018-02-13 15:27:57 +00:00
|
|
|
|
|
|
|
$$ = cfg_alloc(sizeof(net_addr_ip6_sadr));
|
2024-01-28 22:37:08 +00:00
|
|
|
net_fill_ip6_sadr($$, $1, $2, $4, $6);
|
2018-02-13 15:27:57 +00:00
|
|
|
|
|
|
|
net_addr_ip6_sadr *n = (void *) $$;
|
|
|
|
if (!net_validate_ip6_sadr(n))
|
|
|
|
cf_error("Invalid SADR IPv6 prefix %I6/%d from %I6/%d, maybe you wanted %I6/%d from %I6/%d",
|
|
|
|
n->dst_prefix, n->dst_pxlen, n->src_prefix, n->src_pxlen,
|
|
|
|
ip6_and(n->dst_prefix, ip6_mkmask(n->dst_pxlen)), n->dst_pxlen,
|
|
|
|
ip6_and(n->src_prefix, ip6_mkmask(n->src_pxlen)), n->src_pxlen);
|
|
|
|
};
|
|
|
|
|
2016-02-09 13:53:29 +00:00
|
|
|
net_vpn4_: VPN_RD net_ip4_
|
|
|
|
{
|
|
|
|
$$ = cfg_alloc(sizeof(net_addr_vpn4));
|
2017-02-20 01:26:45 +00:00
|
|
|
net_fill_vpn4($$, net4_prefix(&$2), net4_pxlen(&$2), $1);
|
2016-02-09 13:53:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
net_vpn6_: VPN_RD net_ip6_
|
|
|
|
{
|
|
|
|
$$ = cfg_alloc(sizeof(net_addr_vpn6));
|
2017-02-20 01:26:45 +00:00
|
|
|
net_fill_vpn6($$, net6_prefix(&$2), net6_pxlen(&$2), $1);
|
2016-02-09 13:53:29 +00:00
|
|
|
}
|
|
|
|
|
2016-01-20 13:55:37 +00:00
|
|
|
net_roa4_: net_ip4_ MAX NUM AS NUM
|
|
|
|
{
|
2016-01-21 09:24:50 +00:00
|
|
|
$$ = cfg_alloc(sizeof(net_addr_roa4));
|
2016-05-12 14:04:47 +00:00
|
|
|
net_fill_roa4($$, net4_prefix(&$1), net4_pxlen(&$1), $3, $5);
|
2017-05-23 15:22:53 +00:00
|
|
|
if ($3 < net4_pxlen(&$1) || $3 > IP4_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid max prefix length %u", $3);
|
2016-01-20 13:55:37 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
net_roa6_: net_ip6_ MAX NUM AS NUM
|
|
|
|
{
|
2016-01-21 09:24:50 +00:00
|
|
|
$$ = cfg_alloc(sizeof(net_addr_roa6));
|
2016-05-12 14:04:47 +00:00
|
|
|
net_fill_roa6($$, net6_prefix(&$1), net6_pxlen(&$1), $3, $5);
|
2017-05-23 15:22:53 +00:00
|
|
|
if ($3 < net6_pxlen(&$1) || $3 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid max prefix length %u", $3);
|
2016-01-20 13:55:37 +00:00
|
|
|
};
|
|
|
|
|
2017-12-11 23:05:49 +00:00
|
|
|
net_mpls_: MPLS NUM
|
|
|
|
{
|
2023-10-25 16:25:46 +00:00
|
|
|
$$ = cfg_alloc(sizeof(net_addr_mpls));
|
2017-12-11 23:05:49 +00:00
|
|
|
net_fill_mpls($$, $2);
|
|
|
|
}
|
|
|
|
|
2023-10-15 14:04:36 +00:00
|
|
|
net_aspa_: ASPA NUM
|
|
|
|
{
|
|
|
|
$$ = cfg_alloc(sizeof(net_addr_aspa));
|
|
|
|
net_fill_aspa($$, $2);
|
|
|
|
}
|
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
net_ip_: net_ip4_ | net_ip6_ ;
|
2016-02-09 13:53:29 +00:00
|
|
|
net_vpn_: net_vpn4_ | net_vpn6_ ;
|
2017-02-20 01:26:45 +00:00
|
|
|
net_roa_: net_roa4_ | net_roa6_ ;
|
2016-01-20 13:55:37 +00:00
|
|
|
|
2016-01-21 09:24:50 +00:00
|
|
|
net_:
|
|
|
|
net_ip_ { $$ = cfg_alloc($1.length); net_copy($$, &($1)); }
|
2016-02-09 13:53:29 +00:00
|
|
|
| net_vpn_
|
2016-01-21 09:24:50 +00:00
|
|
|
| net_roa_
|
2016-12-07 14:36:15 +00:00
|
|
|
| net_flow_
|
2018-02-13 15:27:57 +00:00
|
|
|
| net_ip6_sadr_
|
2017-12-11 23:05:49 +00:00
|
|
|
| net_mpls_
|
2023-10-15 14:04:36 +00:00
|
|
|
| net_aspa_
|
2016-01-21 09:24:50 +00:00
|
|
|
;
|
2015-11-12 01:03:59 +00:00
|
|
|
|
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
/* Networks - regular */
|
|
|
|
|
2022-06-07 08:35:48 +00:00
|
|
|
net_ip4:
|
|
|
|
net_ip4_
|
|
|
|
| CF_SYM_KNOWN {
|
|
|
|
if (($1->class != (SYM_CONSTANT | T_NET)) || (SYM_VAL($1).net->type != NET_IP4))
|
|
|
|
cf_error("IPv4 network constant expected");
|
|
|
|
$$ = * SYM_VAL($1).net;
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
net_ip6:
|
|
|
|
net_ip6_
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
2015-12-24 14:52:03 +00:00
|
|
|
if (($1->class != (SYM_CONSTANT | T_NET)) || (SYM_VAL($1).net->type != NET_IP6))
|
2019-05-17 20:18:49 +00:00
|
|
|
cf_error("IPv6 network constant expected");
|
2015-12-24 14:52:03 +00:00
|
|
|
$$ = * SYM_VAL($1).net;
|
2015-12-11 14:35:37 +00:00
|
|
|
}
|
2015-12-24 14:52:03 +00:00
|
|
|
;
|
|
|
|
|
|
|
|
net_ip:
|
|
|
|
net_ip_
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
2015-12-24 14:52:03 +00:00
|
|
|
if (($1->class != (SYM_CONSTANT | T_NET)) || !net_is_ip(SYM_VAL($1).net))
|
2019-05-17 20:18:49 +00:00
|
|
|
cf_error("IP network constant expected");
|
2015-12-24 14:52:03 +00:00
|
|
|
$$ = * SYM_VAL($1).net;
|
2000-05-13 11:17:49 +00:00
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
net_any:
|
|
|
|
net_
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
2015-12-24 14:52:03 +00:00
|
|
|
if ($1->class != (SYM_CONSTANT | T_NET))
|
2019-05-17 20:18:49 +00:00
|
|
|
cf_error("Network constant expected");
|
2015-12-24 14:52:03 +00:00
|
|
|
$$ = (net_addr *) SYM_VAL($1).net; /* Avoid const warning */
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
|
|
|
net_or_ipa:
|
|
|
|
net_ip4_
|
|
|
|
| net_ip6_
|
|
|
|
| IP4 { net_fill_ip4(&($$), $1, IP4_MAX_PREFIX_LENGTH); }
|
|
|
|
| IP6 { net_fill_ip6(&($$), $1, IP6_MAX_PREFIX_LENGTH); }
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
2015-12-24 14:52:03 +00:00
|
|
|
if ($1->class == (SYM_CONSTANT | T_IP))
|
|
|
|
net_fill_ip_host(&($$), SYM_VAL($1).ip);
|
|
|
|
else if (($1->class == (SYM_CONSTANT | T_NET)) && net_is_ip(SYM_VAL($1).net))
|
|
|
|
$$ = * SYM_VAL($1).net;
|
|
|
|
else
|
2019-05-17 20:18:49 +00:00
|
|
|
cf_error("IP address or network constant expected");
|
1998-12-06 23:10:45 +00:00
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2016-06-13 13:49:53 +00:00
|
|
|
label_stack_start: NUM
|
|
|
|
{
|
2022-05-05 17:28:56 +00:00
|
|
|
$$ = cfg_allocz(ADATA_SIZE(MPLS_MAX_LABEL_STACK * sizeof(u32)));
|
|
|
|
$$->length = sizeof(u32);
|
|
|
|
*((u32 *)$$->data) = $1;
|
2016-06-13 13:49:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
label_stack:
|
|
|
|
label_stack_start
|
|
|
|
| label_stack '/' NUM {
|
2022-05-05 17:28:56 +00:00
|
|
|
if ($1->length >= MPLS_MAX_LABEL_STACK * sizeof(u32))
|
2017-02-20 01:26:45 +00:00
|
|
|
cf_error("Too many labels in stack");
|
2022-05-05 17:28:56 +00:00
|
|
|
|
|
|
|
*((u32 *)($$->data + $1->length)) = $3;
|
|
|
|
$1->length += sizeof(u32);
|
2016-06-13 13:49:53 +00:00
|
|
|
$$ = $1;
|
|
|
|
}
|
|
|
|
;
|
2015-12-24 14:52:03 +00:00
|
|
|
|
2017-06-06 14:47:30 +00:00
|
|
|
time:
|
2000-03-01 11:42:13 +00:00
|
|
|
TEXT {
|
2017-06-06 14:47:30 +00:00
|
|
|
$$ = tm_parse_time($1);
|
2000-03-01 11:42:13 +00:00
|
|
|
if (!$$)
|
2017-06-06 14:47:30 +00:00
|
|
|
cf_error("Invalid date/time");
|
2000-03-01 11:42:13 +00:00
|
|
|
}
|
1999-05-26 14:24:32 +00:00
|
|
|
;
|
|
|
|
|
2022-09-09 13:04:36 +00:00
|
|
|
/* Settle timer configuration */
|
|
|
|
settle: expr_us expr_us {
|
|
|
|
if ($1 > $2) cf_error("Minimum settle time %t is bigger than maximum settle time %t", $1, $2);
|
|
|
|
$$.min = $1;
|
|
|
|
$$.max = $2;
|
|
|
|
};
|
|
|
|
|
2014-05-29 21:05:03 +00:00
|
|
|
text:
|
|
|
|
TEXT
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
|
|
|
if ($1->class != (SYM_CONSTANT | T_STRING)) cf_error("String constant expected");
|
2014-05-29 21:05:03 +00:00
|
|
|
$$ = SYM_VAL($1).s;
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2015-11-05 11:48:52 +00:00
|
|
|
opttext:
|
|
|
|
TEXT
|
|
|
|
| /* empty */ { $$ = NULL; }
|
|
|
|
;
|
|
|
|
|
2023-08-25 02:32:01 +00:00
|
|
|
text_or_ipa:
|
|
|
|
TEXT { $$.type = T_STRING; $$.val.s = $1; }
|
|
|
|
| IP4 { $$.type = T_IP; $$.val.ip = ipa_from_ip4($1); }
|
|
|
|
| IP6 { $$.type = T_IP; $$.val.ip = ipa_from_ip6($1); }
|
|
|
|
| CF_SYM_KNOWN {
|
|
|
|
if (($1->class == (SYM_CONSTANT | T_STRING)) ||
|
|
|
|
($1->class == (SYM_CONSTANT | T_IP)))
|
|
|
|
$$ = *($1->val);
|
|
|
|
else
|
|
|
|
cf_error("String or IP constant expected");
|
|
|
|
}
|
|
|
|
| '(' term ')' {
|
2023-10-13 12:02:21 +00:00
|
|
|
$$ = *cf_eval($2, T_VOID);
|
2023-08-25 02:32:01 +00:00
|
|
|
if (($$.type != T_BYTESTRING) && ($$.type != T_STRING))
|
|
|
|
cf_error("Bytestring or string value expected");
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2023-08-24 14:59:23 +00:00
|
|
|
bytestring:
|
|
|
|
BYTETEXT
|
2023-10-13 11:46:04 +00:00
|
|
|
| bytestring_expr { $$ = cf_eval($1, T_BYTESTRING)->val.bs; }
|
2023-08-24 14:59:23 +00:00
|
|
|
;
|
|
|
|
|
|
|
|
bytestring_text:
|
|
|
|
BYTETEXT { $$.type = T_BYTESTRING; $$.val.bs = $1; }
|
|
|
|
| TEXT { $$.type = T_STRING; $$.val.s = $1; }
|
|
|
|
| bytestring_expr {
|
2023-10-13 11:46:04 +00:00
|
|
|
$$ = *cf_eval($1, T_VOID);
|
2023-08-24 14:59:23 +00:00
|
|
|
if (($$.type != T_BYTESTRING) && ($$.type != T_STRING))
|
|
|
|
cf_error("Bytestring or string value expected");
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
|
|
|
bytestring_expr:
|
2023-10-29 18:53:09 +00:00
|
|
|
lvalue { $$ = f_lval_getter(&$1); }
|
2023-08-24 14:59:23 +00:00
|
|
|
| term_bs
|
|
|
|
| '(' term ')' { $$ = $2; }
|
|
|
|
;
|
|
|
|
|
2015-11-05 11:48:52 +00:00
|
|
|
|
1998-11-27 19:36:06 +00:00
|
|
|
CF_CODE
|
|
|
|
|
|
|
|
CF_END
|