/*********************************************************************
*
* Parse Bootstrap file
*
*/
BSR *parse_bsr(JCR *jcr, char *fname)
{
LEX *lc = NULL;
int token, i;
BSR *root_bsr = new_bsr();
BSR *bsr = root_bsr;
Dmsg1(300, "Enter parse_bsf %s\n", fname);
if ((lc = lex_open_file(lc, fname, s_err)) == NULL) {
berrno be;
Emsg2(M_ERROR_TERM, 0, _("Cannot open bootstrap file %s: %s\n"),
fname, be.bstrerror());
}
lc->caller_ctx = (void *)jcr;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg1(300, "parse got token=%s\n", lex_tok_to_str(token));
if (token == T_EOL) {
continue;
}
for (i=0; items[i].name; i++) {
if (strcasecmp(items[i].name, lc->str) == 0) {
token = lex_get_token(lc, T_ALL);
Dmsg1 (300, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
if (token != T_EQUALS) {
scan_err1(lc, "expected an equals, got: %s", lc->str);
bsr = NULL;
break;
}
Dmsg1(300, "calling handler for %s\n", items[i].name);
/* Call item handler */
bsr = items[i].handler(lc, bsr);
i = -1;
break;
}
}
if (i >= 0) {
Dmsg1(300, "Keyword = %s\n", lc->str);
scan_err1(lc, "Keyword %s not found", lc->str);
bsr = NULL;
break;
}
if (!bsr) {
break;
}
}
lc = lex_close_file(lc);
Dmsg0(300, "Leave parse_bsf()\n");
if (!bsr) {
free_bsr(root_bsr);
root_bsr = NULL;
}
if (root_bsr) {
root_bsr->use_fast_rejection = is_fast_rejection_ok(root_bsr);
root_bsr->use_positioning = is_positioning_ok(root_bsr);
}
for (bsr=root_bsr; bsr; bsr=bsr->next) {
bsr->root = root_bsr;
}
return root_bsr;
}
/*
* Get the next character from the input.
* Returns the character or
* L_EOF if end of file
* L_EOL if end of line
*/
int lex_get_char(LEX *lf)
{
if (lf->ch == L_EOF) {
Emsg0(M_ABORT, 0, _("get_char: called after EOF."
" You may have a open double quote without the closing double quote.\n"));
}
if (lf->ch == L_EOL) {
/*
* See if we are really reading a file otherwise we have reached EndOfFile.
*/
if (!lf->fd || bfgets(lf->line, lf->fd) == NULL) {
lf->ch = L_EOF;
if (lf->next) {
if (lf->fd) {
lex_close_file(lf);
}
}
return lf->ch;
}
lf->line_no++;
lf->col_no = 0;
Dmsg2(1000, "fget line=%d %s", lf->line_no, lf->line);
}
lf->ch = (uint8_t)lf->line[lf->col_no];
if (lf->ch == 0) {
lf->ch = L_EOL;
} else {
lf->col_no++;
}
Dmsg2(dbglvl, "lex_get_char: %c %d\n", lf->ch, lf->ch);
return lf->ch;
}
/* Parse a config file used by Plugin/Director */
bool ConfigFile::parse(const char *fname)
{
int token, i;
bool ret=false;
if (!items) {
return false;
}
if ((lc = lex_open_file(lc, fname, s_err, s_warn)) == NULL) {
berrno be;
Emsg2(M_ERROR, 0, _("Cannot open config file %s: %s\n"),
fname, be.bstrerror());
return false;
}
lc->options |= LOPT_NO_EXTERN;
lc->caller_ctx = (void *)this;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg1(dbglevel, "parse got token=%s\n", lex_tok_to_str(token));
if (token == T_EOL) {
continue;
}
for (i = 0; items[i].name; i++) {
if (strcasecmp(items[i].name, lc->str) == 0) {
if ((token = lex_get_token(lc, T_EQUALS)) == T_ERROR) {
Dmsg1(dbglevel, "in T_IDENT got token=%s\n",
lex_tok_to_str(token));
break;
}
Dmsg1(dbglevel, "calling handler for %s\n", items[i].name);
/* Call item handler */
ret = items[i].found = items[i].handler(lc, this, &items[i]);
i = -1;
break;
}
}
if (i >= 0) {
Dmsg1(dbglevel, "Keyword = %s\n", lc->str);
scan_err1(lc, "Keyword %s not found", lc->str);
/* We can raise an error here */
break;
}
if (!ret) {
break;
}
}
for (i = 0; items[i].name; i++) {
if (items[i].required && !items[i].found) {
scan_err1(lc, "%s required but not found", items[i].name);
ret = false;
}
}
lc = lex_close_file(lc);
return ret;
}
bool CONFIG::parse_config()
{
LEX *lc = NULL;
int token, i, pass;
int res_type = 0;
enum parse_state state = p_none;
RES_ITEM *items = NULL;
int level = 0;
static bool first = true;
int errstat;
const char *cf = m_cf;
LEX_ERROR_HANDLER *scan_error = m_scan_error;
int err_type = m_err_type;
if (first && (errstat=rwl_init(&res_lock)) != 0) {
berrno be;
Jmsg1(NULL, M_ABORT, 0, _("Unable to initialize resource lock. ERR=%s\n"),
be.bstrerror(errstat));
}
first = false;
char *full_path = (char *)alloca(MAX_PATH + 1);
if (!find_config_file(cf, full_path, MAX_PATH +1)) {
Jmsg0(NULL, M_ABORT, 0, _("Config filename too long.\n"));
}
cf = full_path;
/* Make two passes. The first builds the name symbol table,
* and the second picks up the items.
*/
Dmsg0(900, "Enter parse_config()\n");
for (pass=1; pass <= 2; pass++) {
Dmsg1(900, "parse_config pass %d\n", pass);
if ((lc = lex_open_file(lc, cf, scan_error)) == NULL) {
berrno be;
/* We must create a lex packet to print the error */
lc = (LEX *)malloc(sizeof(LEX));
memset(lc, 0, sizeof(LEX));
if (scan_error) {
lc->scan_error = scan_error;
} else {
lex_set_default_error_handler(lc);
}
lex_set_error_handler_error_type(lc, err_type) ;
bstrncpy(lc->str, cf, sizeof(lc->str));
lc->fname = lc->str;
scan_err2(lc, _("Cannot open config file \"%s\": %s\n"),
lc->str, be.bstrerror());
free(lc);
return 0;
}
lex_set_error_handler_error_type(lc, err_type) ;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg3(900, "parse state=%d pass=%d got token=%s\n", state, pass,
lex_tok_to_str(token));
switch (state) {
case p_none:
if (token == T_EOL) {
break;
} else if (token == T_UTF8_BOM) {
/* We can assume the file is UTF-8 as we have seen a UTF-8 BOM */
break;
} else if (token == T_UTF16_BOM) {
scan_err0(lc, _("Currently we cannot handle UTF-16 source files. "
"Please convert the conf file to UTF-8\n"));
return 0;
} else if (token != T_IDENTIFIER) {
scan_err1(lc, _("Expected a Resource name identifier, got: %s"), lc->str);
return 0;
}
for (i=0; resources[i].name; i++) {
if (strcasecmp(resources[i].name, lc->str) == 0) {
items = resources[i].items;
if (!items) {
break;
}
state = p_resource;
res_type = resources[i].rcode;
init_resource(this, res_type, items, pass);
break;
}
}
if (state == p_none) {
scan_err1(lc, _("expected resource name, got: %s"), lc->str);
return 0;
}
break;
case p_resource:
switch (token) {
case T_BOB:
level++;
break;
case T_IDENTIFIER:
if (level != 1) {
scan_err1(lc, _("not in resource definition: %s"), lc->str);
return 0;
}
for (i=0; items[i].name; i++) {
if (strcasecmp(items[i].name, lc->str) == 0) {
/* If the ITEM_NO_EQUALS flag is set we do NOT
* scan for = after the keyword */
if (!(items[i].flags & ITEM_NO_EQUALS)) {
token = lex_get_token(lc, T_SKIP_EOL);
Dmsg1 (900, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
if (token != T_EQUALS) {
scan_err1(lc, _("expected an equals, got: %s"), lc->str);
return 0;
}
}
Dmsg1(800, "calling handler for %s\n", items[i].name);
/* Call item handler */
items[i].handler(lc, &items[i], i, pass);
i = -1;
break;
}
}
if (i >= 0) {
Dmsg2(900, "level=%d id=%s\n", level, lc->str);
Dmsg1(900, "Keyword = %s\n", lc->str);
scan_err1(lc, _("Keyword \"%s\" not permitted in this resource.\n"
"Perhaps you left the trailing brace off of the previous resource."), lc->str);
return 0;
}
break;
case T_EOB:
level--;
state = p_none;
Dmsg0(900, "T_EOB => define new resource\n");
if (res_all.hdr.name == NULL) {
scan_err0(lc, _("Name not specified for resource"));
return 0;
}
save_resource(res_type, items, pass); /* save resource */
break;
case T_EOL:
break;
default:
scan_err2(lc, _("unexpected token %d %s in resource definition"),
token, lex_tok_to_str(token));
return 0;
}
break;
default:
scan_err1(lc, _("Unknown parser state %d\n"), state);
return 0;
}
}
if (state != p_none) {
scan_err0(lc, _("End of conf file reached with unclosed resource."));
return 0;
}
if (debug_level >= 900 && pass == 2) {
int i;
for (i=m_r_first; i<=m_r_last; i++) {
dump_resource(i, m_res_head[i-m_r_first], prtmsg, NULL);
}
}
lc = lex_close_file(lc);
}
Dmsg0(900, "Leave parse_config()\n");
return 1;
}
/*
* Analyse the content of a ini file to build the item list
* It uses special syntax for datatype. Used by Director on Restore object
*
* OptPrompt = "Variable1"
* OptRequired
* OptDefault = 100
* Variable1 = @PINT32@
* ...
*/
bool ConfigFile::unserialize(const char *fname)
{
int token, i, nb = 0;
bool ret = false;
const char **assign;
/*
* At this time, we allow only 32 different items
*/
int s = MAX_INI_ITEMS * sizeof (struct ini_items);
items = (struct ini_items *) malloc (s);
memset(items, 0, s);
items_allocated = true;
/*
* Parse the file and generate the items structure on the fly
*/
if ((lc = lex_open_file(lc, fname, s_err, s_warn)) == NULL) {
berrno be;
Emsg2(M_ERROR, 0, _("Cannot open config file %s: %s\n"),
fname, be.bstrerror());
return false;
}
lc->options |= LOPT_NO_EXTERN;
lc->caller_ctx = (void *)this;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg1(dbglevel, "parse got token=%s\n", lex_tok_to_str(token));
if (token == T_EOL) {
continue;
}
ret = false;
assign = NULL;
if (nb >= MAX_INI_ITEMS) {
break;
}
if (bstrcasecmp("optprompt", lc->str)) {
assign = &(items[nb].comment);
} else if (bstrcasecmp("optdefault", lc->str)) {
assign = &(items[nb].default_value);
} else if (bstrcasecmp("optrequired", lc->str)) {
items[nb].required = true; /* Don't use argument */
scan_to_eol(lc);
continue;
} else {
items[nb].name = bstrdup(lc->str);
}
token = lex_get_token(lc, T_ALL);
Dmsg1(dbglevel, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
if (token != T_EQUALS) {
scan_err1(lc, "expected an equals, got: %s", lc->str);
break;
}
/*
* We may allow blank variable
*/
if (lex_get_token(lc, T_STRING) == T_ERROR) {
break;
}
if (assign) {
*assign = bstrdup(lc->str);
} else {
if ((items[nb].type = ini_get_store_type(lc->str)) == 0) {
scan_err1(lc, "expected a data type, got: %s", lc->str);
break;
}
nb++;
}
scan_to_eol(lc);
ret = true;
}
if (!ret) {
for (i = 0; i < nb; i++) {
bfree_and_null_const(items[i].name);
bfree_and_null_const(items[i].comment);
bfree_and_null_const(items[i].default_value);
items[i].type = 0;
items[i].required = false;
}
}
lc = lex_close_file(lc);
return ret;
}
/*
* Parse a config file used by Plugin/Director
*/
bool ConfigFile::parse(const char *fname)
{
int token, i;
bool ret = false;
if (!items) {
return false;
}
if ((lc = lex_open_file(lc, fname, s_err, s_warn)) == NULL) {
berrno be;
Emsg2(M_ERROR, 0, _("Cannot open config file %s: %s\n"),
fname, be.bstrerror());
return false;
}
lc->options |= LOPT_NO_EXTERN;
lc->caller_ctx = (void *)this;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg1(dbglevel, "parse got token=%s\n", lex_tok_to_str(token));
if (token == T_EOL) {
continue;
}
for (i = 0; items[i].name; i++) {
if (bstrcasecmp(items[i].name, lc->str)) {
if ((token = lex_get_token(lc, T_EQUALS)) == T_ERROR) {
Dmsg1(dbglevel, "in T_IDENT got token=%s\n",
lex_tok_to_str(token));
break;
}
Dmsg1(dbglevel, "calling handler for %s\n", items[i].name);
/*
* Call item handler
*/
switch (items[i].type) {
case INI_CFG_TYPE_INT32:
ret = ini_store_int32(lc, this, &items[i]);
break;
case INI_CFG_TYPE_PINT32:
ret = ini_store_pint32(lc, this, &items[i]);
break;
case INI_CFG_TYPE_INT64:
ret = ini_store_int64(lc, this, &items[i]);
break;
case INI_CFG_TYPE_PINT64:
ret = ini_store_pint64(lc, this, &items[i]);
break;
case INI_CFG_TYPE_NAME:
ret = ini_store_name(lc, this, &items[i]);
break;
case INI_CFG_TYPE_STR:
ret = ini_store_str(lc, this, &items[i]);
break;
case INI_CFG_TYPE_BOOL:
ret = ini_store_bool(lc, this, &items[i]);
break;
case INI_CFG_TYPE_ALIST_STR:
ret = ini_store_alist_str(lc, this, &items[i]);
break;
default:
break;
}
i = -1;
break;
}
}
if (i >= 0) {
Dmsg1(dbglevel, "Keyword = %s\n", lc->str);
scan_err1(lc, "Keyword %s not found", lc->str);
/*
* We can raise an error here
*/
break;
}
if (!ret) {
break;
}
}
for (i = 0; items[i].name; i++) {
if (items[i].required && !items[i].found) {
scan_err1(lc, "%s required but not found", items[i].name);
ret = false;
}
}
lc = lex_close_file(lc);
return ret;
}
bool CONFIG::parse_config_file(const char *cf, void *caller_ctx, LEX_ERROR_HANDLER *scan_error,
LEX_WARNING_HANDLER *scan_warning, int32_t err_type)
{
bool result = true;
LEX *lc = NULL;
int token, i, pass;
int res_type = 0;
enum parse_state state = p_none;
RES_TABLE *res_table = NULL;
RES_ITEM *items = NULL;
RES_ITEM *item = NULL;
int level = 0;
/*
* Make two passes. The first builds the name symbol table,
* and the second picks up the items.
*/
Dmsg0(900, "Enter parse_config()\n");
for (pass = 1; pass <= 2; pass++) {
Dmsg1(900, "parse_config pass %d\n", pass);
if ((lc = lex_open_file(lc, cf, scan_error, scan_warning)) == NULL) {
berrno be;
/*
* We must create a lex packet to print the error
*/
lc = (LEX *)malloc(sizeof(LEX));
memset(lc, 0, sizeof(LEX));
if (scan_error) {
lc->scan_error = scan_error;
} else {
lex_set_default_error_handler(lc);
}
if (scan_warning) {
lc->scan_warning = scan_warning;
} else {
lex_set_default_warning_handler(lc);
}
lex_set_error_handler_error_type(lc, err_type) ;
scan_err2(lc, _("Cannot open config file \"%s\": %s\n"),
cf, be.bstrerror());
free(lc);
return 0;
}
lex_set_error_handler_error_type(lc, err_type);
lc->error_counter = 0;
lc->caller_ctx = caller_ctx;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
Dmsg3(900, "parse state=%d pass=%d got token=%s\n", state, pass,
lex_tok_to_str(token));
switch (state) {
case p_none:
if (token == T_EOL) {
break;
} else if (token == T_UTF8_BOM) {
/*
* We can assume the file is UTF-8 as we have seen a UTF-8 BOM
*/
break;
} else if (token == T_UTF16_BOM) {
scan_err0(lc, _("Currently we cannot handle UTF-16 source files. "
"Please convert the conf file to UTF-8\n"));
goto bail_out;
} else if (token != T_IDENTIFIER) {
scan_err1(lc, _("Expected a Resource name identifier, got: %s"), lc->str);
goto bail_out;
}
res_table = get_resource_table(lc->str);
if(res_table && res_table->items) {
items = res_table->items;
state = p_resource;
res_type = res_table->rcode;
init_resource(res_type, items, pass);
}
if (state == p_none) {
scan_err1(lc, _("expected resource name, got: %s"), lc->str);
goto bail_out;
}
break;
case p_resource:
switch (token) {
case T_BOB:
level++;
break;
case T_IDENTIFIER:
if (level != 1) {
scan_err1(lc, _("not in resource definition: %s"), lc->str);
goto bail_out;
}
i = get_resource_item_index(items, lc->str);
if (i>=0) {
item = &items[i];
/*
* If the CFG_ITEM_NO_EQUALS flag is set we do NOT
* scan for = after the keyword
*/
if (!(item->flags & CFG_ITEM_NO_EQUALS)) {
token = lex_get_token(lc, T_SKIP_EOL);
Dmsg1 (900, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
if (token != T_EQUALS) {
scan_err1(lc, _("expected an equals, got: %s"), lc->str);
goto bail_out;
}
}
/*
* See if we are processing a deprecated keyword if so warn the user about it.
*/
if (item->flags & CFG_ITEM_DEPRECATED) {
scan_warn2(lc, _("using deprecated keyword %s on line %d"), item->name, lc->line_no);
/*
* As we only want to warn we continue parsing the config. So no goto bail_out here.
*/
}
Dmsg1(800, "calling handler for %s\n", item->name);
/*
* Call item handler
*/
if (!store_resource(item->type, lc, item, i, pass)) {
/*
* None of the generic types fired if there is a registered callback call that now.
*/
if (m_store_res) {
m_store_res(lc, item, i, pass);
}
}
} else {
Dmsg2(900, "level=%d id=%s\n", level, lc->str);
Dmsg1(900, "Keyword = %s\n", lc->str);
scan_err1(lc, _("Keyword \"%s\" not permitted in this resource.\n"
"Perhaps you left the trailing brace off of the previous resource."), lc->str);
goto bail_out;
}
break;
case T_EOB:
level--;
state = p_none;
Dmsg0(900, "T_EOB => define new resource\n");
if (((URES *)m_res_all)->hdr.name == NULL) {
scan_err0(lc, _("Name not specified for resource"));
goto bail_out;
}
/* save resource */
if (!save_resource(res_type, items, pass)) {
scan_err0(lc, _("save_resource failed"));
goto bail_out;
};
break;
case T_EOL:
break;
default:
scan_err2(lc, _("unexpected token %d %s in resource definition"),
token, lex_tok_to_str(token));
goto bail_out;
}
break;
default:
scan_err1(lc, _("Unknown parser state %d\n"), state);
goto bail_out;
}
}
if (state != p_none) {
scan_err0(lc, _("End of conf file reached with unclosed resource."));
goto bail_out;
}
if (debug_level >= 900 && pass == 2) {
int i;
for (i = m_r_first; i <= m_r_last; i++) {
dump_resource(i, m_res_head[i-m_r_first], prtmsg, NULL, false);
}
}
if (lc->error_counter > 0) {
result = false;
}
lc = lex_close_file(lc);
}
Dmsg0(900, "Leave parse_config_file()\n");
return result;
bail_out:
if (lc) {
lc = lex_close_file(lc);
}
return false;
}
