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"
|
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"
|
1998-12-06 17:38:42 +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
|
|
|
|
|
|
|
|
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;
|
|
|
|
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;
|
2023-04-27 16:20:49 +00:00
|
|
|
struct keyword *kw;
|
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;
|
2017-10-19 10:39:44 +00:00
|
|
|
struct f_dynamic_attr fda;
|
|
|
|
struct f_static_attr fsa;
|
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;
|
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;
|
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;
|
2017-03-17 14:48:09 +00:00
|
|
|
mpls_label_stack *mls;
|
2023-08-22 12:44:18 +00:00
|
|
|
const struct bytestring *bs;
|
1998-11-27 19:36:06 +00:00
|
|
|
}
|
|
|
|
|
2011-05-06 20:00:54 +00:00
|
|
|
%token END CLI_MARKER INVALID_TOKEN ELSECOL DDOT
|
2000-06-01 08:43:29 +00:00
|
|
|
%token GEQ LEQ NEQ AND OR
|
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
|
2019-05-17 20:18:49 +00:00
|
|
|
%token <s> CF_SYM_KNOWN CF_SYM_UNDEFINED
|
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
|
2015-12-24 14:52:03 +00:00
|
|
|
%type <a> ipa
|
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
|
2018-02-13 15:27:57 +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_
|
2017-03-17 14:48:09 +00:00
|
|
|
%type <mls> 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
|
2019-01-30 13:03:47 +00:00
|
|
|
%type <s> symbol
|
2023-04-27 16:20:49 +00:00
|
|
|
%type <kw> kw_sym
|
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
|
|
|
|
|
2000-05-16 14:24:33 +00:00
|
|
|
%nonassoc PREFIX_DUMMY
|
2010-01-27 22:45:36 +00:00
|
|
|
%left AND OR
|
2016-09-20 13:13:01 +00:00
|
|
|
%nonassoc '=' '<' '>' '~' GEQ LEQ NEQ NMA PO PC
|
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
|
|
|
|
|
2018-02-13 15:27:57 +00:00
|
|
|
CF_KEYWORDS(DEFINE, ON, OFF, YES, NO, S, MS, US, PORT, VPN, MPLS, FROM)
|
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 ';' {
|
2020-11-24 03:09:11 +00:00
|
|
|
struct f_val *val = cfg_allocz(sizeof(struct f_val));
|
2023-08-24 02:45:55 +00:00
|
|
|
*val = cf_eval($4, T_VOID);
|
2019-02-15 12:53:17 +00:00
|
|
|
cf_define_symbol($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); }
|
2019-05-17 20:18:49 +00:00
|
|
|
| CF_SYM_KNOWN {
|
|
|
|
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-04-27 16:20:49 +00:00
|
|
|
symbol: CF_SYM_UNDEFINED | CF_SYM_KNOWN | kw_sym { $$ = cf_symbol_from_keyword($1); } ;
|
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
|
|
|
|
2015-12-24 14:52:03 +00:00
|
|
|
net_ip6_: IP6 '/' NUM
|
|
|
|
{
|
2017-05-23 15:22:53 +00:00
|
|
|
if ($3 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid prefix length %u", $3);
|
2016-06-30 13:04:49 +00:00
|
|
|
|
|
|
|
net_fill_ip6(&($$), $1, $3);
|
|
|
|
|
|
|
|
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
|
|
|
|
2018-02-13 15:27:57 +00:00
|
|
|
net_ip6_sadr_: IP6 '/' NUM FROM IP6 '/' NUM
|
|
|
|
{
|
|
|
|
if ($3 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid prefix length %u", $3);
|
|
|
|
|
|
|
|
if ($7 > IP6_MAX_PREFIX_LENGTH)
|
|
|
|
cf_error("Invalid prefix length %u", $7);
|
|
|
|
|
|
|
|
$$ = cfg_alloc(sizeof(net_addr_ip6_sadr));
|
|
|
|
net_fill_ip6_sadr($$, $1, $3, $5, $7);
|
|
|
|
|
|
|
|
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
|
|
|
|
{
|
|
|
|
$$ = cfg_alloc(sizeof(net_addr_roa6));
|
|
|
|
net_fill_mpls($$, $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_
|
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
|
|
|
|
{
|
2017-03-17 14:48:09 +00:00
|
|
|
$$ = cfg_allocz(sizeof(mpls_label_stack));
|
|
|
|
$$->len = 1;
|
|
|
|
$$->stack[0] = $1;
|
2016-06-13 13:49:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
label_stack:
|
|
|
|
label_stack_start
|
|
|
|
| label_stack '/' NUM {
|
2017-03-17 14:48:09 +00:00
|
|
|
if ($1->len >= MPLS_MAX_LABEL_STACK)
|
2017-02-20 01:26:45 +00:00
|
|
|
cf_error("Too many labels in stack");
|
2017-03-17 14:48:09 +00:00
|
|
|
$1->stack[$1->len++] = $3;
|
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
|
|
|
;
|
|
|
|
|
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 ')' {
|
|
|
|
$$ = cf_eval($2, T_VOID);
|
|
|
|
if (($$.type != T_BYTESTRING) && ($$.type != T_STRING))
|
|
|
|
cf_error("Bytestring or string value expected");
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2023-08-24 14:59:23 +00:00
|
|
|
bytestring:
|
|
|
|
BYTETEXT
|
|
|
|
| bytestring_expr { $$ = cf_eval($1, T_BYTESTRING).val.bs; }
|
|
|
|
;
|
|
|
|
|
|
|
|
bytestring_text:
|
|
|
|
BYTETEXT { $$.type = T_BYTESTRING; $$.val.bs = $1; }
|
|
|
|
| TEXT { $$.type = T_STRING; $$.val.s = $1; }
|
|
|
|
| bytestring_expr {
|
|
|
|
$$ = cf_eval($1, T_VOID);
|
|
|
|
if (($$.type != T_BYTESTRING) && ($$.type != T_STRING))
|
|
|
|
cf_error("Bytestring or string value expected");
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
|
|
|
bytestring_expr:
|
|
|
|
symbol_value
|
|
|
|
| term_bs
|
|
|
|
| '(' term ')' { $$ = $2; }
|
|
|
|
;
|
|
|
|
|
2015-11-05 11:48:52 +00:00
|
|
|
|
1998-11-27 19:36:06 +00:00
|
|
|
CF_CODE
|
|
|
|
|
|
|
|
CF_END
|