/*
Bacula® - The Network Backup Solution
- Copyright (C) 2000-2007 Free Software Foundation Europe e.V.
+ Copyright (C) 2000-2011 Free Software Foundation Europe e.V.
The main author of Bacula is Kern Sibbald, with contributions from
many others, a complete list can be found in the file AUTHORS.
This program is Free Software; you can redistribute it and/or
- modify it under the terms of version two of the GNU General Public
+ modify it under the terms of version three of the GNU Affero General Public
License as published by the Free Software Foundation and included
in the file LICENSE.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU Affero General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Bacula® is a registered trademark of John Walker.
+ Bacula® is a registered trademark of Kern Sibbald.
The licensor of Bacula is the Free Software Foundation Europe
(FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
Switzerland, email:ftf@fsfeurope.org.
*
* Kern Sibbald, January MM
*
- * Version $Id$
*/
#define MAX_PATH 1024
#endif
-/* Each daemon has a slightly different set of
- * resources, so it will define the following
- * global values.
+/*
+ * Define the Union of all the common resource structure definitions.
*/
-extern int r_first;
-extern int r_last;
-extern RES_TABLE resources[];
-extern RES **res_head;
+union URES {
+ MSGS res_msgs;
+ RES hdr;
+};
#if defined(_MSC_VER)
// work around visual studio name mangling preventing external linkage since res_all
// is declared as a different type when instantiated.
-extern "C" CURES res_all;
+extern "C" URES res_all;
#else
-extern CURES res_all;
+extern URES res_all;
#endif
-extern int res_all_size;
extern brwlock_t res_lock; /* resource lock */
* Initialize the static structure to zeros, then
* apply all the default values.
*/
-void init_resource(int type, RES_ITEM *items, int pass)
+static void init_resource(CONFIG *config, int type, RES_ITEM *items, int pass)
{
int i;
int rindex = type - r_first;
- static bool first = true;
- int errstat;
- if (first && (errstat=rwl_init(&res_lock)) != 0) {
- berrno be;
- Emsg1(M_ABORT, 0, _("Unable to initialize resource lock. ERR=%s\n"),
- be.bstrerror(errstat));
- }
- first = false;
-
- memset(&res_all, 0, res_all_size);
+ memset(config->m_res_all, 0, config->m_res_all_size);
res_all.hdr.rcode = type;
res_all.hdr.refcnt = 1;
items[i].default_value);
if (items[i].flags & ITEM_DEFAULT && items[i].default_value != 0) {
if (items[i].handler == store_bit) {
- *(int *)(items[i].value) |= items[i].code;
+ *(uint32_t *)(items[i].value) |= items[i].code;
} else if (items[i].handler == store_bool) {
*(bool *)(items[i].value) = items[i].default_value != 0;
- } else if (items[i].handler == store_pint ||
- items[i].handler == store_int) {
- *(int *)(items[i].value) = items[i].default_value;
+ } else if (items[i].handler == store_pint32 ||
+ items[i].handler == store_int32 ||
+ items[i].handler == store_size32) {
+ *(uint32_t *)(items[i].value) = items[i].default_value;
} else if (items[i].handler == store_int64) {
*(int64_t *)(items[i].value) = items[i].default_value;
- } else if (items[i].handler == store_size) {
+ } else if (items[i].handler == store_size64) {
+ *(uint64_t *)(items[i].value) = (uint64_t)items[i].default_value;
+ } else if (items[i].handler == store_speed) {
*(uint64_t *)(items[i].value) = (uint64_t)items[i].default_value;
} else if (items[i].handler == store_time) {
*(utime_t *)(items[i].value) = (utime_t)items[i].default_value;
}
if (token != T_EQUALS) {
scan_err1(lc, _("expected an =, got: %s"), lc->str);
+ return;
}
break;
}
free_pool_memory(dest);
Dmsg0(900, "done with dest codes\n");
break;
+
case MD_FILE: /* file */
case MD_APPEND: /* append */
dest = get_pool_memory(PM_MESSAGE);
Dmsg1(900, "store_msgs dest=%s:\n", NPRT(dest));
if (token != T_EQUALS) {
scan_err1(lc, _("expected an =, got: %s"), lc->str);
+ return;
}
scan_types(lc, (MSGS *)(item->value), item->code, dest, NULL);
free_pool_memory(dest);
default:
scan_err1(lc, _("Unknown item code: %d\n"), item->code);
- break;
+ return;
}
}
scan_to_eol(lc);
}
if (!found) {
scan_err1(lc, _("message type: %s not found"), str);
- /* NOT REACHED */
+ return;
}
if (msg_type == M_MAX+1) { /* all? */
lex_get_token(lc, T_NAME);
if (!is_name_valid(lc->str, &msg)) {
scan_err1(lc, "%s\n", msg);
+ return;
}
free_pool_memory(msg);
/* Store the name both pass 1 and pass 2 */
if (*(item->value)) {
scan_err2(lc, _("Attempt to redefine name \"%s\" to \"%s\"."),
*(item->value), lc->str);
+ return;
}
*(item->value) = bstrdup(lc->str);
scan_to_eol(lc);
if (res == NULL) {
scan_err3(lc, _("Could not find config Resource %s referenced on line %d : %s\n"),
lc->str, lc->line_no, lc->line);
+ return;
}
if (*(item->value)) {
scan_err3(lc, _("Attempt to redefine resource \"%s\" referenced on line %d : %s\n"),
item->name, lc->line_no, lc->line);
+ return;
}
*(item->value) = (char *)res;
}
if (i >= count) {
scan_err4(lc, _("Too many %s directives. Max. is %d. line %d: %s\n"),
lc->str, count, lc->line_no, lc->line);
+ return;
}
list = New(alist(10, not_owned_by_alist));
}
if (res == NULL) {
scan_err3(lc, _("Could not find config Resource \"%s\" referenced on line %d : %s\n"),
item->name, lc->line_no, lc->line);
+ return;
}
Dmsg5(900, "Append %p to alist %p size=%d i=%d %s\n",
res, list, list->size(), i, item->name);
if (res == NULL) {
scan_err3(lc, _("Missing config Resource \"%s\" referenced on line %d : %s\n"),
lc->str, lc->line_no, lc->line);
+ return;
}
}
scan_to_eol(lc);
/* Store an integer at specified address */
-void store_int(LEX *lc, RES_ITEM *item, int index, int pass)
+void store_int32(LEX *lc, RES_ITEM *item, int index, int pass)
{
lex_get_token(lc, T_INT32);
- *(int *)(item->value) = lc->int32_val;
+ *(uint32_t *)(item->value) = lc->int32_val;
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
}
/* Store a positive integer at specified address */
-void store_pint(LEX *lc, RES_ITEM *item, int index, int pass)
+void store_pint32(LEX *lc, RES_ITEM *item, int index, int pass)
{
lex_get_token(lc, T_PINT32);
- *(int *)(item->value) = lc->pint32_val;
+ *(uint32_t *)(item->value) = lc->pint32_val;
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
}
set_bit(index, res_all.hdr.item_present);
}
+enum store_unit_type {
+ STORE_SIZE,
+ STORE_SPEED
+} ;
+
/* Store a size in bytes */
-void store_size(LEX *lc, RES_ITEM *item, int index, int pass)
+static void store_int_unit(LEX *lc, RES_ITEM *item, int index, int pass,
+ bool size32, enum store_unit_type type)
{
int token;
uint64_t uvalue;
char bsize[500];
- Dmsg0(900, "Enter store_size\n");
+ Dmsg0(900, "Enter store_unit\n");
token = lex_get_token(lc, T_SKIP_EOL);
errno = 0;
switch (token) {
break;
}
}
- if (!size_to_uint64(bsize, strlen(bsize), &uvalue)) {
- scan_err1(lc, _("expected a size number, got: %s"), lc->str);
+ if (type == STORE_SIZE) {
+ if (!size_to_uint64(bsize, strlen(bsize), &uvalue)) {
+ scan_err1(lc, _("expected a size number, got: %s"), lc->str);
+ return;
+ }
+ } else {
+ if (!speed_to_uint64(bsize, strlen(bsize), &uvalue)) {
+ scan_err1(lc, _("expected a speed number, got: %s"), lc->str);
+ return;
+ }
+ }
+ if (size32) {
+ *(uint32_t *)(item->value) = (uint32_t)uvalue;
+ } else {
+ *(uint64_t *)(item->value) = uvalue;
}
- *(uint64_t *)(item->value) = uvalue;
break;
default:
- scan_err1(lc, _("expected a size, got: %s"), lc->str);
- break;
+ scan_err2(lc, _("expected a %s, got: %s"),
+ (type == STORE_SIZE)?_("size"):_("speed"), lc->str);
+ return;
}
if (token != T_EOL) {
scan_to_eol(lc);
}
set_bit(index, res_all.hdr.item_present);
- Dmsg0(900, "Leave store_size\n");
+ Dmsg0(900, "Leave store_unit\n");
+}
+
+/* Store a size in bytes */
+void store_size32(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ store_int_unit(lc, item, index, pass, true /* 32 bit */, STORE_SIZE);
}
+/* Store a size in bytes */
+void store_size64(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ store_int_unit(lc, item, index, pass, false /* not 32 bit */, STORE_SIZE);
+}
+
+/* Store a speed in bytes/s */
+void store_speed(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ store_int_unit(lc, item, index, pass, false /* 64 bit */, STORE_SPEED);
+}
/* Store a time period in seconds */
void store_time(LEX *lc, RES_ITEM *item, int index, int pass)
}
if (!duration_to_utime(period, &utime)) {
scan_err1(lc, _("expected a time period, got: %s"), period);
+ return;
}
*(utime_t *)(item->value) = utime;
break;
default:
scan_err1(lc, _("expected a time period, got: %s"), lc->str);
- break;
+ return;
}
if (token != T_EOL) {
scan_to_eol(lc);
{
lex_get_token(lc, T_NAME);
if (strcasecmp(lc->str, "yes") == 0 || strcasecmp(lc->str, "true") == 0) {
- *(int *)(item->value) |= item->code;
+ *(uint32_t *)(item->value) |= item->code;
} else if (strcasecmp(lc->str, "no") == 0 || strcasecmp(lc->str, "false") == 0) {
- *(int *)(item->value) &= ~(item->code);
+ *(uint32_t *)(item->value) &= ~(item->code);
} else {
scan_err2(lc, _("Expect %s, got: %s"), "YES, NO, TRUE, or FALSE", lc->str); /* YES and NO must not be translated */
+ return;
}
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
*(bool *)(item->value) = false;
} else {
scan_err2(lc, _("Expect %s, got: %s"), "YES, NO, TRUE, or FALSE", lc->str); /* YES and NO must not be translated */
+ return;
}
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
/* Store the label pass 2 so that type is defined */
for (i=0; tapelabels[i].name; i++) {
if (strcasecmp(lc->str, tapelabels[i].name) == 0) {
- *(int *)(item->value) = tapelabels[i].token;
+ *(uint32_t *)(item->value) = tapelabels[i].token;
i = 0;
break;
}
}
if (i != 0) {
scan_err1(lc, _("Expected a Tape Label keyword, got: %s"), lc->str);
+ return;
}
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
p_resource
};
+CONFIG *new_config_parser()
+{
+ CONFIG *config;
+ config = (CONFIG *)malloc(sizeof(CONFIG));
+ memset(config, 0, sizeof(CONFIG));
+ return config;
+}
+
+void CONFIG::init(
+ const char *cf,
+ LEX_ERROR_HANDLER *scan_error,
+ int32_t err_type,
+ void *vres_all,
+ int32_t res_all_size,
+ int32_t r_first,
+ int32_t r_last,
+ RES_TABLE *resources,
+ RES **res_head)
+{
+ m_cf = cf;
+ m_scan_error = scan_error;
+ m_err_type = err_type;
+ m_res_all = vres_all;
+ m_res_all_size = res_all_size;
+ m_r_first = r_first;
+ m_r_last = r_last;
+ m_resources = resources;
+ m_res_head = res_head;
+}
+
/*********************************************************************
*
* Parse configuration file
* Note, the default behavior unless you have set an alternate
* scan_error handler is to die on an error.
*/
+#ifdef xxx
int
parse_config(const char *cf, LEX_ERROR_HANDLER *scan_error, int err_type)
+{
+ int ok;
+ CONFIG *config = new_config_parser();
+ config->init(cf, scan_error, err_type, (void *)&res_all, res_all_size,
+ r_first, r_last, resources, res_head);
+ ok = config->parse_config();
+ free(config);
+ return ok;
+}
+#endif
+
+
+bool CONFIG::parse_config()
{
LEX *lc = NULL;
int token, i, pass;
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)) {
- cf = full_path;
+ 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.
}
lex_set_error_handler_error_type(lc, err_type) ;
while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
- Dmsg1(900, "parse got token=%s\n", lex_tok_to_str(token));
+ 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) {
} 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;
+ goto bail_out;
} else if (token != T_IDENTIFIER) {
scan_err1(lc, _("Expected a Resource name identifier, got: %s"), lc->str);
- return 0;
+ goto bail_out;
}
for (i=0; resources[i].name; i++) {
if (strcasecmp(resources[i].name, lc->str) == 0) {
- state = p_resource;
items = resources[i].items;
+ if (!items) {
+ break;
+ }
+ state = p_resource;
res_type = resources[i].rcode;
- init_resource(res_type, items, pass);
+ init_resource(this, res_type, items, pass);
break;
}
}
if (state == p_none) {
scan_err1(lc, _("expected resource name, got: %s"), lc->str);
- return 0;
+ goto bail_out;
}
break;
case p_resource:
case T_IDENTIFIER:
if (level != 1) {
scan_err1(lc, _("not in resource definition: %s"), lc->str);
- return 0;
+ goto bail_out;
}
for (i=0; items[i].name; i++) {
if (strcasecmp(items[i].name, lc->str) == 0) {
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;
+ goto bail_out;
}
}
Dmsg1(800, "calling handler for %s\n", items[i].name);
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;
+ goto bail_out;
}
break;
Dmsg0(900, "T_EOB => define new resource\n");
if (res_all.hdr.name == NULL) {
scan_err0(lc, _("Name not specified for resource"));
+ goto bail_out;
}
save_resource(res_type, items, pass); /* save resource */
break;
default:
scan_err2(lc, _("unexpected token %d %s in resource definition"),
token, lex_tok_to_str(token));
- return 0;
+ goto bail_out;
}
break;
default:
scan_err1(lc, _("Unknown parser state %d\n"), state);
- return 0;
+ goto bail_out;
}
}
if (state != p_none) {
scan_err0(lc, _("End of conf file reached with unclosed resource."));
- return 0;
+ goto bail_out;
}
if (debug_level >= 900 && pass == 2) {
int i;
- for (i=r_first; i<=r_last; i++) {
- dump_resource(i, res_head[i-r_first], prtmsg, NULL);
+ 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;
+bail_out:
+ if (lc) {
+ lc = lex_close_file(lc);
+ }
+ return 0;
}
const char *get_default_configdir()
#endif
}
-bool
+/*
+ * Returns false on error
+ * true on OK, with full_path set to where config file should be
+ */
+static bool
find_config_file(const char *config_file, char *full_path, int max_path)
{
- if (first_path_separator(config_file) != NULL) {
- return false;
- }
-
- struct stat st;
+ int file_length = strlen(config_file) + 1;
- if (stat(config_file, &st) == 0) {
- return false;
+ /* If a full path specified, use it */
+ if (first_path_separator(config_file) != NULL) {
+ if (file_length > max_path) {
+ return false;
+ }
+ bstrncpy(full_path, config_file, file_length);
+ return true;
}
+ /* config_file is default file name, now find default dir */
const char *config_dir = get_default_configdir();
int dir_length = strlen(config_dir);
- int file_length = strlen(config_file);
- if ((dir_length + 1 + file_length + 1) > max_path) {
+ if ((dir_length + 1 + file_length) > max_path) {
return false;
}
full_path[dir_length++] = '/';
}
- memcpy(&full_path[dir_length], config_file, file_length + 1);
+ memcpy(&full_path[dir_length], config_file, file_length);
return true;
}
* Free configuration resources
*
*/
+void CONFIG::free_resources()
+{
+ for (int i=m_r_first; i<=m_r_last; i++) {
+ free_resource(m_res_head[i-m_r_first], i);
+ m_res_head[i-m_r_first] = NULL;
+ }
+}
+
+RES **CONFIG::save_resources()
+{
+ int num = m_r_last - m_r_first + 1;
+ RES **res = (RES **)malloc(num*sizeof(RES *));
+ for (int i=0; i<num; i++) {
+ res[i] = m_res_head[i];
+ m_res_head[i] = NULL;
+ }
+ return res;
+}
+
+RES **CONFIG::new_res_head()
+{
+ int size = (m_r_last - m_r_first + 1) * sizeof(RES *);
+ RES **res = (RES **)malloc(size);
+ memset(res, 0, size);
+ return res;
+}
+
+
+#ifdef xxx
void free_config_resources()
{
for (int i=r_first; i<=r_last; i++) {
memset(res, 0, size);
return res;
}
+#endif