bird/conf/cf-lex.l

703 lines
16 KiB
Text
Raw Normal View History

1998-11-28 03:35:50 +08:00
/*
* BIRD -- Configuration Lexer
*
* (c) 1998--2000 Martin Mares <mj@ucw.cz>
1998-11-28 03:35:50 +08:00
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
2000-06-04 02:23:00 +08:00
/**
2000-06-07 20:29:08 +08:00
* DOC: Lexical analyzer
2000-06-04 02:23:00 +08:00
*
2000-06-07 20:29:08 +08:00
* The lexical analyzer used for configuration files and CLI commands
2000-06-07 21:25:53 +08:00
* is generated using the |flex| tool accompanied by a couple of
2000-06-04 02:23:00 +08:00
* functions maintaining the hash tables containing information about
* symbols and keywords.
*
* Each symbol is represented by a &symbol structure containing name
* of the symbol, its lexical scope, symbol class (%SYM_PROTO for a
* name of a protocol, %SYM_CONSTANT for a constant etc.) and class
* dependent data. When an unknown symbol is encountered, it's
* automatically added to the symbol table with class %SYM_VOID.
2000-06-04 02:23:00 +08:00
*
* The keyword tables are generated from the grammar templates
* using the |gen_keywords.m4| script.
*/
1998-11-28 03:35:50 +08:00
%{
#undef REJECT /* Avoid name clashes */
1998-11-28 03:35:50 +08:00
#include <errno.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdint.h>
2011-11-10 16:22:20 +08:00
#include <unistd.h>
#include <libgen.h>
#include <glob.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/stat.h>
1998-11-28 03:35:50 +08:00
#define PARSER 1
1998-11-28 03:35:50 +08:00
#include "nest/bird.h"
1999-11-15 19:35:41 +08:00
#include "nest/route.h"
#include "nest/protocol.h"
1999-11-15 19:35:41 +08:00
#include "filter/filter.h"
1998-11-28 03:35:50 +08:00
#include "conf/conf.h"
#include "conf/cf-parse.tab.h"
#include "lib/string.h"
#include "lib/hash.h"
1998-11-28 03:35:50 +08:00
struct keyword {
1998-11-28 03:35:50 +08:00
byte *name;
int value;
struct keyword *next;
};
#include "conf/keywords.h"
1998-11-28 03:35:50 +08:00
2017-05-30 20:43:49 +08:00
/* Could be defined by Bison in cf-parse.tab.h, inteferes with SYM hash */
#ifdef SYM
#undef SYM
#endif
static uint cf_hash(byte *c);
1998-11-28 03:35:50 +08:00
#define KW_KEY(n) n->name
#define KW_NEXT(n) n->next
#define KW_EQ(a,b) !strcmp(a,b)
#define KW_FN(k) cf_hash(k)
#define KW_ORDER 8 /* Fixed */
#define SYM_KEY(n) n->name, n->scope->active
#define SYM_NEXT(n) n->next
#define SYM_EQ(a,s1,b,s2) !strcmp(a,b) && s1 == s2
#define SYM_FN(k,s) cf_hash(k)
#define SYM_ORDER 6 /* Initial */
#define SYM_REHASH sym_rehash
#define SYM_PARAMS /8, *1, 2, 2, 6, 20
HASH_DEFINE_REHASH_FN(SYM, struct symbol)
HASH(struct keyword) kw_hash;
1999-11-04 21:51:52 +08:00
static struct sym_scope *conf_this_scope;
1998-11-28 03:35:50 +08:00
linpool *cfg_mem;
1998-11-28 03:35:50 +08:00
2011-09-12 03:21:47 +08:00
int (*cf_read_hook)(byte *buf, unsigned int max, int fd);
2011-10-10 07:01:58 +08:00
struct include_file_stack *ifs;
static struct include_file_stack *ifs_head;
#define MAX_INCLUDE_DEPTH 8
1998-11-28 03:35:50 +08:00
#define YY_INPUT(buf,result,max) result = cf_read_hook(buf, max, ifs->fd);
1998-11-28 03:35:50 +08:00
#define YY_NO_UNPUT
#define YY_FATAL_ERROR(msg) cf_error(msg)
static void cf_include(char *arg, int alen);
2011-09-12 03:21:47 +08:00
static int check_eof(void);
1998-11-28 03:35:50 +08:00
%}
%option noyywrap
%option noinput
%option nounput
%option noreject
1998-11-28 03:35:50 +08:00
%x COMMENT CCOMM CLI
1998-11-28 03:35:50 +08:00
ALPHA [a-zA-Z_]
DIGIT [0-9]
XIGIT [0-9a-fA-F]
ALNUM [a-zA-Z_0-9]
WHITE [ \t]
2011-09-12 03:21:47 +08:00
include ^{WHITE}*include{WHITE}*\".*\"{WHITE}*;
1998-11-28 03:35:50 +08:00
%%
{include} {
char *start, *end;
if (!ifs->depth)
cf_error("Include not allowed in CLI");
start = strchr(yytext, '"');
start++;
end = strchr(start, '"');
*end = 0;
if (start == end)
cf_error("Include with empty argument");
cf_include(start, end-start);
}
1998-11-28 03:35:50 +08:00
{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+ {
2014-10-24 17:11:43 +08:00
ip4_addr a;
if (!ip4_pton(yytext, &a))
cf_error("Invalid IPv4 address %s", yytext);
#ifdef IPV6
2014-10-24 17:11:43 +08:00
cf_lval.i32 = ip4_to_u32(a);
return RTRID;
#else
2014-10-24 17:11:43 +08:00
cf_lval.a = ipa_from_ip4(a);
return IPA;
#endif
}
({XIGIT}*::|({XIGIT}*:){3,})({XIGIT}*|{DIGIT}+\.{DIGIT}+\.{DIGIT}+\.{DIGIT}+) {
#ifdef IPV6
2014-10-24 17:11:43 +08:00
if (ipa_pton(yytext, &cf_lval.a))
return IPA;
2014-10-24 17:11:43 +08:00
cf_error("Invalid IPv6 address %s", yytext);
#else
cf_error("This is an IPv4 router, therefore IPv6 addresses are not supported");
#endif
1998-11-28 03:35:50 +08:00
}
0x{XIGIT}+ {
1998-11-28 03:35:50 +08:00
char *e;
unsigned long int l;
1998-11-28 03:35:50 +08:00
errno = 0;
l = strtoul(yytext+2, &e, 16);
if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
1998-11-28 03:35:50 +08:00
cf_error("Number out of range");
cf_lval.i = l;
return NUM;
}
{DIGIT}+ {
char *e;
unsigned long int l;
1998-11-28 03:35:50 +08:00
errno = 0;
l = strtoul(yytext, &e, 10);
if (e && *e || errno == ERANGE || (unsigned long int)(unsigned int) l != l)
1998-11-28 03:35:50 +08:00
cf_error("Number out of range");
cf_lval.i = l;
return NUM;
}
else: {
/* Hack to distinguish if..else from else: in case */
return ELSECOL;
}
({ALPHA}{ALNUM}*|[']({ALNUM}|[-]|[\.]|[:])*[']) {
2010-02-10 19:30:14 +08:00
if(*yytext == '\'') {
yytext[yyleng-1] = 0;
yytext++;
}
struct keyword *k = HASH_FIND(kw_hash, KW, yytext);
if (k)
{
if (k->value > 0)
return k->value;
else
1998-11-28 03:35:50 +08:00
{
cf_lval.i = -k->value;
return ENUM;
1998-11-28 03:35:50 +08:00
}
}
cf_lval.s = cf_get_symbol(yytext);
1998-11-28 03:35:50 +08:00
return SYM;
}
<CLI>(.|\n) {
BEGIN(INITIAL);
return CLI_MARKER;
}
\.\. {
return DDOT;
}
2009-01-28 00:35:00 +08:00
[={}:;,.()+*/%<>~\[\]?!\|-] {
1998-11-28 03:35:50 +08:00
return yytext[0];
}
["][^"\n]*["] {
yytext[yyleng-1] = 0;
cf_lval.t = cfg_strdup(yytext+1);
1998-11-28 03:35:50 +08:00
return TEXT;
}
["][^"\n]*\n cf_error("Unterminated string");
<INITIAL,COMMENT><<EOF>> { if (check_eof()) return END; }
1998-11-28 03:35:50 +08:00
{WHITE}+
\n ifs->lino++;
1998-11-28 03:35:50 +08:00
# BEGIN(COMMENT);
1998-11-28 03:35:50 +08:00
\/\* BEGIN(CCOMM);
1998-11-28 03:35:50 +08:00
. cf_error("Unknown character");
<COMMENT>\n {
ifs->lino++;
1998-11-28 03:35:50 +08:00
BEGIN(INITIAL);
}
<COMMENT>.
<CCOMM>\*\/ BEGIN(INITIAL);
<CCOMM>\n ifs->lino++;
1998-11-28 03:35:50 +08:00
<CCOMM>\/\* cf_error("Comment nesting not supported");
<CCOMM><<EOF>> cf_error("Unterminated comment");
<CCOMM>.
2000-03-11 04:21:12 +08:00
\!\= return NEQ;
2016-09-20 21:13:01 +08:00
\!\~ return NMA;
2000-03-11 04:21:12 +08:00
\<\= return LEQ;
\>\= return GEQ;
2000-06-01 16:43:29 +08:00
\&\& return AND;
\|\| return OR;
2000-03-11 04:21:12 +08:00
2009-03-14 19:43:10 +08:00
\[\= return PO;
\=\] return PC;
1998-11-28 03:35:50 +08:00
%%
static uint
1998-11-28 03:35:50 +08:00
cf_hash(byte *c)
{
uint h = 13 << 24;
1998-11-28 03:35:50 +08:00
while (*c)
h = h + (h >> 2) + (h >> 5) + ((uint) *c++ << 24);
1998-11-28 03:35:50 +08:00
return h;
}
/*
* IFS stack - it contains structures needed for recursive processing
* of include in config files. On the top of the stack is a structure
* for currently processed file. Other structures are either for
* active files interrupted because of include directive (these have
* fd and flex buffer) or for inactive files scheduled to be processed
* later (when parent requested including of several files by wildcard
* match - these do not have fd and flex buffer yet).
*
* FIXME: Most of these ifs and include functions are really sysdep/unix.
*/
static struct include_file_stack *
push_ifs(struct include_file_stack *old)
{
struct include_file_stack *ret;
ret = cfg_allocz(sizeof(struct include_file_stack));
ret->lino = 1;
ret->prev = old;
return ret;
}
static struct include_file_stack *
pop_ifs(struct include_file_stack *old)
{
yy_delete_buffer(old->buffer);
close(old->fd);
return old->prev;
}
2011-09-12 03:21:47 +08:00
static void
enter_ifs(struct include_file_stack *new)
2011-09-12 03:21:47 +08:00
{
if (!new->buffer)
{
new->fd = open(new->file_name, O_RDONLY);
if (new->fd < 0)
{
ifs = ifs->up;
cf_error("Unable to open included file %s: %m", new->file_name);
}
new->buffer = yy_create_buffer(NULL, YY_BUF_SIZE);
}
2011-09-12 03:21:47 +08:00
yy_switch_to_buffer(new->buffer);
}
2011-09-12 03:21:47 +08:00
/**
* cf_lex_unwind - unwind lexer state during error
*
* cf_lex_unwind() frees the internal state on IFS stack when the lexical
* analyzer is terminated by cf_error().
*/
void
cf_lex_unwind(void)
{
struct include_file_stack *n;
for (n = ifs; n != ifs_head; n = n->prev)
{
/* Memory is freed automatically */
if (n->buffer)
yy_delete_buffer(n->buffer);
if (n->fd)
close(n->fd);
}
ifs = ifs_head;
}
static void
cf_include(char *arg, int alen)
{
struct include_file_stack *base_ifs = ifs;
int new_depth, rv, i;
char *patt;
glob_t g = {};
new_depth = ifs->depth + 1;
if (new_depth > MAX_INCLUDE_DEPTH)
cf_error("Max include depth reached");
2011-09-12 03:21:47 +08:00
/* expand arg to properly handle relative filenames */
if (*arg != '/')
{
int dlen = strlen(ifs->file_name);
char *dir = alloca(dlen + 1);
patt = alloca(dlen + alen + 2);
memcpy(dir, ifs->file_name, dlen + 1);
sprintf(patt, "%s/%s", dirname(dir), arg);
}
else
patt = arg;
2011-09-12 03:21:47 +08:00
/* Skip globbing if there are no wildcards, mainly to get proper
response when the included config file is missing */
if (!strpbrk(arg, "?*["))
{
ifs = push_ifs(ifs);
ifs->file_name = cfg_strdup(patt);
ifs->depth = new_depth;
ifs->up = base_ifs;
enter_ifs(ifs);
return;
}
2011-09-12 03:21:47 +08:00
/* Expand the pattern */
rv = glob(patt, GLOB_ERR | GLOB_NOESCAPE, NULL, &g);
if (rv == GLOB_ABORTED)
cf_error("Unable to match pattern %s: %m", patt);
if ((rv != 0) || (g.gl_pathc <= 0))
return;
/*
* Now we put all found files to ifs stack in reverse order, they
* will be activated and processed in order as ifs stack is popped
* by pop_ifs() and enter_ifs() in check_eof().
*/
for(i = g.gl_pathc - 1; i >= 0; i--)
{
char *fname = g.gl_pathv[i];
struct stat fs;
if (stat(fname, &fs) < 0)
{
globfree(&g);
cf_error("Unable to stat included file %s: %m", fname);
}
if (fs.st_mode & S_IFDIR)
continue;
/* Prepare new stack item */
ifs = push_ifs(ifs);
ifs->file_name = cfg_strdup(fname);
ifs->depth = new_depth;
ifs->up = base_ifs;
}
globfree(&g);
enter_ifs(ifs);
2011-09-12 03:21:47 +08:00
}
static int
check_eof(void)
{
if (ifs == ifs_head)
{
/* EOF in main config file */
ifs->lino = 1; /* Why this? */
return 1;
}
2011-09-12 03:21:47 +08:00
ifs = pop_ifs(ifs);
enter_ifs(ifs);
return 0;
2011-09-12 03:21:47 +08:00
}
static struct symbol *
cf_new_symbol(byte *c)
{
struct symbol *s;
uint l = strlen(c);
if (l > SYM_MAX_LEN)
cf_error("Symbol too long");
s = cfg_alloc(sizeof(struct symbol) + l);
s->scope = conf_this_scope;
s->class = SYM_VOID;
s->def = NULL;
s->aux = 0;
strcpy(s->name, c);
if (!new_config->sym_hash.data)
HASH_INIT(new_config->sym_hash, new_config->pool, SYM_ORDER);
1998-11-28 03:35:50 +08:00
HASH_INSERT2(new_config->sym_hash, SYM, new_config->pool, s);
return s;
1998-11-28 03:35:50 +08:00
}
2000-06-04 02:23:00 +08:00
/**
* cf_find_symbol - find a symbol by name
* @cfg: specificed config
* @c: symbol name
*
* This functions searches the symbol table in the config @cfg for a symbol of
* given name. First it examines the current scope, then the second recent one
* and so on until it either finds the symbol and returns a pointer to its
* &symbol structure or reaches the end of the scope chain and returns %NULL to
* signify no match.
*/
struct symbol *
cf_find_symbol(struct config *cfg, byte *c)
{
struct symbol *s;
if (cfg->sym_hash.data &&
(s = HASH_FIND(cfg->sym_hash, SYM, c, 1)))
return s;
if (cfg->fallback &&
cfg->fallback->sym_hash.data &&
(s = HASH_FIND(cfg->fallback->sym_hash, SYM, c, 1)))
return s;
return NULL;
}
/**
* cf_get_symbol - get a symbol by name
2000-06-04 02:23:00 +08:00
* @c: symbol name
*
* This functions searches the symbol table of the currently parsed config
* (@new_config) for a symbol of given name. It returns either the already
* existing symbol or a newly allocated undefined (%SYM_VOID) symbol if no
* existing symbol is found.
2000-06-04 02:23:00 +08:00
*/
struct symbol *
cf_get_symbol(byte *c)
{
return cf_find_symbol(new_config, c) ?: cf_new_symbol(c);
}
1998-11-28 05:07:02 +08:00
struct symbol *
cf_default_name(char *template, int *counter)
1998-11-28 05:07:02 +08:00
{
char buf[SYM_MAX_LEN];
1998-11-28 05:07:02 +08:00
struct symbol *s;
char *perc = strchr(template, '%');
1998-11-28 05:07:02 +08:00
for(;;)
1998-11-28 05:07:02 +08:00
{
bsprintf(buf, template, ++(*counter));
s = cf_get_symbol(buf);
if (s->class == SYM_VOID)
return s;
if (!perc)
break;
1998-11-28 05:07:02 +08:00
}
cf_error("Unable to generate default name");
1998-11-28 05:07:02 +08:00
}
2000-06-04 02:23:00 +08:00
/**
* cf_define_symbol - define meaning of a symbol
* @sym: symbol to be defined
* @type: symbol class to assign
* @def: class dependent data
*
* Defines new meaning of a symbol. If the symbol is an undefined
* one (%SYM_VOID), it's just re-defined to the new type. If it's defined
* in different scope, a new symbol in current scope is created and the
* meaning is assigned to it. If it's already defined in the current scope,
* an error is reported via cf_error().
*
* Result: Pointer to the newly defined symbol. If we are in the top-level
* scope, it's the same @sym as passed to the function.
2000-06-04 02:23:00 +08:00
*/
struct symbol *
cf_define_symbol(struct symbol *sym, int type, void *def)
{
if (sym->class)
{
if (sym->scope == conf_this_scope)
cf_error("Symbol already defined");
sym = cf_new_symbol(sym->name);
}
sym->class = type;
sym->def = def;
return sym;
}
static void
cf_lex_init_kh(void)
{
HASH_INIT(kw_hash, &root_pool, KW_ORDER);
struct keyword *k;
for (k=keyword_list; k->name; k++)
HASH_INSERT(kw_hash, KW, k);
}
2000-06-04 02:23:00 +08:00
/**
* cf_lex_init - initialize the lexer
* @is_cli: true if we're going to parse CLI command, false for configuration
* @c: configuration structure
2000-06-04 02:23:00 +08:00
*
2000-06-07 20:29:08 +08:00
* cf_lex_init() initializes the lexical analyzer and prepares it for
2000-06-04 02:23:00 +08:00
* parsing of a new input.
*/
1998-11-28 03:35:50 +08:00
void
2011-09-12 03:21:47 +08:00
cf_lex_init(int is_cli, struct config *c)
1998-11-28 03:35:50 +08:00
{
if (!kw_hash.data)
cf_lex_init_kh();
ifs_head = ifs = push_ifs(NULL);
2016-11-09 00:46:29 +08:00
if (!is_cli)
{
ifs->file_name = c->file_name;
ifs->fd = c->file_fd;
ifs->depth = 1;
}
yyrestart(NULL);
ifs->buffer = YY_CURRENT_BUFFER;
if (is_cli)
BEGIN(CLI);
else
BEGIN(INITIAL);
1999-11-04 21:51:52 +08:00
conf_this_scope = cfg_allocz(sizeof(struct sym_scope));
conf_this_scope->active = 1;
1998-11-28 03:35:50 +08:00
}
2000-06-04 02:23:00 +08:00
/**
* cf_push_scope - enter new scope
* @sym: symbol representing scope name
*
* If we want to enter a new scope to process declarations inside
* a nested block, we can just call cf_push_scope() to push a new
* scope onto the scope stack which will cause all new symbols to be
* defined in this scope and all existing symbols to be sought for
* in all scopes stored on the stack.
*/
1999-11-04 21:51:52 +08:00
void
cf_push_scope(struct symbol *sym)
{
struct sym_scope *s = cfg_alloc(sizeof(struct sym_scope));
s->next = conf_this_scope;
conf_this_scope = s;
s->active = 1;
s->name = sym;
}
2000-06-04 02:23:00 +08:00
/**
* cf_pop_scope - leave a scope
*
* cf_pop_scope() pops the topmost scope from the scope stack,
* leaving all its symbols in the symbol table, but making them
* invisible to the rest of the config.
*/
1999-11-04 21:51:52 +08:00
void
cf_pop_scope(void)
{
conf_this_scope->active = 0;
conf_this_scope = conf_this_scope->next;
ASSERT(conf_this_scope);
}
2000-06-04 02:23:00 +08:00
/**
* cf_symbol_class_name - get name of a symbol class
* @sym: symbol
*
* This function returns a string representing the class
* of the given symbol.
*/
char *
cf_symbol_class_name(struct symbol *sym)
{
if (cf_symbol_is_constant(sym))
return "constant";
switch (sym->class)
{
case SYM_VOID:
return "undefined";
case SYM_PROTO:
return "protocol";
case SYM_TEMPLATE:
return "protocol template";
case SYM_FUNCTION:
return "function";
case SYM_FILTER:
return "filter";
case SYM_TABLE:
return "routing table";
case SYM_ROA:
return "ROA table";
default:
return "unknown type";
}
}
/**
* DOC: Parser
*
2000-06-07 20:29:08 +08:00
* Both the configuration and CLI commands are analyzed using a syntax
* driven parser generated by the |bison| tool from a grammar which
* is constructed from information gathered from grammar snippets by
* the |gen_parser.m4| script.
*
* Grammar snippets are files (usually with extension |.Y|) contributed
2000-06-07 21:25:53 +08:00
* by various BIRD modules in order to provide information about syntax of their
* configuration and their CLI commands. Each snipped consists of several
2000-06-08 20:37:21 +08:00
* sections, each of them starting with a special keyword: |CF_HDR| for
* a list of |#include| directives needed by the C code, |CF_DEFINES|
* for a list of C declarations, |CF_DECLS| for |bison| declarations
* including keyword definitions specified as |CF_KEYWORDS|, |CF_GRAMMAR|
2000-06-07 20:29:08 +08:00
* for the grammar rules, |CF_CODE| for auxiliary C code and finally
* |CF_END| at the end of the snippet.
*
* To create references between the snippets, it's possible to define
* multi-part rules by utilizing the |CF_ADDTO| macro which adds a new
* alternative to a multi-part rule.
*
* CLI commands are defined using a |CF_CLI| macro. Its parameters are:
2000-06-07 20:29:08 +08:00
* the list of keywords determining the command, the list of parameters,
* help text for the parameters and help text for the command.
*
* Values of |enum| filter types can be defined using |CF_ENUM| with
* the following parameters: name of filter type, prefix common for all
2000-06-08 20:37:21 +08:00
* literals of this type and names of all the possible values.
*/