X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fdird_conf.c;h=0517e4a9abad84bb61d7b7b1ca5e9cce972abce3;hb=5b6583c38af78bdd11114c43644ba940c2fc34e9;hp=7299e197aa76c3254402be69d3e47e171396b6da;hpb=f26452f270e5f57a05939bc03240471bfd242521;p=bacula%2Fbacula diff --git a/bacula/src/dird/dird_conf.c b/bacula/src/dird/dird_conf.c index 7299e197aa..0517e4a9ab 100644 --- a/bacula/src/dird/dird_conf.c +++ b/bacula/src/dird/dird_conf.c @@ -1,3 +1,30 @@ +/* + Bacula® - The Network Backup Solution + + Copyright (C) 2000-2009 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 + License as published by the Free Software Foundation and included + in the file LICENSE. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + 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 + 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 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. +*/ /* * Main configuration file parser for Bacula Directors, * some parts may be split into separate files such as @@ -21,33 +48,7 @@ * * Version $Id$ */ -/* - Bacula® - The Network Backup Solution - - Copyright (C) 2000-2006 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 - License as published by the Free Software Foundation plus additions - that are listed in the file LICENSE. - - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - 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 - 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. - The licensor of Bacula is the Free Software Foundation Europe - (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich, - Switzerland, email:ftf@fsfeurope.org. -*/ #include "bacula.h" #include "dird.h" @@ -56,8 +57,8 @@ * types. Note, these should be unique for each * daemon though not a requirement. */ -int r_first = R_FIRST; -int r_last = R_LAST; +int32_t r_first = R_FIRST; +int32_t r_last = R_LAST; static RES *sres_head[R_LAST - R_FIRST + 1]; RES **res_head = sres_head; @@ -73,8 +74,8 @@ 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); +void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass); static void store_device(LEX *lc, RES_ITEM *item, int index, int pass); -static void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass); static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass); static void store_runscript_when(LEX *lc, RES_ITEM *item, int index, int pass); static void store_runscript_cmd(LEX *lc, RES_ITEM *item, int index, int pass); @@ -87,12 +88,12 @@ static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass); */ #if defined(_MSC_VER) extern "C" { // work around visual compiler mangling variables - URES res_all; + URES res_all; } #else URES res_all; #endif -int res_all_size = sizeof(res_all); +int32_t res_all_size = sizeof(res_all); /* Definition of records permitted within each @@ -111,15 +112,20 @@ static RES_ITEM dir_items[] = { {"dirport", store_addresses_port, ITEM(res_dir.DIRaddrs), 0, ITEM_DEFAULT, 9101}, {"diraddress", store_addresses_address, ITEM(res_dir.DIRaddrs), 0, ITEM_DEFAULT, 9101}, {"diraddresses",store_addresses, ITEM(res_dir.DIRaddrs), 0, ITEM_DEFAULT, 9101}, + {"dirsourceaddress",store_addresses_address, ITEM(res_dir.DIRsrc_addr), 0, ITEM_DEFAULT, 0}, {"queryfile", store_dir, ITEM(res_dir.query_file), 0, ITEM_REQUIRED, 0}, {"workingdirectory", store_dir, ITEM(res_dir.working_directory), 0, ITEM_REQUIRED, 0}, + {"plugindirectory", store_dir, ITEM(res_dir.plugin_directory), 0, 0, 0}, {"scriptsdirectory", store_dir, ITEM(res_dir.scripts_directory), 0, 0, 0}, - {"piddirectory",store_dir, ITEM(res_dir.pid_directory), 0, ITEM_REQUIRED, 0}, - {"subsysdirectory", store_dir, ITEM(res_dir.subsys_directory), 0, 0, 0}, - {"maximumconcurrentjobs", store_pint, ITEM(res_dir.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"piddirectory", store_dir, ITEM(res_dir.pid_directory), 0, ITEM_REQUIRED, 0}, + {"subsysdirectory", store_dir, ITEM(res_dir.subsys_directory), 0, 0, 0}, + {"maximumconcurrentjobs", store_pint32, ITEM(res_dir.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"maximumconsoleconnections", store_pint32, ITEM(res_dir.MaxConsoleConnect), 0, ITEM_DEFAULT, 20}, {"password", store_password, ITEM(res_dir.password), 0, ITEM_REQUIRED, 0}, - {"fdconnecttimeout", store_time,ITEM(res_dir.FDConnectTimeout), 0, ITEM_DEFAULT, 60 * 30}, - {"sdconnecttimeout", store_time,ITEM(res_dir.SDConnectTimeout), 0, ITEM_DEFAULT, 60 * 30}, + {"fdconnecttimeout", store_time,ITEM(res_dir.FDConnectTimeout), 0, ITEM_DEFAULT, 3 * 60}, + {"sdconnecttimeout", store_time,ITEM(res_dir.SDConnectTimeout), 0, ITEM_DEFAULT, 30 * 60}, + {"heartbeatinterval", store_time, ITEM(res_dir.heartbeat_interval), 0, ITEM_DEFAULT, 0}, + {"tlsauthenticate", store_bool, ITEM(res_dir.tls_authenticate), 0, 0, 0}, {"tlsenable", store_bool, ITEM(res_dir.tls_enable), 0, 0, 0}, {"tlsrequire", store_bool, ITEM(res_dir.tls_require), 0, 0, 0}, {"tlsverifypeer", store_bool, ITEM(res_dir.tls_verify_peer), 0, ITEM_DEFAULT, true}, @@ -129,6 +135,8 @@ static RES_ITEM dir_items[] = { {"tlskey", store_dir, ITEM(res_dir.tls_keyfile), 0, 0, 0}, {"tlsdhfile", store_dir, ITEM(res_dir.tls_dhfile), 0, 0, 0}, {"tlsallowedcn", store_alist_str, ITEM(res_dir.tls_allowed_cns), 0, 0, 0}, + {"statisticsretention", store_time, ITEM(res_dir.stats_retention), 0, ITEM_DEFAULT, 60*60*24*31*12*5}, + {"verid", store_str, ITEM(res_dir.verid), 0, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -151,6 +159,8 @@ static RES_ITEM con_items[] = { {"filesetacl", store_acl, ITEM(res_con.ACL_lists), FileSet_ACL, 0, 0}, {"catalogacl", store_acl, ITEM(res_con.ACL_lists), Catalog_ACL, 0, 0}, {"whereacl", store_acl, ITEM(res_con.ACL_lists), Where_ACL, 0, 0}, + {"pluginoptionsacl", store_acl, ITEM(res_con.ACL_lists), PluginOptions_ACL, 0, 0}, + {"tlsauthenticate", store_bool, ITEM(res_con.tls_authenticate), 0, 0, 0}, {"tlsenable", store_bool, ITEM(res_con.tls_enable), 0, 0, 0}, {"tlsrequire", store_bool, ITEM(res_con.tls_require), 0, 0, 0}, {"tlsverifypeer", store_bool, ITEM(res_con.tls_verify_peer), 0, ITEM_DEFAULT, true}, @@ -175,20 +185,23 @@ static RES_ITEM cli_items[] = { {"description", store_str, ITEM(res_client.hdr.desc), 0, 0, 0}, {"address", store_str, ITEM(res_client.address), 0, ITEM_REQUIRED, 0}, {"fdaddress", store_str, ITEM(res_client.address), 0, 0, 0}, - {"fdport", store_pint, ITEM(res_client.FDport), 0, ITEM_DEFAULT, 9102}, + {"fdport", store_pint32, ITEM(res_client.FDport), 0, ITEM_DEFAULT, 9102}, {"password", store_password, ITEM(res_client.password), 0, ITEM_REQUIRED, 0}, - {"fdpassword", store_password, ITEM(res_client.password), 0, 0, 0}, + {"fdpassword", store_password, ITEM(res_client.password), 0, 0, 0}, {"catalog", store_res, ITEM(res_client.catalog), R_CATALOG, ITEM_REQUIRED, 0}, {"fileretention", store_time, ITEM(res_client.FileRetention), 0, ITEM_DEFAULT, 60*60*24*60}, {"jobretention", store_time, ITEM(res_client.JobRetention), 0, ITEM_DEFAULT, 60*60*24*180}, + {"heartbeatinterval", store_time, ITEM(res_client.heartbeat_interval), 0, ITEM_DEFAULT, 0}, {"autoprune", store_bool, ITEM(res_client.AutoPrune), 0, ITEM_DEFAULT, true}, - {"maximumconcurrentjobs", store_pint, ITEM(res_client.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"maximumconcurrentjobs", store_pint32, ITEM(res_client.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"tlsauthenticate", store_bool, ITEM(res_client.tls_authenticate), 0, 0, 0}, {"tlsenable", store_bool, ITEM(res_client.tls_enable), 0, 0, 0}, {"tlsrequire", store_bool, ITEM(res_client.tls_require), 0, 0, 0}, {"tlscacertificatefile", store_dir, ITEM(res_client.tls_ca_certfile), 0, 0, 0}, {"tlscacertificatedir", store_dir, ITEM(res_client.tls_ca_certdir), 0, 0, 0}, {"tlscertificate", store_dir, ITEM(res_client.tls_certfile), 0, 0, 0}, {"tlskey", store_dir, ITEM(res_client.tls_keyfile), 0, 0, 0}, + {"tlsallowedcn", store_alist_str, ITEM(res_client.tls_allowed_cns), 0, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -199,7 +212,7 @@ static RES_ITEM cli_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}, + {"sdport", store_pint32, ITEM(res_store.SDport), 0, ITEM_DEFAULT, 9103}, {"address", store_str, ITEM(res_store.address), 0, ITEM_REQUIRED, 0}, {"sdaddress", store_str, ITEM(res_store.address), 0, 0, 0}, {"password", store_password, ITEM(res_store.password), 0, ITEM_REQUIRED, 0}, @@ -208,8 +221,10 @@ static RES_ITEM store_items[] = { {"mediatype", store_strname, ITEM(res_store.media_type), 0, ITEM_REQUIRED, 0}, {"autochanger", store_bool, ITEM(res_store.autochanger), 0, ITEM_DEFAULT, 0}, {"enabled", store_bool, ITEM(res_store.enabled), 0, ITEM_DEFAULT, true}, - {"maximumconcurrentjobs", store_pint, ITEM(res_store.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, - {"sddport", store_pint, ITEM(res_store.SDDport), 0, 0, 0}, /* deprecated */ + {"heartbeatinterval", store_time, ITEM(res_store.heartbeat_interval), 0, ITEM_DEFAULT, 0}, + {"maximumconcurrentjobs", store_pint32, ITEM(res_store.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"sddport", store_pint32, ITEM(res_store.SDDport), 0, 0, 0}, /* deprecated */ + {"tlsauthenticate", store_bool, ITEM(res_store.tls_authenticate), 0, 0, 0}, {"tlsenable", store_bool, ITEM(res_store.tls_enable), 0, 0, 0}, {"tlsrequire", store_bool, ITEM(res_store.tls_require), 0, 0, 0}, {"tlscacertificatefile", store_dir, ITEM(res_store.tls_ca_certfile), 0, 0, 0}, @@ -229,12 +244,14 @@ static RES_ITEM cat_items[] = { {"description", store_str, ITEM(res_cat.hdr.desc), 0, 0, 0}, {"address", store_str, ITEM(res_cat.db_address), 0, 0, 0}, {"dbaddress", store_str, ITEM(res_cat.db_address), 0, 0, 0}, - {"dbport", store_pint, ITEM(res_cat.db_port), 0, 0, 0}, + {"dbport", store_pint32, ITEM(res_cat.db_port), 0, 0, 0}, /* keep this password as store_str for the moment */ {"password", store_str, ITEM(res_cat.db_password), 0, 0, 0}, {"dbpassword", store_str, ITEM(res_cat.db_password), 0, 0, 0}, + {"dbuser", store_str, ITEM(res_cat.db_user), 0, 0, 0}, {"user", store_str, ITEM(res_cat.db_user), 0, 0, 0}, {"dbname", store_str, ITEM(res_cat.db_name), 0, ITEM_REQUIRED, 0}, + {"dbdriver", store_str, ITEM(res_cat.db_driver), 0, 0, 0}, {"dbsocket", store_str, ITEM(res_cat.db_socket), 0, 0, 0}, /* Turned off for the moment */ {"multipleconnections", store_bit, ITEM(res_cat.mult_db_connections), 0, 0, 0}, @@ -266,18 +283,29 @@ RES_ITEM job_items[] = { {"run", store_alist_str, ITEM(res_job.run_cmds), 0, 0, 0}, /* Root of where to restore files */ {"where", store_dir, ITEM(res_job.RestoreWhere), 0, 0, 0}, + {"regexwhere", store_str, ITEM(res_job.RegexWhere), 0, 0, 0}, + {"stripprefix", store_str, ITEM(res_job.strip_prefix), 0, 0, 0}, + {"addprefix", store_str, ITEM(res_job.add_prefix), 0, 0, 0}, + {"addsuffix", store_str, ITEM(res_job.add_suffix), 0, 0, 0}, /* Where to find bootstrap during restore */ {"bootstrap",store_dir, ITEM(res_job.RestoreBootstrap), 0, 0, 0}, /* Where to write bootstrap file during backup */ {"writebootstrap",store_dir, ITEM(res_job.WriteBootstrap), 0, 0, 0}, - {"writeverifylist",store_dir, ITEM(res_job.WriteVerifyList), 0, 0, 0}, + {"writeverifylist",store_dir,ITEM(res_job.WriteVerifyList), 0, 0, 0}, {"replace", store_replace, ITEM(res_job.replace), 0, ITEM_DEFAULT, REPLACE_ALWAYS}, + {"maxrunschedtime", store_time, ITEM(res_job.MaxRunSchedTime), 0, 0, 0}, {"maxruntime", store_time, ITEM(res_job.MaxRunTime), 0, 0, 0}, - {"fullmaxwaittime", store_time, ITEM(res_job.FullMaxWaitTime), 0, 0, 0}, - {"incrementalmaxwaittime", store_time, ITEM(res_job.IncMaxWaitTime), 0, 0, 0}, - {"differentialmaxwaittime", store_time, ITEM(res_job.DiffMaxWaitTime), 0, 0, 0}, + /* xxxMaxWaitTime are deprecated */ + {"fullmaxwaittime", store_time, ITEM(res_job.FullMaxRunTime), 0, 0, 0}, + {"incrementalmaxwaittime", store_time, ITEM(res_job.IncMaxRunTime), 0, 0, 0}, + {"differentialmaxwaittime", store_time, ITEM(res_job.DiffMaxRunTime), 0, 0, 0}, + {"fullmaxruntime", store_time, ITEM(res_job.FullMaxRunTime), 0, 0, 0}, + {"incrementalmaxruntime", store_time, ITEM(res_job.IncMaxRunTime), 0, 0, 0}, + {"differentialmaxruntime", store_time, ITEM(res_job.DiffMaxRunTime), 0, 0, 0}, {"maxwaittime", store_time, ITEM(res_job.MaxWaitTime), 0, 0, 0}, {"maxstartdelay",store_time, ITEM(res_job.MaxStartDelay), 0, 0, 0}, + {"maxfullinterval", store_time, ITEM(res_job.MaxFullInterval), 0, 0, 0}, + {"maxdiffinterval", store_time, ITEM(res_job.MaxDiffInterval), 0, 0, 0}, {"jobretention", store_time, ITEM(res_job.JobRetention), 0, 0, 0}, {"prefixlinks", store_bool, ITEM(res_job.PrefixLinks), 0, ITEM_DEFAULT, false}, {"prunejobs", store_bool, ITEM(res_job.PruneJobs), 0, ITEM_DEFAULT, false}, @@ -286,6 +314,7 @@ RES_ITEM job_items[] = { {"enabled", store_bool, ITEM(res_job.enabled), 0, ITEM_DEFAULT, true}, {"spoolattributes",store_bool, ITEM(res_job.SpoolAttributes), 0, ITEM_DEFAULT, false}, {"spooldata", store_bool, ITEM(res_job.spool_data), 0, ITEM_DEFAULT, false}, + {"spoolsize", store_size64, ITEM(res_job.spool_size), 0, 0, 0}, {"rerunfailedlevels", store_bool, ITEM(res_job.rerun_failed_levels), 0, ITEM_DEFAULT, false}, {"prefermountedvolumes", store_bool, ITEM(res_job.PreferMountedVolumes), 0, ITEM_DEFAULT, true}, {"runbeforejob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0}, @@ -293,15 +322,22 @@ RES_ITEM job_items[] = { {"runafterfailedjob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0}, {"clientrunbeforejob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0}, {"clientrunafterjob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0}, - {"maximumconcurrentjobs", store_pint, ITEM(res_job.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"maximumconcurrentjobs", store_pint32, ITEM(res_job.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, {"rescheduleonerror", store_bool, ITEM(res_job.RescheduleOnError), 0, ITEM_DEFAULT, false}, {"rescheduleinterval", store_time, ITEM(res_job.RescheduleInterval), 0, ITEM_DEFAULT, 60 * 30}, - {"rescheduletimes", store_pint, ITEM(res_job.RescheduleTimes), 0, 0, 0}, - {"priority", store_pint, ITEM(res_job.Priority), 0, ITEM_DEFAULT, 10}, - {"writepartafterjob", store_bool, ITEM(res_job.write_part_after_job), 0, ITEM_DEFAULT, true}, - {"selectionpattern", store_str, ITEM(res_job.selection_pattern), 0, 0, 0}, - {"selectiontype", store_migtype, ITEM(res_job.selection_type), 0, 0, 0}, - {"runscript", store_runscript, ITEM(res_job.RunScripts), 0, ITEM_NO_EQUALS, 0}, + {"rescheduletimes", store_pint32, ITEM(res_job.RescheduleTimes), 0, 0, 0}, + {"priority", store_pint32, ITEM(res_job.Priority), 0, ITEM_DEFAULT, 10}, + {"allowmixedpriority", store_bool, ITEM(res_job.allow_mixed_priority), 0, ITEM_DEFAULT, false}, + {"writepartafterjob", store_bool, ITEM(res_job.write_part_after_job), 0, ITEM_DEFAULT, true}, + {"selectionpattern", store_str, ITEM(res_job.selection_pattern), 0, 0, 0}, + {"runscript", store_runscript, ITEM(res_job.RunScripts), 0, ITEM_NO_EQUALS, 0}, + {"selectiontype", store_migtype, ITEM(res_job.selection_type), 0, 0, 0}, + {"accurate", store_bool, ITEM(res_job.accurate), 0,0,0}, + {"allowduplicatejobs", store_bool, ITEM(res_job.AllowDuplicateJobs), 0, ITEM_DEFAULT, false}, + {"allowhigherduplicates", store_bool, ITEM(res_job.AllowHigherDuplicates), 0, ITEM_DEFAULT, true}, + {"cancelqueuedduplicates", store_bool, ITEM(res_job.CancelQueuedDuplicates), 0, ITEM_DEFAULT, false}, + {"cancelrunningduplicates", store_bool, ITEM(res_job.CancelRunningDuplicates), 0, ITEM_DEFAULT, false}, + {"pluginoptions", store_str, ITEM(res_job.PluginOptions), 0, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -315,7 +351,7 @@ static RES_ITEM fs_items[] = { {"include", store_inc, {0}, 0, ITEM_NO_EQUALS, 0}, {"exclude", store_inc, {0}, 1, ITEM_NO_EQUALS, 0}, {"ignorefilesetchanges", store_bool, ITEM(res_fs.ignore_fs_changes), 0, ITEM_DEFAULT, false}, - {"enablevss", store_bool, ITEM(res_fs.enable_vss), 0, ITEM_DEFAULT, false}, + {"enablevss", store_bool, ITEM(res_fs.enable_vss), 0, ITEM_DEFAULT, true}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -347,20 +383,24 @@ static RES_ITEM pool_items[] = { {"purgeoldestvolume", store_bool, ITEM(res_pool.purge_oldest_volume), 0, 0, 0}, {"recycleoldestvolume", store_bool, ITEM(res_pool.recycle_oldest_volume), 0, 0, 0}, {"recyclecurrentvolume", store_bool, ITEM(res_pool.recycle_current_volume), 0, 0, 0}, - {"maximumvolumes", store_pint, ITEM(res_pool.max_volumes), 0, 0, 0}, - {"maximumvolumejobs", store_pint, ITEM(res_pool.MaxVolJobs), 0, 0, 0}, - {"maximumvolumefiles", store_pint, ITEM(res_pool.MaxVolFiles), 0, 0, 0}, - {"maximumvolumebytes", store_size, ITEM(res_pool.MaxVolBytes), 0, 0, 0}, + {"maximumvolumes", store_pint32, ITEM(res_pool.max_volumes), 0, 0, 0}, + {"maximumvolumejobs", store_pint32, ITEM(res_pool.MaxVolJobs), 0, 0, 0}, + {"maximumvolumefiles", store_pint32, ITEM(res_pool.MaxVolFiles), 0, 0, 0}, + {"maximumvolumebytes", store_size64, ITEM(res_pool.MaxVolBytes), 0, 0, 0}, {"catalogfiles", store_bool, ITEM(res_pool.catalog_files), 0, ITEM_DEFAULT, true}, {"volumeretention", store_time, ITEM(res_pool.VolRetention), 0, ITEM_DEFAULT, 60*60*24*365}, {"volumeuseduration", store_time, ITEM(res_pool.VolUseDuration), 0, 0, 0}, {"migrationtime", store_time, ITEM(res_pool.MigrationTime), 0, 0, 0}, - {"migrationhighbytes", store_size, ITEM(res_pool.MigrationHighBytes), 0, 0, 0}, - {"migrationlowbytes", store_size, ITEM(res_pool.MigrationLowBytes), 0, 0, 0}, + {"migrationhighbytes", store_size64, ITEM(res_pool.MigrationHighBytes), 0, 0, 0}, + {"migrationlowbytes", store_size64, ITEM(res_pool.MigrationLowBytes), 0, 0, 0}, {"nextpool", store_res, ITEM(res_pool.NextPool), R_POOL, 0, 0}, {"storage", store_alist_res, ITEM(res_pool.storage), R_STORAGE, 0, 0}, - {"autoprune", store_bool, ITEM(res_pool.AutoPrune), 0, ITEM_DEFAULT, true}, - {"recycle", store_bool, ITEM(res_pool.Recycle), 0, ITEM_DEFAULT, true}, + {"autoprune", store_bool, ITEM(res_pool.AutoPrune), 0, ITEM_DEFAULT, true}, + {"recycle", store_bool, ITEM(res_pool.Recycle), 0, ITEM_DEFAULT, true}, + {"recyclepool", store_res, ITEM(res_pool.RecyclePool), R_POOL, 0, 0}, + {"scratchpool", store_res, ITEM(res_pool.ScratchPool), R_POOL, 0, 0}, + {"copypool", store_alist_res, ITEM(res_pool.CopyPool), R_POOL, 0, 0}, + {"catalog", store_res, ITEM(res_pool.catalog), R_CATALOG, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -371,8 +411,8 @@ static RES_ITEM pool_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}, - {"maximum", store_pint, ITEM(res_counter.MaxValue), 0, ITEM_DEFAULT, INT32_MAX}, + {"minimum", store_int32, ITEM(res_counter.MinValue), 0, ITEM_DEFAULT, 0}, + {"maximum", store_pint32, ITEM(res_counter.MaxValue), 0, ITEM_DEFAULT, INT32_MAX}, {"wrapcounter", store_res, ITEM(res_counter.WrapCounter), R_COUNTER, 0, 0}, {"catalog", store_res, ITEM(res_counter.Catalog), R_CATALOG, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} @@ -419,6 +459,7 @@ struct s_jl joblevels[] = { {"Incremental", L_INCREMENTAL, JT_BACKUP}, {"Differential", L_DIFFERENTIAL, JT_BACKUP}, {"Since", L_SINCE, JT_BACKUP}, + {"VirtualFull", L_VIRTUAL_FULL, JT_BACKUP}, {"Catalog", L_VERIFY_CATALOG, JT_VERIFY}, {"InitCatalog", L_VERIFY_INIT, JT_VERIFY}, {"VolumeToCatalog", L_VERIFY_VOLUME_TO_CATALOG, JT_VERIFY}, @@ -439,6 +480,7 @@ struct s_jt jobtypes[] = { {"verify", JT_VERIFY}, {"restore", JT_RESTORE}, {"migrate", JT_MIGRATE}, + {"copy", JT_COPY}, {NULL, 0} }; @@ -452,6 +494,7 @@ struct s_jt migtypes[] = { {"oldestvolume", MT_OLDEST_VOL}, {"pooloccupancy", MT_POOL_OCCUPANCY}, {"pooltime", MT_POOL_TIME}, + {"pooluncopiedjobs", MT_POOL_UNCOPIED_JOBS}, {"client", MT_CLIENT}, {"volume", MT_VOLUME}, {"job", MT_JOB}, @@ -470,6 +513,16 @@ struct s_kw ReplaceOptions[] = { {NULL, 0} }; +char *CAT::display(POOLMEM *dst) { + Mmsg(dst,"catalog=%s\ndb_name=%s\ndb_driver=%s\ndb_user=%s\n" + "db_password=%s\ndb_address=%s\ndb_port=%i\n" + "db_socket=%s\n", + name(), NPRTB(db_name), + NPRTB(db_driver), NPRTB(db_user), NPRTB(db_password), + NPRTB(db_address), db_port, NPRTB(db_socket)); + return dst; +} + const char *level_to_str(int level) { int i; @@ -478,7 +531,7 @@ const char *level_to_str(int level) bsnprintf(level_no, sizeof(level_no), "%c (%d)", level, level); /* default if not found */ for (i=0; joblevels[i].level_name; i++) { - if (level == joblevels[i].level) { + if (level == (int)joblevels[i].level) { str = joblevels[i].level_name; break; } @@ -550,6 +603,7 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm dump_resource(-R_CATALOG, (RES *)res->res_client.catalog, sendit, sock); } break; + case R_DEVICE: dev = &res->res_dev; char ed1[50]; @@ -562,6 +616,7 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm edit_uint64(dev->PoolId, ed1), dev->VolumeName, dev->MediaType); break; + case R_STORAGE: sendit(sock, _("Storage: name=%s address=%s SDport=%d MaxJobs=%u\n" " DeviceName=%s MediaType=%s StorageId=%s\n"), @@ -571,13 +626,16 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm res->res_store.media_type, edit_int64(res->res_store.StorageId, ed1)); break; + case R_CATALOG: sendit(sock, _("Catalog: name=%s address=%s DBport=%d db_name=%s\n" -" db_user=%s MutliDBConn=%d\n"), +" db_driver=%s db_user=%s MutliDBConn=%d\n"), res->res_cat.hdr.name, NPRT(res->res_cat.db_address), - res->res_cat.db_port, res->res_cat.db_name, NPRT(res->res_cat.db_user), + res->res_cat.db_port, res->res_cat.db_name, + NPRT(res->res_cat.db_driver), NPRT(res->res_cat.db_user), res->res_cat.mult_db_connections); break; + case R_JOB: case R_JOBDEFS: sendit(sock, _("%s: name=%s JobType=%d level=%s Priority=%d Enabled=%d\n"), @@ -590,7 +648,13 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm res->res_job.RescheduleOnError, res->res_job.RescheduleTimes, edit_uint64_with_commas(res->res_job.RescheduleInterval, ed1), res->res_job.spool_data, res->res_job.write_part_after_job); - if (res->res_job.JobType == JT_MIGRATE) { + if (res->res_job.spool_size) { + sendit(sock, _(" SpoolSize=%s\n"), edit_uint64(res->res_job.spool_size, ed1)); + } + if (res->res_job.JobType == JT_BACKUP) { + sendit(sock, _(" Accurate=%d\n"), res->res_job.accurate); + } + if (res->res_job.JobType == JT_MIGRATE || res->res_job.JobType == JT_COPY) { sendit(sock, _(" SelectionType=%d\n"), res->res_job.selection_type); } if (res->res_job.client) { @@ -605,8 +669,11 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm sendit(sock, _(" --> ")); dump_resource(-R_SCHEDULE, (RES *)res->res_job.schedule, sendit, sock); } - if (res->res_job.RestoreWhere) { - sendit(sock, _(" --> Where=%s\n"), NPRT(res->res_job.RestoreWhere)); + if (res->res_job.RestoreWhere && !res->res_job.RegexWhere) { + sendit(sock, _(" --> Where=%s\n"), NPRT(res->res_job.RestoreWhere)); + } + if (res->res_job.RegexWhere) { + sendit(sock, _(" --> RegexWhere=%s\n"), NPRT(res->res_job.RegexWhere)); } if (res->res_job.RestoreBootstrap) { sendit(sock, _(" --> Bootstrap=%s\n"), NPRT(res->res_job.RestoreBootstrap)); @@ -614,6 +681,18 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm if (res->res_job.WriteBootstrap) { sendit(sock, _(" --> WriteBootstrap=%s\n"), NPRT(res->res_job.WriteBootstrap)); } + if (res->res_job.PluginOptions) { + sendit(sock, _(" --> PluginOptions=%s\n"), NPRT(res->res_job.PluginOptions)); + } + if (res->res_job.MaxRunTime) { + sendit(sock, _(" --> MaxRunTime=%u\n"), res->res_job.MaxRunTime); + } + if (res->res_job.MaxWaitTime) { + sendit(sock, _(" --> MaxWaitTime=%u\n"), res->res_job.MaxWaitTime); + } + if (res->res_job.MaxStartDelay) { + sendit(sock, _(" --> MaxStartDelay=%u\n"), res->res_job.MaxStartDelay); + } if (res->res_job.storage) { STORE *store; foreach_alist(store, res->res_job.storage) { @@ -629,7 +708,7 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm sendit(sock, _(" --> Target=%s\n"), NPRT(script->target)); sendit(sock, _(" --> RunOnSuccess=%u\n"), script->on_success); sendit(sock, _(" --> RunOnFailure=%u\n"), script->on_failure); - sendit(sock, _(" --> AbortJobOnError=%u\n"), script->abort_on_error); + sendit(sock, _(" --> FailJobOnError=%u\n"), script->fail_on_error); sendit(sock, _(" --> RunWhen=%u\n"), script->when); } } @@ -667,6 +746,7 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm dump_resource(-R_MSGS, (RES *)res->res_job.messages, sendit, sock); } break; + case R_FILESET: { int i, j, k; @@ -715,6 +795,9 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm for (k=0; kdrivetype.size(); k++) { sendit(sock, " XD %s\n", fo->drivetype.get(k)); } + if (fo->plugin) { + sendit(sock, " G %s\n", fo->plugin); + } if (fo->reader) { sendit(sock, " D %s\n", fo->reader); } @@ -723,12 +806,22 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm } sendit(sock, " N\n"); } + if (incexe->ignoredir) { + sendit(sock, " Z %s\n", incexe->ignoredir); + } for (j=0; jname_list.size(); j++) { sendit(sock, " I %s\n", incexe->name_list.get(j)); } if (incexe->name_list.size()) { sendit(sock, " N\n"); } + for (j=0; jplugin_list.size(); j++) { + sendit(sock, " P %s\n", incexe->plugin_list.get(j)); + } + if (incexe->plugin_list.size()) { + sendit(sock, " N\n"); + } + } for (i=0; ires_fs.num_excludes; i++) { @@ -742,6 +835,7 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm } break; } + case R_SCHEDULE: if (res->res_sch.run) { int i; @@ -829,6 +923,7 @@ next_run: sendit(sock, _("Schedule: name=%s\n"), res->res_sch.hdr.name); } break; + case R_POOL: sendit(sock, _("Pool: name=%s PoolType=%s\n"), res->res_pool.hdr.name, res->res_pool.pool_type); @@ -844,17 +939,28 @@ next_run: NPRT(res->res_pool.label_format)); sendit(sock, _(" CleaningPrefix=%s LabelType=%d\n"), NPRT(res->res_pool.cleaning_prefix), res->res_pool.LabelType); - sendit(sock, _(" RecyleOldest=%d PurgeOldest=%d MaxVolJobs=%d MaxVolFiles=%d\n"), + sendit(sock, _(" RecyleOldest=%d PurgeOldest=%d\n"), res->res_pool.recycle_oldest_volume, - res->res_pool.purge_oldest_volume, - res->res_pool.MaxVolJobs, res->res_pool.MaxVolFiles); + res->res_pool.purge_oldest_volume); + sendit(sock, _(" MaxVolJobs=%d MaxVolFiles=%d MaxVolBytes=%s\n"), + res->res_pool.MaxVolJobs, + res->res_pool.MaxVolFiles, + edit_uint64(res->res_pool.MaxVolBytes, ed1)); sendit(sock, _(" MigTime=%s MigHiBytes=%s MigLoBytes=%s\n"), edit_utime(res->res_pool.MigrationTime, ed1, sizeof(ed1)), edit_uint64(res->res_pool.MigrationHighBytes, ed2), edit_uint64(res->res_pool.MigrationLowBytes, ed3)); if (res->res_pool.NextPool) { - sendit(sock, _(" --> ")); - dump_resource(-R_POOL, (RES *)res->res_pool.NextPool, sendit, sock); + sendit(sock, _(" NextPool=%s\n"), res->res_pool.NextPool->name()); + } + if (res->res_pool.RecyclePool) { + sendit(sock, _(" RecyclePool=%s\n"), res->res_pool.RecyclePool->name()); + } + if (res->res_pool.ScratchPool) { + sendit(sock, _(" ScratchPool=%s\n"), res->res_pool.ScratchPool->name()); + } + if (res->res_pool.catalog) { + sendit(sock, _(" Catalog=%s\n"), res->res_pool.catalog->name()); } if (res->res_pool.storage) { STORE *store; @@ -863,7 +969,16 @@ next_run: dump_resource(-R_STORAGE, (RES *)store, sendit, sock); } } + if (res->res_pool.CopyPool) { + POOL *copy; + foreach_alist(copy, res->res_pool.CopyPool) { + sendit(sock, _(" --> ")); + dump_resource(-R_POOL, (RES *)copy, sendit, sock); + } + } + break; + case R_MSGS: sendit(sock, _("Messages: name=%s\n"), res->res_msgs.hdr.name); if (res->res_msgs.mail_cmd) @@ -871,6 +986,7 @@ next_run: if (res->res_msgs.operator_cmd) sendit(sock, _(" opcmd=%s\n"), res->res_msgs.operator_cmd); break; + default: sendit(sock, _("Unknown resource type %d in dump_resource.\n"), type); break; @@ -886,6 +1002,7 @@ next_run: static void free_incexe(INCEXE *incexe) { incexe->name_list.destroy(); + incexe->plugin_list.destroy(); for (int i=0; inum_opts; i++) { FOPTS *fopt = incexe->opts_list[i]; fopt->regex.destroy(); @@ -898,6 +1015,9 @@ static void free_incexe(INCEXE *incexe) fopt->base.destroy(); fopt->fstype.destroy(); fopt->drivetype.destroy(); + if (fopt->plugin) { + free(fopt->plugin); + } if (fopt->reader) { free(fopt->reader); } @@ -909,6 +1029,9 @@ static void free_incexe(INCEXE *incexe) if (incexe->opts_list) { free(incexe->opts_list); } + if (incexe->ignoredir) { + free(incexe->ignoredir); + } free(incexe); } @@ -945,6 +1068,9 @@ void free_resource(RES *sres, int type) if (res->res_dir.scripts_directory) { free((char *)res->res_dir.scripts_directory); } + if (res->res_dir.plugin_directory) { + free((char *)res->res_dir.plugin_directory); + } if (res->res_dir.pid_directory) { free(res->res_dir.pid_directory); } @@ -960,6 +1086,9 @@ void free_resource(RES *sres, int type) if (res->res_dir.DIRaddrs) { free_addresses(res->res_dir.DIRaddrs); } + if (res->res_dir.DIRsrc_addr) { + free_addresses(res->res_dir.DIRsrc_addr); + } if (res->res_dir.tls_ctx) { free_tls_context(res->res_dir.tls_ctx); } @@ -981,6 +1110,9 @@ void free_resource(RES *sres, int type) if (res->res_dir.tls_allowed_cns) { delete res->res_dir.tls_allowed_cns; } + if (res->res_dir.verid) { + free(res->res_dir.verid); + } break; case R_DEVICE: case R_COUNTER: @@ -1039,6 +1171,9 @@ void free_resource(RES *sres, int type) if (res->res_client.tls_keyfile) { free(res->res_client.tls_keyfile); } + if (res->res_client.tls_allowed_cns) { + delete res->res_client.tls_allowed_cns; + } break; case R_STORAGE: if (res->res_store.address) { @@ -1082,6 +1217,9 @@ void free_resource(RES *sres, int type) if (res->res_cat.db_name) { free(res->res_cat.db_name); } + if (res->res_cat.db_driver) { + free(res->res_cat.db_driver); + } if (res->res_cat.db_password) { free(res->res_cat.db_password); } @@ -1132,12 +1270,27 @@ void free_resource(RES *sres, int type) if (res->res_job.RestoreWhere) { free(res->res_job.RestoreWhere); } + if (res->res_job.RegexWhere) { + free(res->res_job.RegexWhere); + } + if (res->res_job.strip_prefix) { + free(res->res_job.strip_prefix); + } + if (res->res_job.add_prefix) { + free(res->res_job.add_prefix); + } + if (res->res_job.add_suffix) { + free(res->res_job.add_suffix); + } if (res->res_job.RestoreBootstrap) { free(res->res_job.RestoreBootstrap); } if (res->res_job.WriteBootstrap) { free(res->res_job.WriteBootstrap); } + if (res->res_job.PluginOptions) { + free(res->res_job.PluginOptions); + } if (res->res_job.selection_pattern) { free(res->res_job.selection_pattern); } @@ -1245,7 +1398,10 @@ void save_resource(int type, RES_ITEM *items, int pass) } /* Explicitly copy resource pointers from this pass (res_all) */ res->res_pool.NextPool = res_all.res_pool.NextPool; + res->res_pool.RecyclePool = res_all.res_pool.RecyclePool; + res->res_pool.ScratchPool = res_all.res_pool.ScratchPool; res->res_pool.storage = res_all.res_pool.storage; + res->res_pool.catalog = res_all.res_pool.catalog; break; case R_CONSOLE: if ((res = (URES *)GetResWithName(R_CONSOLE, res_all.res_con.hdr.name)) == NULL) { @@ -1287,6 +1443,36 @@ void save_resource(int type, RES_ITEM *items, int pass) res->res_job.jobdefs = res_all.res_job.jobdefs; res->res_job.run_cmds = res_all.res_job.run_cmds; res->res_job.RunScripts = res_all.res_job.RunScripts; + + /* TODO: JobDefs where/regexwhere doesn't work well (but this + * is not very useful) + * We have to set_bit(index, res_all.hdr.item_present); + * or something like that + */ + + /* we take RegexWhere before all other options */ + if (!res->res_job.RegexWhere + && + (res->res_job.strip_prefix || + res->res_job.add_suffix || + res->res_job.add_prefix)) + { + int len = bregexp_get_build_where_size(res->res_job.strip_prefix, + res->res_job.add_prefix, + res->res_job.add_suffix); + res->res_job.RegexWhere = (char *) bmalloc (len * sizeof(char)); + bregexp_build_where(res->res_job.RegexWhere, len, + res->res_job.strip_prefix, + res->res_job.add_prefix, + res->res_job.add_suffix); + /* TODO: test bregexp */ + } + + if (res->res_job.RegexWhere && res->res_job.RestoreWhere) { + free(res->res_job.RestoreWhere); + res->res_job.RestoreWhere = NULL; + } + break; case R_COUNTER: if ((res = (URES *)GetResWithName(R_COUNTER, res_all.res_counter.hdr.name)) == NULL) { @@ -1301,6 +1487,7 @@ void save_resource(int type, RES_ITEM *items, int pass) Emsg1(M_ERROR_TERM, 0, _("Cannot find Client resource %s\n"), res_all.res_client.hdr.name); } res->res_client.catalog = res_all.res_client.catalog; + res->res_client.tls_allowed_cns = res_all.res_client.tls_allowed_cns; break; case R_SCHEDULE: /* @@ -1375,7 +1562,7 @@ void save_resource(int type, RES_ITEM *items, int pass) error = true; break; default: - printf(_("Unknown resource type %d in save_resrouce.\n"), type); + printf(_("Unknown resource type %d in save_resource.\n"), type); error = true; break; } @@ -1388,20 +1575,21 @@ void save_resource(int type, RES_ITEM *items, int pass) Dmsg3(900, "Inserting first %s res: %s index=%d\n", res_to_str(type), res->res_dir.hdr.name, rindex); } else { - RES *next; + RES *next, *last; if (res->res_dir.hdr.name == NULL) { Emsg1(M_ERROR_TERM, 0, _("Name item is required in %s resource, but not found.\n"), resources[rindex]); } /* Add new res to end of chain */ - for (next=res_head[rindex]; next->next; next=next->next) { + for (last=next=res_head[rindex]; next; next=next->next) { + last = next; if (strcmp(next->name, res->res_dir.hdr.name) == 0) { Emsg2(M_ERROR_TERM, 0, _("Attempt to define second %s resource named \"%s\" is not permitted.\n"), resources[rindex].name, res->res_dir.hdr.name); } } - next->next = (RES *)res; + last->next = (RES *)res; Dmsg4(900, _("Inserting %s res: %s index=%d pass=%d\n"), res_to_str(type), res->res_dir.hdr.name, rindex, pass); } @@ -1457,10 +1645,10 @@ static void store_device(LEX *lc, RES_ITEM *item, int index, int pass) } /* - * Store JobType (backup, verify, restore) + * Store Migration/Copy type * */ -static void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass) +void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass) { int token, i; @@ -1468,7 +1656,7 @@ static void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass) /* Store the type both pass 1 and pass 2 */ for (i=0; migtypes[i].type_name; i++) { if (strcasecmp(lc->str, migtypes[i].type_name) == 0) { - *(int *)(item->value) = migtypes[i].job_type; + *(uint32_t *)(item->value) = migtypes[i].job_type; i = 0; break; } @@ -1494,7 +1682,7 @@ void store_jobtype(LEX *lc, RES_ITEM *item, int index, int pass) /* Store the type both pass 1 and pass 2 */ for (i=0; jobtypes[i].type_name; i++) { if (strcasecmp(lc->str, jobtypes[i].type_name) == 0) { - *(int *)(item->value) = jobtypes[i].job_type; + *(uint32_t *)(item->value) = jobtypes[i].job_type; i = 0; break; } @@ -1518,7 +1706,7 @@ void store_level(LEX *lc, RES_ITEM *item, int index, int pass) /* Store the level pass 2 so that type is defined */ for (i=0; joblevels[i].level_name; i++) { if (strcasecmp(lc->str, joblevels[i].level_name) == 0) { - *(int *)(item->value) = joblevels[i].level; + *(uint32_t *)(item->value) = joblevels[i].level; i = 0; break; } @@ -1538,7 +1726,7 @@ void store_replace(LEX *lc, RES_ITEM *item, int index, int pass) /* Scan Replacement options */ for (i=0; ReplaceOptions[i].name; i++) { if (strcasecmp(lc->str, ReplaceOptions[i].name) == 0) { - *(int *)(item->value) = ReplaceOptions[i].token; + *(uint32_t *)(item->value) = ReplaceOptions[i].token; i = 0; break; } @@ -1586,13 +1774,15 @@ static void store_runscript_when(LEX *lc, RES_ITEM *item, int index, int pass) lex_get_token(lc, T_NAME); if (strcasecmp(lc->str, "before") == 0) { - *(int *)(item->value) = SCRIPT_Before ; + *(uint32_t *)(item->value) = SCRIPT_Before ; } else if (strcasecmp(lc->str, "after") == 0) { - *(int *)(item->value) = SCRIPT_After; + *(uint32_t *)(item->value) = SCRIPT_After; + } else if (strcasecmp(lc->str, "aftervss") == 0) { + *(uint32_t *)(item->value) = SCRIPT_AfterVSS; } else if (strcasecmp(lc->str, "always") == 0) { - *(int *)(item->value) = SCRIPT_Any; + *(uint32_t *)(item->value) = SCRIPT_Any; } else { - scan_err2(lc, _("Expect %s, got: %s"), "Before, After or Always", lc->str); + scan_err2(lc, _("Expect %s, got: %s"), "Before, After, AfterVSS or Always", lc->str); } scan_to_eol(lc); } @@ -1607,9 +1797,9 @@ static void store_runscript_target(LEX *lc, RES_ITEM *item, int index, int pass) if (pass == 2) { if (strcmp(lc->str, "%c") == 0) { ((RUNSCRIPT*) item->value)->set_target(lc->str); - } else if (strcmp(lc->str, "yes") == 0) { + } else if (strcasecmp(lc->str, "yes") == 0) { ((RUNSCRIPT*) item->value)->set_target("%c"); - } else if (strcmp(lc->str, "no") == 0) { + } else if (strcasecmp(lc->str, "no") == 0) { ((RUNSCRIPT*) item->value)->set_target(""); } else { RES *res = GetResWithName(R_CLIENT, lc->str); @@ -1624,15 +1814,20 @@ static void store_runscript_target(LEX *lc, RES_ITEM *item, int index, int pass) scan_to_eol(lc); } -/* Store a runscript->command in a bit field - * +/* + * Store a runscript->command as a string and runscript->cmd_type as a pointer */ static void store_runscript_cmd(LEX *lc, RES_ITEM *item, int index, int pass) { lex_get_token(lc, T_STRING); if (pass == 2) { - ((RUNSCRIPT*) item->value)->set_command(lc->str); + Dmsg2(1, "runscript cmd=%s type=%c\n", lc->str, item->code); + POOLMEM *c = get_pool_memory(PM_FNAME); + /* Each runscript command takes 2 entries in commands list */ + pm_strcpy(c, lc->str); + ((RUNSCRIPT*) item->value)->commands->prepend(c); /* command line */ + ((RUNSCRIPT*) item->value)->commands->prepend((void *)item->code); /* command type */ } scan_to_eol(lc); } @@ -1644,6 +1839,7 @@ static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass) if (pass == 2) { RUNSCRIPT *script = new_runscript(); + script->set_job_code_callback(job_code_callback_filesetname); script->set_command(lc->str); @@ -1651,7 +1847,7 @@ static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass) if (strcmp(item->name, "runbeforejob") == 0) { script->when = SCRIPT_Before; - script->abort_on_error = true; + script->fail_on_error = true; script->set_target(""); } else if (strcmp(item->name, "runafterjob") == 0) { @@ -1671,7 +1867,7 @@ static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass) script->old_proto = true; script->when = SCRIPT_Before; script->set_target("%c"); - script->abort_on_error = true; + script->fail_on_error = true; } else if (strcmp(item->name, "runafterfailedjob") == 0) { script->when = SCRIPT_After; @@ -1691,19 +1887,37 @@ static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass) scan_to_eol(lc); } +/* Store a bool in a bit field without modifing res_all.hdr + * We can also add an option to store_bool to skip res_all.hdr + */ +void store_runscript_bool(LEX *lc, RES_ITEM *item, int index, int pass) +{ + lex_get_token(lc, T_NAME); + if (strcasecmp(lc->str, "yes") == 0 || strcasecmp(lc->str, "true") == 0) { + *(bool *)(item->value) = true; + } else if (strcasecmp(lc->str, "no") == 0 || strcasecmp(lc->str, "false") == 0) { + *(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 */ + } + scan_to_eol(lc); +} + /* * new RunScript items - * name handler value code flags default_value + * name handler value code flags default_value */ static RES_ITEM runscript_items[] = { - {"command", store_runscript_cmd, {(char **)&res_runscript}, 0, ITEM_REQUIRED, 0}, - {"target", store_runscript_target, {(char **)&res_runscript}, 0, 0, 0}, - {"runsonsuccess", store_bool, {(char **)&res_runscript.on_success}, 0, 0, 0}, - {"runsonfailure", store_bool, {(char **)&res_runscript.on_failure}, 0, 0, 0}, - {"abortjobonerror", store_bool, {(char **)&res_runscript.abort_on_error}, 0, 0, 0}, - {"runswhen", store_runscript_when, {(char **)&res_runscript.when}, 0, 0, 0}, - {"runsonclient", store_runscript_target, {(char **)&res_runscript}, 0, 0, 0}, /* TODO */ - {NULL, NULL, {0}, 0, 0, 0} + {"command", store_runscript_cmd, {(char **)&res_runscript}, SHELL_CMD, 0, 0}, + {"console", store_runscript_cmd, {(char **)&res_runscript}, CONSOLE_CMD, 0, 0}, + {"target", store_runscript_target,{(char **)&res_runscript}, 0, 0, 0}, + {"runsonsuccess", store_runscript_bool, {(char **)&res_runscript.on_success},0, 0, 0}, + {"runsonfailure", store_runscript_bool, {(char **)&res_runscript.on_failure},0, 0, 0}, + {"failjobonerror",store_runscript_bool, {(char **)&res_runscript.fail_on_error},0, 0, 0}, + {"abortjobonerror",store_runscript_bool, {(char **)&res_runscript.fail_on_error},0, 0, 0}, + {"runswhen", store_runscript_when, {(char **)&res_runscript.when}, 0, 0, 0}, + {"runsonclient", store_runscript_target,{(char **)&res_runscript}, 0, 0, 0}, /* TODO */ + {NULL, NULL, {0}, 0, 0, 0} }; /* @@ -1715,19 +1929,24 @@ static RES_ITEM runscript_items[] = { */ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) { - int token, i; + char *c; + int token, i, t; alist **runscripts = (alist **)(item->value) ; Dmsg1(200, "store_runscript: begin store_runscript pass=%i\n", pass); - res_runscript.reset_default(); /* setting on_success, on_failure, abort_on_error */ - token = lex_get_token(lc, T_SKIP_EOL); if (token != T_BOB) { scan_err1(lc, _("Expecting open brace. Got %s"), lc->str); } - + /* setting on_success, on_failure, fail_on_error */ + res_runscript.reset_default(); + + if (pass == 2) { + res_runscript.commands = New(alist(10, not_owned_by_alist)); + } + while ((token = lex_get_token(lc, T_SKIP_EOL)) != T_EOF) { if (token == T_EOB) { break; @@ -1755,27 +1974,56 @@ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) } if (pass == 2) { - if (res_runscript.command == NULL) { - scan_err2(lc, _("%s item is required in %s resource, but not found.\n"), - "command", "runscript"); - } - /* run on client by default */ if (res_runscript.target == NULL) { res_runscript.set_target("%c"); } - - RUNSCRIPT *script = new_runscript(); - memcpy(script, &res_runscript, sizeof(RUNSCRIPT)); - if (*runscripts == NULL) { - *runscripts = New(alist(10, not_owned_by_alist)); + *runscripts = New(alist(10, not_owned_by_alist)); } - - (*runscripts)->append(script); - script->debug(); + /* + * commands list contains 2 values per command + * - POOLMEM command string (ex: /bin/true) + * - int command type (ex: SHELL_CMD) + */ + res_runscript.set_job_code_callback(job_code_callback_filesetname); + while ((c=(char*)res_runscript.commands->pop()) != NULL) { + t = (intptr_t)res_runscript.commands->pop(); + RUNSCRIPT *script = new_runscript(); + memcpy(script, &res_runscript, sizeof(RUNSCRIPT)); + script->command = c; + script->cmd_type = t; + /* target is taken from res_runscript, each runscript object have + * a copy + */ + script->target = NULL; + script->set_target(res_runscript.target); + + (*runscripts)->append(script); + script->debug(); + } + delete res_runscript.commands; + /* setting on_success, on_failure... cleanup target field */ + res_runscript.reset_default(true); } scan_to_eol(lc); set_bit(index, res_all.hdr.item_present); } + +/* callback function for edit_job_codes */ +extern "C" char *job_code_callback_filesetname(JCR *jcr, const char* param) +{ + if (param[0] == 'f') { + return jcr->fileset->name(); + } else { + return NULL; + } +} + +bool parse_dir_config(CONFIG *config, const char *configfile, int exit_code) +{ + config->init(configfile, NULL, exit_code, (void *)&res_all, res_all_size, + r_first, r_last, resources, res_head); + return config->parse_config(); +}