* Version $Id$
*/
/*
- Copyright (C) 2000-2003 Kern Sibbald and John Walker
+ Copyright (C) 2000-2004 Kern Sibbald and John Walker
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
int r_first = R_FIRST;
int r_last = R_LAST;
-pthread_mutex_t res_mutex = PTHREAD_MUTEX_INITIALIZER;
-
/* Imported subroutines */
-extern void store_run(LEX *lc, struct res_items *item, int index, int pass);
-extern void store_finc(LEX *lc, struct res_items *item, int index, int pass);
-extern void store_inc(LEX *lc, struct res_items *item, int index, int pass);
+extern void store_run(LEX *lc, RES_ITEM *item, int index, int pass);
+extern void store_finc(LEX *lc, RES_ITEM *item, int index, int pass);
+extern void store_inc(LEX *lc, RES_ITEM *item, int index, int pass);
/* Forward referenced subroutines */
-void store_jobtype(LEX *lc, struct res_items *item, int index, int pass);
-void store_level(LEX *lc, struct res_items *item, int index, int pass);
-void store_replace(LEX *lc, struct res_items *item, int index, int pass);
+void store_jobtype(LEX *lc, RES_ITEM *item, int index, int pass);
+void store_level(LEX *lc, RES_ITEM *item, int index, int pass);
+void store_replace(LEX *lc, RES_ITEM *item, int index, int pass);
+void store_acl(LEX *lc, RES_ITEM *item, int index, int pass);
/* We build the current resource here as we are
*
* name handler value code flags default_value
*/
-static struct res_items dir_items[] = {
+static RES_ITEM dir_items[] = {
{"name", store_name, ITEM(res_dir.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_dir.hdr.desc), 0, 0, 0},
{"messages", store_res, ITEM(res_dir.messages), R_MSGS, 0, 0},
*
* name handler value code flags default_value
*/
-static struct res_items con_items[] = {
+static RES_ITEM con_items[] = {
{"name", store_name, ITEM(res_con.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_con.hdr.desc), 0, 0, 0},
{"enablessl", store_yesno, ITEM(res_con.enable_ssl), 1, ITEM_DEFAULT, 0},
{"password", store_password, ITEM(res_con.password), 0, ITEM_REQUIRED, 0},
+ {"jobacl", store_acl, ITEM(res_con.ACL_lists), Job_ACL, 0, 0},
+ {"clientacl", store_acl, ITEM(res_con.ACL_lists), Client_ACL, 0, 0},
+ {"storageacl", store_acl, ITEM(res_con.ACL_lists), Storage_ACL, 0, 0},
+ {"scheduleacl", store_acl, ITEM(res_con.ACL_lists), Schedule_ACL, 0, 0},
+ {"runacl", store_acl, ITEM(res_con.ACL_lists), Run_ACL, 0, 0},
+ {"poolacl", store_acl, ITEM(res_con.ACL_lists), Pool_ACL, 0, 0},
+ {"commandacl", store_acl, ITEM(res_con.ACL_lists), Command_ACL, 0, 0},
+ {"filesetacl", store_acl, ITEM(res_con.ACL_lists), FileSet_ACL, 0, 0},
+ {"catalogacl", store_acl, ITEM(res_con.ACL_lists), Catalog_ACL, 0, 0},
{NULL, NULL, NULL, 0, 0, 0}
};
* name handler value code flags default_value
*/
-static struct res_items cli_items[] = {
+static RES_ITEM cli_items[] = {
{"name", store_name, ITEM(res_client.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_client.hdr.desc), 0, 0, 0},
{"address", store_str, ITEM(res_client.address), 0, ITEM_REQUIRED, 0},
*
* name handler value code flags default_value
*/
-static struct res_items store_items[] = {
+static RES_ITEM store_items[] = {
{"name", store_name, ITEM(res_store.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_store.hdr.desc), 0, 0, 0},
{"sdport", store_pint, ITEM(res_store.SDport), 0, ITEM_DEFAULT, 9103},
*
* name handler value code flags default_value
*/
-static struct res_items cat_items[] = {
+static RES_ITEM cat_items[] = {
{"name", store_name, ITEM(res_cat.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_cat.hdr.desc), 0, 0, 0},
{"address", store_str, ITEM(res_cat.db_address), 0, 0, 0},
*
* name handler value code flags default_value
*/
-struct res_items job_items[] = {
+RES_ITEM job_items[] = {
{"name", store_name, ITEM(res_job.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_job.hdr.desc), 0, 0, 0},
{"type", store_jobtype, ITEM(res_job.JobType), 0, ITEM_REQUIRED, 0},
{"messages", store_res, ITEM(res_job.messages), R_MSGS, ITEM_REQUIRED, 0},
{"storage", store_res, ITEM(res_job.storage), R_STORAGE, ITEM_REQUIRED, 0},
{"pool", store_res, ITEM(res_job.pool), R_POOL, ITEM_REQUIRED, 0},
+ {"fullbackuppool", store_res, ITEM(res_job.full_pool), R_POOL, 0, 0},
+ {"incrementalbackuppool", store_res, ITEM(res_job.inc_pool), R_POOL, 0, 0},
+ {"differentialbackuppool", store_res, ITEM(res_job.dif_pool), R_POOL, 0, 0},
{"client", store_res, ITEM(res_job.client), R_CLIENT, ITEM_REQUIRED, 0},
{"fileset", store_res, ITEM(res_job.fileset), R_FILESET, ITEM_REQUIRED, 0},
{"schedule", store_res, ITEM(res_job.schedule), R_SCHEDULE, 0, 0},
{"prunefiles", store_yesno, ITEM(res_job.PruneFiles), 1, ITEM_DEFAULT, 0},
{"prunevolumes",store_yesno, ITEM(res_job.PruneVolumes), 1, ITEM_DEFAULT, 0},
{"spoolattributes",store_yesno, ITEM(res_job.SpoolAttributes), 1, ITEM_DEFAULT, 0},
+ {"spooldata", store_yesno, ITEM(res_job.spool_data), 1, ITEM_DEFAULT, 0},
{"runbeforejob", store_str, ITEM(res_job.RunBeforeJob), 0, 0, 0},
{"runafterjob", store_str, ITEM(res_job.RunAfterJob), 0, 0, 0},
{"runafterfailedjob", store_str, ITEM(res_job.RunAfterFailedJob), 0, 0, 0},
*
* name handler value code flags default_value
*/
-static struct res_items fs_items[] = {
+static RES_ITEM fs_items[] = {
{"name", store_name, ITEM(res_fs.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_fs.hdr.desc), 0, 0, 0},
{"include", store_inc, NULL, 0, ITEM_NO_EQUALS, 0},
*
* name handler value code flags default_value
*/
-static struct res_items sch_items[] = {
+static RES_ITEM sch_items[] = {
{"name", store_name, ITEM(res_sch.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_sch.hdr.desc), 0, 0, 0},
{"run", store_run, ITEM(res_sch.run), 0, 0, 0},
{NULL, NULL, NULL, 0, 0, 0}
};
-/* Group resource -- not implemented
- *
- * name handler value code flags default_value
- */
-static struct res_items group_items[] = {
- {"name", store_name, ITEM(res_group.hdr.name), 0, ITEM_REQUIRED, 0},
- {"description", store_str, ITEM(res_group.hdr.desc), 0, 0, 0},
- {NULL, NULL, NULL, 0, 0, 0}
-};
-
/* Pool resource
*
* name handler value code flags default_value
*/
-static struct res_items pool_items[] = {
+static RES_ITEM pool_items[] = {
{"name", store_name, ITEM(res_pool.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_pool.hdr.desc), 0, 0, 0},
{"pooltype", store_strname, ITEM(res_pool.pool_type), 0, ITEM_REQUIRED, 0},
* Counter Resource
* name handler value code flags default_value
*/
-static struct res_items counter_items[] = {
+static RES_ITEM counter_items[] = {
{"name", store_name, ITEM(res_counter.hdr.name), 0, ITEM_REQUIRED, 0},
{"description", store_str, ITEM(res_counter.hdr.desc), 0, 0, 0},
{"minimum", store_int, ITEM(res_counter.MinValue), 0, ITEM_DEFAULT, 0},
/* Message resource */
-extern struct res_items msgs_items[];
+extern RES_ITEM msgs_items[];
/*
* This is the master resource definition.
*
* name items rcode res_head
*/
-struct s_res resources[] = {
+RES_TABLE resources[] = {
{"director", dir_items, R_DIRECTOR, NULL},
{"client", cli_items, R_CLIENT, NULL},
{"job", job_items, R_JOB, NULL},
{"catalog", cat_items, R_CATALOG, NULL},
{"schedule", sch_items, R_SCHEDULE, NULL},
{"fileset", fs_items, R_FILESET, NULL},
- {"group", group_items, R_GROUP, NULL},
{"pool", pool_items, R_POOL, NULL},
{"messages", msgs_items, R_MSGS, NULL},
{"counter", counter_items, R_COUNTER, NULL},
static char level_no[30];
char *str = level_no;
- sprintf(level_no, "%d", level); /* default if not found */
+ bsnprintf(level_no, sizeof(level_no), "%d", level); /* default if not found */
for (i=0; joblevels[i].level_name; i++) {
if (level == joblevels[i].level) {
str = joblevels[i].level_name;
res->res_job.hdr.name, res->res_job.JobType,
level_to_str(res->res_job.level), res->res_job.Priority,
res->res_job.MaxConcurrentJobs);
- sendit(sock, " Resched=%d Times=%d Interval=%s\n",
+ sendit(sock, " Resched=%d Times=%d Interval=%s Spool=%d\n",
res->res_job.RescheduleOnError, res->res_job.RescheduleTimes,
- edit_uint64_with_commas(res->res_job.RescheduleInterval, ed1));
+ edit_uint64_with_commas(res->res_job.RescheduleInterval, ed1),
+ res->res_job.spool_data);
if (res->res_job.client) {
sendit(sock, " --> ");
dump_resource(-R_CLIENT, (RES *)res->res_job.client, sendit, sock);
if (res->res_job.pool) {
sendit(sock, " --> ");
dump_resource(-R_POOL, (RES *)res->res_job.pool, sendit, sock);
- } else {
- sendit(sock, "!!! No Pool resource\n");
+ }
+ if (res->res_job.full_pool) {
+ sendit(sock, " --> ");
+ dump_resource(-R_POOL, (RES *)res->res_job.full_pool, sendit, sock);
+ }
+ if (res->res_job.inc_pool) {
+ sendit(sock, " --> ");
+ dump_resource(-R_POOL, (RES *)res->res_job.inc_pool, sendit, sock);
+ }
+ if (res->res_job.dif_pool) {
+ sendit(sock, " --> ");
+ dump_resource(-R_POOL, (RES *)res->res_job.dif_pool, sendit, sock);
}
if (res->res_job.verify_job) {
sendit(sock, " --> ");
if (res->res_sch.run) {
int i;
RUN *run = res->res_sch.run;
- char buf[1000], num[10];
+ char buf[1000], num[30];
sendit(sock, "Schedule: name=%s\n", res->res_sch.hdr.name);
if (!run) {
break;
bstrncpy(buf, " hour=", sizeof(buf));
for (i=0; i<24; i++) {
if (bit_is_set(i, run->hour)) {
- sprintf(num, "%d ", i);
+ bsnprintf(num, sizeof(num), "%d ", i);
bstrncat(buf, num, sizeof(buf));
}
}
bstrncpy(buf, " mday=", sizeof(buf));
for (i=0; i<31; i++) {
if (bit_is_set(i, run->mday)) {
- sprintf(num, "%d ", i);
+ bsnprintf(num, sizeof(num), "%d ", i);
bstrncat(buf, num, sizeof(buf));
}
}
bstrncpy(buf, " month=", sizeof(buf));
for (i=0; i<12; i++) {
if (bit_is_set(i, run->month)) {
- sprintf(num, "%d ", i);
+ bsnprintf(num, sizeof(num), "%d ", i);
bstrncat(buf, num, sizeof(buf));
}
}
bstrncpy(buf, " wday=", sizeof(buf));
for (i=0; i<7; i++) {
if (bit_is_set(i, run->wday)) {
- sprintf(num, "%d ", i);
+ bsnprintf(num, sizeof(num), "%d ", i);
bstrncat(buf, num, sizeof(buf));
}
}
bstrncpy(buf, " wom=", sizeof(buf));
for (i=0; i<5; i++) {
if (bit_is_set(i, run->wom)) {
- sprintf(num, "%d ", i);
+ bsnprintf(num, sizeof(num), "%d ", i);
bstrncat(buf, num, sizeof(buf));
}
}
bstrncpy(buf, " woy=", sizeof(buf));
for (i=0; i<54; i++) {
if (bit_is_set(i, run->woy)) {
- sprintf(num, "%d ", i);
+ bsnprintf(num, sizeof(num), "%d ", i);
bstrncat(buf, num, sizeof(buf));
}
}
sendit(sock, "Schedule: name=%s\n", res->res_sch.hdr.name);
}
break;
- case R_GROUP:
- sendit(sock, "Group: name=%s\n", res->res_group.hdr.name);
- break;
case R_POOL:
sendit(sock, "Pool: name=%s PoolType=%s\n", res->res_pool.hdr.name,
res->res_pool.pool_type);
* resource chain is traversed. Mainly we worry about freeing
* allocated strings (names).
*/
-void free_resource(int type)
+void free_resource(RES *sres, int type)
{
int num;
- URES *res;
- RES *nres;
- int rindex = type - r_first;
-
- res = (URES *)resources[rindex].res_head;
+ RES *nres; /* next resource if linked */
+ URES *res = (URES *)sres;
if (res == NULL)
return;
if (res->res_con.password) {
free(res->res_con.password);
}
+ for (int i=0; i<Num_ACL; i++) {
+ if (res->res_con.ACL_lists[i]) {
+ delete res->res_con.ACL_lists[i];
+ res->res_con.ACL_lists[i] = NULL;
+ }
+ }
break;
case R_CLIENT:
if (res->res_client.address) {
free_msgs_res((MSGS *)res); /* free message resource */
res = NULL;
break;
- case R_GROUP:
- break;
default:
printf("Unknown resource type %d in free_resource.\n", type);
}
if (res) {
free(res);
}
- resources[rindex].res_head = nres;
if (nres) {
- free_resource(type);
+ free_resource(nres, type);
}
}
* pointers because they may not have been defined until
* later in pass 1.
*/
-void save_resource(int type, struct res_items *items, int pass)
+void save_resource(int type, RES_ITEM *items, int pass)
{
URES *res;
int rindex = type - r_first;
case R_CONSOLE:
case R_CATALOG:
case R_STORAGE:
- case R_GROUP:
case R_POOL:
case R_MSGS:
case R_FILESET:
res->res_job.fileset = res_all.res_job.fileset;
res->res_job.storage = res_all.res_job.storage;
res->res_job.pool = res_all.res_job.pool;
+ res->res_job.full_pool = res_all.res_job.full_pool;
+ res->res_job.inc_pool = res_all.res_job.inc_pool;
+ res->res_job.dif_pool = res_all.res_job.dif_pool;
res->res_job.verify_job = res_all.res_job.verify_job;
res->res_job.jobdefs = res_all.res_job.jobdefs;
break;
case R_SCHEDULE:
size = sizeof(SCHED);
break;
- case R_GROUP:
- size = sizeof(GROUP);
- break;
case R_POOL:
size = sizeof(POOL);
break;
* Store JobType (backup, verify, restore)
*
*/
-void store_jobtype(LEX *lc, struct res_items *item, int index, int pass)
+void store_jobtype(LEX *lc, RES_ITEM *item, int index, int pass)
{
int token, i;
* Store Job Level (Full, Incremental, ...)
*
*/
-void store_level(LEX *lc, struct res_items *item, int index, int pass)
+void store_level(LEX *lc, RES_ITEM *item, int index, int pass)
{
int token, i;
set_bit(index, res_all.hdr.item_present);
}
-void store_replace(LEX *lc, struct res_items *item, int index, int pass)
+void store_replace(LEX *lc, RES_ITEM *item, int index, int pass)
{
int token, i;
token = lex_get_token(lc, T_NAME);
set_bit(index, res_all.hdr.item_present);
}
+/*
+ * Store ACL (access control list)
+ *
+ */
+void store_acl(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ int token;
+
+ for (;;) {
+ token = lex_get_token(lc, T_NAME);
+ if (pass == 1) {
+ if (((alist **)item->value)[item->code] == NULL) {
+ ((alist **)item->value)[item->code] = new alist(10, owned_by_alist);
+// Dmsg1(400, "Defined new ACL alist at %d\n", item->code);
+ }
+ ((alist **)item->value)[item->code]->append(bstrdup(lc->str));
+// Dmsg2(400, "Appended to %d %s\n", item->code, lc->str);
+ }
+ token = lex_get_token(lc, T_ALL);
+ if (token == T_COMMA) {
+ continue; /* get another ACL */
+ }
+ break;
+ }
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
#ifdef old_deprecated_code
/*
* Store backup/verify info for Job record
*
* Backup = Client=<client-name> FileSet=<FileSet-name> Level=<level>
*/
-static void store_backup(LEX *lc, struct res_items *item, int index, int pass)
+static void store_backup(LEX *lc, RES_ITEM *item, int index, int pass)
{
int token, i;
RES *res;
* Restore = JobId=<job-id> Where=<root-directory> Replace=<options> Bootstrap=<file>
*
*/
-static void store_restore(LEX *lc, struct res_items *item, int index, int pass)
+static void store_restore(LEX *lc, RES_ITEM *item, int index, int pass)
{
int token, i;
RES *res;
projects / bacula / bacula / blobdiff