X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fdird%2Fdird_conf.c;h=23cd6cbe4313bfb661f911a9e91981d3c15cbacf;hb=e3391c1a4f17d7143b853eee76ff8e18557f3b80;hp=a50001a0c6e14a97e5ebcb9627ede4f5c815d924;hpb=806c784046527b7a1c6d0b55928bc3360cd2d816;p=bacula%2Fbacula diff --git a/bacula/src/dird/dird_conf.c b/bacula/src/dird/dird_conf.c index a50001a0c6..23cd6cbe43 100644 --- a/bacula/src/dird/dird_conf.c +++ b/bacula/src/dird/dird_conf.c @@ -1,29 +1,20 @@ /* - Bacula® - The Network Backup Solution - - Copyright (C) 2000-2008 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 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. + Bacula(R) - The Network Backup Solution + + Copyright (C) 2000-2015 Kern Sibbald + + The original author of Bacula is Kern Sibbald, with contributions + from many others, a complete list can be found in the file AUTHORS. + + You may use this file and others of this release according to the + license defined in the LICENSE file, which includes the Affero General + Public License, v3.0 ("AGPLv3") and some additional permissions and + terms pursuant to its AGPLv3 Section 7. + + This notice must be preserved when any source code is + conveyed and/or propagated. + + Bacula(R) is a registered trademark of Kern Sibbald. */ /* * Main configuration file parser for Bacula Directors, @@ -46,7 +37,6 @@ * * Kern Sibbald, January MM * - * Version $Id$ */ @@ -57,8 +47,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; @@ -76,7 +66,7 @@ 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_runscript(LEX *lc, RES_ITEM *item, int index, int pass); +void store_actiononpurge(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); static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass); @@ -88,17 +78,17 @@ 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 +/* + * Definition of records permitted within each * resource with the routine to process the record - * information. NOTE! quoted names must be in lower case. + * information. */ /* * Director Resource @@ -106,33 +96,38 @@ int res_all_size = sizeof(res_all); * name handler value code flags default_value */ 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}, - {"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}, - {"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}, - {"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}, - {"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}, - {"tlscacertificatefile", store_dir, ITEM(res_dir.tls_ca_certfile), 0, 0, 0}, - {"tlscacertificatedir", store_dir, ITEM(res_dir.tls_ca_certdir), 0, 0, 0}, - {"tlscertificate", store_dir, ITEM(res_dir.tls_certfile), 0, 0, 0}, - {"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}, + {"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}, + {"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_pint32, ITEM(res_dir.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"MaximumReloadRequests", store_pint32, ITEM(res_dir.MaxReload), 0, ITEM_DEFAULT, 32}, + {"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, 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, 5 * 60}, + {"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}, + {"TlsCaCertificateFile", store_dir, ITEM(res_dir.tls_ca_certfile), 0, 0, 0}, + {"TlsCaCertificateDir", store_dir, ITEM(res_dir.tls_ca_certdir), 0, 0, 0}, + {"TlsCertificate", store_dir, ITEM(res_dir.tls_certfile), 0, 0, 0}, + {"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} }; @@ -142,30 +137,30 @@ static RES_ITEM dir_items[] = { * name handler value code flags default_value */ 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}, - {"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}, - {"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}, - {"tlscacertificatefile", store_dir, ITEM(res_con.tls_ca_certfile), 0, 0, 0}, - {"tlscacertificatedir", store_dir, ITEM(res_con.tls_ca_certdir), 0, 0, 0}, - {"tlscertificate", store_dir, ITEM(res_con.tls_certfile), 0, 0, 0}, - {"tlskey", store_dir, ITEM(res_con.tls_keyfile), 0, 0, 0}, - {"tlsdhfile", store_dir, ITEM(res_con.tls_dhfile), 0, 0, 0}, - {"tlsallowedcn", store_alist_str, ITEM(res_con.tls_allowed_cns), 0, 0, 0}, + {"Name", store_name, ITEM(res_con.hdr.name), 0, ITEM_REQUIRED, 0}, + {"Description", store_str, ITEM(res_con.hdr.desc), 0, 0, 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}, + {"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}, + {"TlsCaCertificateFile", store_dir, ITEM(res_con.tls_ca_certfile), 0, 0, 0}, + {"TlsCaCertificateDir", store_dir, ITEM(res_con.tls_ca_certdir), 0, 0, 0}, + {"TlsCertificate", store_dir, ITEM(res_con.tls_certfile), 0, 0, 0}, + {"TlsKey", store_dir, ITEM(res_con.tls_keyfile), 0, 0, 0}, + {"TlsDhFile", store_dir, ITEM(res_con.tls_dhfile), 0, 0, 0}, + {"TlsAllowedCn", store_alist_str, ITEM(res_con.tls_allowed_cns), 0, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -177,27 +172,32 @@ static RES_ITEM con_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", store_name, ITEM(res_client.hdr.name), 0, ITEM_REQUIRED, 0}, + {"Description", store_str, ITEM(res_client.hdr.desc), 0, 0, 0}, {"fdaddress", store_str, ITEM(res_client.address), 0, 0, 0}, - {"fdport", store_pint, 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}, - {"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}, - {"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}, + {"Address", store_str, ITEM(res_client.address), 0, ITEM_REQUIRED, 0}, + {"FdPort", store_pint32, ITEM(res_client.FDport), 0, ITEM_DEFAULT, 9102}, + {"fdpassword", store_password, ITEM(res_client.password), 0, 0, 0}, + {"Password", store_password, ITEM(res_client.password), 0, ITEM_REQUIRED, 0}, + {"FdStorageAddress", store_str, ITEM(res_client.fd_storage_address), 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, 5 * 60}, + {"AutoPrune", store_bool, ITEM(res_client.AutoPrune), 0, ITEM_DEFAULT, true}, + {"SDCallsClient", store_bool, ITEM(res_client.sd_calls_client), 0, ITEM_DEFAULT, false}, + {"SnapshotRetention", store_time, ITEM(res_client.SnapRetention), 0, ITEM_DEFAULT, 0}, + {"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}, + {"MaximumBandwidthPerJob", store_speed, ITEM(res_client.max_bandwidth), 0, 0, 0}, + {"Enabled", store_bool, ITEM(res_client.enabled), 0, ITEM_DEFAULT, true}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -206,27 +206,30 @@ static RES_ITEM cli_items[] = { * name handler value code flags default_value */ 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}, - {"address", store_str, ITEM(res_store.address), 0, ITEM_REQUIRED, 0}, + {"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_pint32, ITEM(res_store.SDport), 0, ITEM_DEFAULT, 9103}, {"sdaddress", store_str, ITEM(res_store.address), 0, 0, 0}, - {"password", store_password, ITEM(res_store.password), 0, ITEM_REQUIRED, 0}, + {"Address", store_str, ITEM(res_store.address), 0, ITEM_REQUIRED, 0}, + {"FdStorageAddress", store_str, ITEM(res_store.fd_storage_address), 0, 0, 0}, {"sdpassword", store_password, ITEM(res_store.password), 0, 0, 0}, - {"device", store_device, ITEM(res_store.device), R_DEVICE, ITEM_REQUIRED, 0}, - {"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}, - {"heartbeatinterval", store_time, ITEM(res_store.heartbeat_interval), 0, ITEM_DEFAULT, 0}, - {"maximumconcurrentjobs", store_pint, ITEM(res_store.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, - {"sddport", store_pint, 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}, - {"tlscacertificatedir", store_dir, ITEM(res_store.tls_ca_certdir), 0, 0, 0}, - {"tlscertificate", store_dir, ITEM(res_store.tls_certfile), 0, 0, 0}, - {"tlskey", store_dir, ITEM(res_store.tls_keyfile), 0, 0, 0}, + {"Password", store_password, ITEM(res_store.password), 0, ITEM_REQUIRED, 0}, + {"Device", store_device, ITEM(res_store.device), R_DEVICE, ITEM_REQUIRED, 0}, + {"MediaType", store_strname, ITEM(res_store.media_type), 0, ITEM_REQUIRED, 0}, + {"Autochanger", store_bool, ITEM(res_store.autochanger), 0, ITEM_DEFAULT, false}, + {"Enabled", store_bool, ITEM(res_store.enabled), 0, ITEM_DEFAULT, true}, + {"AllowCompression", store_bool, ITEM(res_store.AllowCompress), 0, ITEM_DEFAULT, true}, + {"HeartbeatInterval", store_time, ITEM(res_store.heartbeat_interval), 0, ITEM_DEFAULT, 5 * 60}, + {"MaximumConcurrentJobs", store_pint32, ITEM(res_store.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"MaximumConcurrentReadjobs", store_pint32, ITEM(res_store.MaxConcurrentReadJobs), 0, ITEM_DEFAULT, 0}, + {"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}, + {"TlsCaCertificateDir", store_dir, ITEM(res_store.tls_ca_certdir), 0, 0, 0}, + {"TlsCertificate", store_dir, ITEM(res_store.tls_certfile), 0, 0, 0}, + {"TlsKey", store_dir, ITEM(res_store.tls_keyfile), 0, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -236,20 +239,22 @@ static RES_ITEM store_items[] = { * name handler value code flags default_value */ 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", store_name, ITEM(res_cat.hdr.name), 0, ITEM_REQUIRED, 0}, + {"Description", store_str, ITEM(res_cat.hdr.desc), 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}, + {"Address", store_str, ITEM(res_cat.db_address), 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}, - {"user", store_str, ITEM(res_cat.db_user), 0, 0, 0}, - {"dbname", store_str, ITEM(res_cat.db_name), 0, ITEM_REQUIRED, 0}, + {"Password", 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}, + {"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}, + {"MultipleConnections", store_bit, ITEM(res_cat.mult_db_connections), 0, 0, 0}, + {"DisableBatchInsert", store_bool, ITEM(res_cat.disable_batch_insert), 0, ITEM_DEFAULT, false}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -259,89 +264,102 @@ static RES_ITEM cat_items[] = { * name handler value code flags default_value */ 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}, - {"level", store_level, ITEM(res_job.JobLevel), 0, 0, 0}, - {"messages", store_res, ITEM(res_job.messages), R_MSGS, ITEM_REQUIRED, 0}, - {"storage", store_alist_res, ITEM(res_job.storage), R_STORAGE, 0, 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.diff_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}, - {"verifyjob", store_res, ITEM(res_job.verify_job), R_JOB, 0, 0}, - {"jobtoverify", store_res, ITEM(res_job.verify_job), R_JOB, 0, 0}, - {"jobdefs", store_res, ITEM(res_job.jobdefs), R_JOBDEFS, 0, 0}, - {"run", store_alist_str, ITEM(res_job.run_cmds), 0, 0, 0}, + {"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}, + {"Level", store_level, ITEM(res_job.JobLevel), 0, 0, 0}, + {"Messages", store_res, ITEM(res_job.messages), R_MSGS, ITEM_REQUIRED, 0}, + {"Storage", store_alist_res, ITEM(res_job.storage), R_STORAGE, 0, 0}, + {"Pool", store_res, ITEM(res_job.pool), R_POOL, ITEM_REQUIRED, 0}, + {"NextPool", store_res, ITEM(res_job.next_pool), R_POOL, 0, 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.diff_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}, + {"VerifyJob", store_res, ITEM(res_job.verify_job), R_JOB, 0, 0}, + {"JobToVerify", store_res, ITEM(res_job.verify_job), R_JOB, 0, 0}, + {"JobDefs", store_res, ITEM(res_job.jobdefs), R_JOBDEFS, 0, 0}, + {"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", 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}, + {"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}, - {"replace", store_replace, ITEM(res_job.replace), 0, ITEM_DEFAULT, REPLACE_ALWAYS}, - {"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}, - {"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}, - {"prunefiles", store_bool, ITEM(res_job.PruneFiles), 0, ITEM_DEFAULT, false}, - {"prunevolumes",store_bool, ITEM(res_job.PruneVolumes), 0, ITEM_DEFAULT, false}, - {"enabled", store_bool, ITEM(res_job.enabled), 0, ITEM_DEFAULT, true}, - {"optimizejobscheduling",store_bool, ITEM(res_job.OptimizeJobScheduling), 0, ITEM_DEFAULT, false}, - {"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_size, 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}, + {"WriteBootstrap",store_dir, ITEM(res_job.WriteBootstrap), 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}, + {"MaximumBandwidth", store_speed, ITEM(res_job.max_bandwidth), 0, 0, 0}, + {"MaxRunSchedTime", store_time, ITEM(res_job.MaxRunSchedTime), 0, 0, 0}, + {"MaxRunTime", store_time, ITEM(res_job.MaxRunTime), 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}, + {"PrefixLinks", store_bool, ITEM(res_job.PrefixLinks), 0, ITEM_DEFAULT, false}, + {"PruneJobs", store_bool, ITEM(res_job.PruneJobs), 0, ITEM_DEFAULT, false}, + {"PruneFiles", store_bool, ITEM(res_job.PruneFiles), 0, ITEM_DEFAULT, false}, + {"PruneVolumes",store_bool, ITEM(res_job.PruneVolumes), 0, ITEM_DEFAULT, false}, + {"PurgeMigrationJob", store_bool, ITEM(res_job.PurgeMigrateJob), 0, ITEM_DEFAULT, false}, + {"Enabled", store_bool, ITEM(res_job.enabled), 0, ITEM_DEFAULT, true}, + {"SnapshotRetention", store_time, ITEM(res_job.SnapRetention), 0, ITEM_DEFAULT, 0}, + {"SpoolAttributes",store_bool, ITEM(res_job.SpoolAttributes), 0, ITEM_DEFAULT, true}, + {"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}, {"runafterjob", store_short_runscript, ITEM(res_job.RunScripts), 0, 0, 0}, {"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}, - {"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}, - {"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}, + {"Runscript", store_runscript, ITEM(res_job.RunScripts), 0, ITEM_NO_EQUALS, 0}, + {"MaximumConcurrentJobs", store_pint32, ITEM(res_job.MaxConcurrentJobs), 0, ITEM_DEFAULT, 1}, + {"MaximumSpawnedJobs", store_pint32, ITEM(res_job.MaxSpawnedJobs), 0, ITEM_DEFAULT, 600}, + {"RescheduleOnError", store_bool, ITEM(res_job.RescheduleOnError), 0, ITEM_DEFAULT, false}, + {"RescheduleIncompleteJobs", store_bool, ITEM(res_job.RescheduleIncompleteJobs), 0, ITEM_DEFAULT, true}, + {"RescheduleInterval", store_time, ITEM(res_job.RescheduleInterval), 0, ITEM_DEFAULT, 60 * 30}, + {"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}, + {"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, true}, {"allowhigherduplicates", store_bool, ITEM(res_job.AllowHigherDuplicates), 0, ITEM_DEFAULT, true}, - {"cancelqueuedduplicates", store_bool, ITEM(res_job.CancelQueuedDuplicates), 0, ITEM_DEFAULT, true}, - {"cancelrunningduplicates", store_bool, ITEM(res_job.CancelRunningDuplicates), 0, ITEM_DEFAULT, false}, - {"pluginoptions", store_str, ITEM(res_job.PluginOptions), 0, 0, 0}, + {"CancelLowerLevelDuplicates", store_bool, ITEM(res_job.CancelLowerLevelDuplicates), 0, ITEM_DEFAULT, false}, + {"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}, + {"Base", store_alist_res, ITEM(res_job.base), R_JOB, 0, 0}, {NULL, NULL, {0}, 0, 0, 0} }; -/* FileSet resource +/* Fileset resource * - * name handler value code flags default_value + * Name handler value code flags default_value */ 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, {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, true}, + {"Name", store_name, ITEM(res_fs.hdr.name), 0, ITEM_REQUIRED, 0}, + {"Description", store_str, ITEM(res_fs.hdr.desc), 0, 0, 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, true}, + {"EnableSnapshot",store_bool, ITEM(res_fs.enable_snapshot), 0, ITEM_DEFAULT, false}, + {"Include", store_inc, {0}, 0, ITEM_NO_EQUALS, 0}, + {"Exclude", store_inc, {0}, 1, ITEM_NO_EQUALS, 0}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -351,9 +369,10 @@ static RES_ITEM fs_items[] = { * name handler value code flags default_value */ 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}, + {"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}, + {"Enabled", store_bool, ITEM(res_sch.enabled), 0, ITEM_DEFAULT, true}, {NULL, NULL, {0}, 0, 0, 0} }; @@ -362,34 +381,39 @@ static RES_ITEM sch_items[] = { * name handler value code flags default_value */ 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}, - {"labelformat", store_strname, ITEM(res_pool.label_format), 0, 0, 0}, - {"labeltype", store_label, ITEM(res_pool.LabelType), 0, 0, 0}, - {"cleaningprefix", store_strname, ITEM(res_pool.cleaning_prefix), 0, 0, 0}, - {"usecatalog", store_bool, ITEM(res_pool.use_catalog), 0, ITEM_DEFAULT, true}, - {"usevolumeonce", store_bool, ITEM(res_pool.use_volume_once), 0, 0, 0}, - {"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}, - {"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}, - {"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}, - {"recyclepool", store_res, ITEM(res_pool.RecyclePool), 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}, + {"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}, + {"LabelFormat", store_strname, ITEM(res_pool.label_format), 0, 0, 0}, + {"LabelType", store_label, ITEM(res_pool.LabelType), 0, 0, 0}, + {"CleaningPrefix", store_strname, ITEM(res_pool.cleaning_prefix), 0, 0, 0}, + {"UseCatalog", store_bool, ITEM(res_pool.use_catalog), 0, ITEM_DEFAULT, true}, + {"UseVolumeOnce", store_bool, ITEM(res_pool.use_volume_once), 0, 0, 0}, + {"PurgeOldestVolume", store_bool, ITEM(res_pool.purge_oldest_volume), 0, 0, 0}, + {"ActionOnPurge", store_actiononpurge, ITEM(res_pool.action_on_purge), 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_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_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}, + {"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}, + {"FileRetention", store_time, ITEM(res_pool.FileRetention), 0, 0, 0}, + {"JobRetention", store_time, ITEM(res_pool.JobRetention), 0, 0, 0}, + {NULL, NULL, {0}, 0, 0, 0} }; @@ -398,12 +422,12 @@ static RES_ITEM pool_items[] = { * name handler value code flags default_value */ 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}, - {"wrapcounter", store_res, ITEM(res_counter.WrapCounter), R_COUNTER, 0, 0}, - {"catalog", store_res, ITEM(res_counter.Catalog), R_CATALOG, 0, 0}, + {"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_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} }; @@ -418,22 +442,22 @@ extern RES_ITEM msgs_items[]; * NOTE!!! keep it in the same order as the R_codes * or eliminate all resources[rindex].name * - * name items rcode res_head + * name items rcode */ RES_TABLE resources[] = { - {"director", dir_items, R_DIRECTOR}, - {"client", cli_items, R_CLIENT}, - {"job", job_items, R_JOB}, - {"storage", store_items, R_STORAGE}, - {"catalog", cat_items, R_CATALOG}, - {"schedule", sch_items, R_SCHEDULE}, - {"fileset", fs_items, R_FILESET}, - {"pool", pool_items, R_POOL}, - {"messages", msgs_items, R_MSGS}, - {"counter", counter_items, R_COUNTER}, - {"console", con_items, R_CONSOLE}, - {"jobdefs", job_items, R_JOBDEFS}, - {"device", NULL, R_DEVICE}, /* info obtained from SD */ + {"Director", dir_items, R_DIRECTOR}, + {"Client", cli_items, R_CLIENT}, + {"Job", job_items, R_JOB}, + {"Storage", store_items, R_STORAGE}, + {"Catalog", cat_items, R_CATALOG}, + {"Schedule", sch_items, R_SCHEDULE}, + {"Fileset", fs_items, R_FILESET}, + {"Pool", pool_items, R_POOL}, + {"Messages", msgs_items, R_MSGS}, + {"Counter", counter_items, R_COUNTER}, + {"Console", con_items, R_CONSOLE}, + {"JobDefs", job_items, R_JOBDEFS}, + {"Device", NULL, R_DEVICE}, /* info obtained from SD */ {NULL, NULL, 0} }; @@ -448,27 +472,35 @@ 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}, {"DiskToCatalog", L_VERIFY_DISK_TO_CATALOG, JT_VERIFY}, {"Data", L_VERIFY_DATA, JT_VERIFY}, + {"Full", L_FULL, JT_COPY}, + {"Incremental", L_INCREMENTAL, JT_COPY}, + {"Differential", L_DIFFERENTIAL, JT_COPY}, + {"Full", L_FULL, JT_MIGRATE}, + {"Incremental", L_INCREMENTAL, JT_MIGRATE}, + {"Differential", L_DIFFERENTIAL, JT_MIGRATE}, {" ", L_NONE, JT_ADMIN}, {" ", L_NONE, JT_RESTORE}, {NULL, 0, 0} }; + /* Keywords (RHS) permitted in Job type records * * type_name job_type */ -struct s_jt jobtypes[] = { - {"backup", JT_BACKUP}, - {"admin", JT_ADMIN}, - {"verify", JT_VERIFY}, - {"restore", JT_RESTORE}, - {"migrate", JT_MIGRATE}, - {"copy", JT_COPY}, +s_jt jobtypes[] = { + {"Backup", JT_BACKUP}, + {"Admin", JT_ADMIN}, + {"Verify", JT_VERIFY}, + {"Restore", JT_RESTORE}, + {"Migrate", JT_MIGRATE}, + {"Copy", JT_COPY}, {NULL, 0} }; @@ -477,15 +509,16 @@ struct s_jt jobtypes[] = { * * type_name job_type */ -struct s_jt migtypes[] = { - {"smallestvolume", MT_SMALLEST_VOL}, - {"oldestvolume", MT_OLDEST_VOL}, - {"pooloccupancy", MT_POOL_OCCUPANCY}, - {"pooltime", MT_POOL_TIME}, - {"client", MT_CLIENT}, - {"volume", MT_VOLUME}, - {"job", MT_JOB}, - {"sqlquery", MT_SQLQUERY}, +s_jt migtypes[] = { + {"SmallestVolume", MT_SMALLEST_VOL}, + {"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}, + {"SqlQuery", MT_SQLQUERY}, {NULL, 0} }; @@ -493,13 +526,23 @@ struct s_jt migtypes[] = { /* Options permitted in Restore replace= */ struct s_kw ReplaceOptions[] = { - {"always", REPLACE_ALWAYS}, - {"ifnewer", REPLACE_IFNEWER}, - {"ifolder", REPLACE_IFOLDER}, - {"never", REPLACE_NEVER}, + {"Always", REPLACE_ALWAYS}, + {"IfNewer", REPLACE_IFNEWER}, + {"IfOlder", REPLACE_IFOLDER}, + {"Never", REPLACE_NEVER}, {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; @@ -508,7 +551,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; } @@ -517,25 +560,26 @@ const char *level_to_str(int level) } /* Dump contents of resource */ -void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fmt, ...), void *sock) +void dump_resource(int type, RES *ares, void sendit(void *sock, const char *fmt, ...), void *sock) { - URES *res = (URES *)reshdr; + URES *res = (URES *)ares; bool recurse = true; char ed1[100], ed2[100], ed3[100]; DEVICE *dev; + UAContext *ua = (UAContext *)sock; if (res == NULL) { sendit(sock, _("No %s resource defined\n"), res_to_str(type)); return; } if (type < 0) { /* no recursion */ - type = - type; + type = -type; recurse = false; } switch (type) { case R_DIRECTOR: sendit(sock, _("Director: name=%s MaxJobs=%d FDtimeout=%s SDtimeout=%s\n"), - reshdr->name, res->res_dir.MaxConcurrentJobs, + ares->name, res->res_dir.MaxConcurrentJobs, edit_uint64(res->res_dir.FDConnectTimeout, ed1), edit_uint64(res->res_dir.SDConnectTimeout, ed2)); if (res->res_dir.query_file) { @@ -568,13 +612,24 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm break; case R_CLIENT: - sendit(sock, _("Client: name=%s address=%s FDport=%d MaxJobs=%u\n"), - res->res_client.hdr.name, res->res_client.address, res->res_client.FDport, + if (!acl_access_ok(ua, Client_ACL, res->res_client.hdr.name)) { + break; + } + sendit(sock, _("Client: Name=%s Enabled=%d Address=%s FDport=%d MaxJobs=%u\n"), + res->res_client.hdr.name, res->res_client.enabled, + res->res_client.address, res->res_client.FDport, res->res_client.MaxConcurrentJobs); sendit(sock, _(" JobRetention=%s FileRetention=%s AutoPrune=%d\n"), edit_utime(res->res_client.JobRetention, ed1, sizeof(ed1)), edit_utime(res->res_client.FileRetention, ed2, sizeof(ed2)), res->res_client.AutoPrune); + if (res->res_client.fd_storage_address) { + sendit(sock, " FDStorageAddress=%s\n", res->res_client.fd_storage_address); + } + if (res->res_client.max_bandwidth) { + sendit(sock, _(" MaximumBandwidth=%lld\n"), + res->res_client.max_bandwidth); + } if (res->res_client.catalog) { sendit(sock, _(" --> ")); dump_resource(-R_CATALOG, (RES *)res->res_client.catalog, sendit, sock); @@ -595,33 +650,46 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm break; case R_STORAGE: + if (!acl_access_ok(ua, Storage_ACL, res->res_store.hdr.name)) { + break; + } sendit(sock, _("Storage: name=%s address=%s SDport=%d MaxJobs=%u\n" -" DeviceName=%s MediaType=%s StorageId=%s\n"), +" DeviceName=%s MediaType=%s StorageId=%s Autochanger=%d\n"), res->res_store.hdr.name, res->res_store.address, res->res_store.SDport, res->res_store.MaxConcurrentJobs, res->res_store.dev_name(), res->res_store.media_type, - edit_int64(res->res_store.StorageId, ed1)); + edit_int64(res->res_store.StorageId, ed1), + res->res_store.autochanger); + if (res->res_store.fd_storage_address) { + sendit(sock, " FDStorageAddress=%s\n", res->res_store.fd_storage_address); + } break; case R_CATALOG: + if (!acl_access_ok(ua, Catalog_ACL, res->res_cat.hdr.name)) { + break; + } sendit(sock, _("Catalog: name=%s address=%s DBport=%d db_name=%s\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, + 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: + if (!acl_access_ok(ua, Job_ACL, res->res_job.hdr.name)) { + break; + } sendit(sock, _("%s: name=%s JobType=%d level=%s Priority=%d Enabled=%d\n"), type == R_JOB ? _("Job") : _("JobDefs"), res->res_job.hdr.name, res->res_job.JobType, level_to_str(res->res_job.JobLevel), res->res_job.Priority, res->res_job.enabled); sendit(sock, _(" MaxJobs=%u Resched=%d Times=%d Interval=%s Spool=%d WritePartAfterJob=%d\n"), - res->res_job.MaxConcurrentJobs, + res->res_job.MaxConcurrentJobs, 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); @@ -631,6 +699,10 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm if (res->res_job.JobType == JT_BACKUP) { sendit(sock, _(" Accurate=%d\n"), res->res_job.accurate); } + if (res->res_job.max_bandwidth) { + sendit(sock, _(" MaximumBandwidth=%lld\n"), + res->res_job.max_bandwidth); + } if (res->res_job.JobType == JT_MIGRATE || res->res_job.JobType == JT_COPY) { sendit(sock, _(" SelectionType=%d\n"), res->res_job.selection_type); } @@ -661,6 +733,18 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm 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.MaxRunSchedTime) { + sendit(sock, _(" --> MaxRunSchedTime=%u\n"), res->res_job.MaxRunSchedTime); + } if (res->res_job.storage) { STORE *store; foreach_alist(store, res->res_job.storage) { @@ -668,6 +752,12 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm dump_resource(-R_STORAGE, (RES *)store, sendit, sock); } } + if (res->res_job.base) { + JOB *job; + foreach_alist(job, res->res_job.base) { + sendit(sock, _(" --> Base %s\n"), job->name()); + } + } if (res->res_job.RunScripts) { RUNSCRIPT *script; foreach_alist(script, res->res_job.RunScripts) { @@ -685,15 +775,15 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm dump_resource(-R_POOL, (RES *)res->res_job.pool, sendit, sock); } if (res->res_job.full_pool) { - sendit(sock, _(" --> ")); + sendit(sock, _(" --> FullBackup")); dump_resource(-R_POOL, (RES *)res->res_job.full_pool, sendit, sock); } if (res->res_job.inc_pool) { - sendit(sock, _(" --> ")); + sendit(sock, _(" --> IncrementalBackup")); dump_resource(-R_POOL, (RES *)res->res_job.inc_pool, sendit, sock); } if (res->res_job.diff_pool) { - sendit(sock, _(" --> ")); + sendit(sock, _(" --> DifferentialBackup")); dump_resource(-R_POOL, (RES *)res->res_job.diff_pool, sendit, sock); } if (res->res_job.verify_job) { @@ -718,6 +808,9 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm case R_FILESET: { int i, j, k; + if (!acl_access_ok(ua, FileSet_ACL, res->res_fs.hdr.name)) { + break; + } sendit(sock, _("FileSet: name=%s\n"), res->res_fs.hdr.name); for (i=0; ires_fs.num_includes; i++) { INCEXE *incexe = res->res_fs.include_items[i]; @@ -774,6 +867,9 @@ 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)); } @@ -786,8 +882,7 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm if (incexe->plugin_list.size()) { sendit(sock, " N\n"); } - - } + } /* end for over includes */ for (i=0; ires_fs.num_excludes; i++) { INCEXE *incexe = res->res_fs.exclude_items[i]; @@ -799,19 +894,30 @@ void dump_resource(int type, RES *reshdr, void sendit(void *sock, const char *fm } } break; - } + } /* end case R_FILESET */ case R_SCHEDULE: + if (!acl_access_ok(ua, Schedule_ACL, res->res_sch.hdr.name)) { + break; + } + if (res->res_sch.run) { int i; RUN *run = res->res_sch.run; char buf[1000], num[30]; - sendit(sock, _("Schedule: name=%s\n"), res->res_sch.hdr.name); + sendit(sock, _("Schedule: Name=%s Enabled=%d\n"), + res->res_sch.hdr.name, res->res_sch.enabled); if (!run) { break; } next_run: sendit(sock, _(" --> Run Level=%s\n"), level_to_str(run->level)); + if (run->MaxRunSchedTime) { + sendit(sock, _(" MaxRunSchedTime=%u\n"), run->MaxRunSchedTime); + } + if (run->Priority) { + sendit(sock, _(" Priority=%u\n"), run->Priority); + } bstrncpy(buf, _(" hour="), sizeof(buf)); for (i=0; i<24; i++) { if (bit_is_set(i, run->hour)) { @@ -822,7 +928,7 @@ next_run: bstrncat(buf, "\n", sizeof(buf)); sendit(sock, buf); bstrncpy(buf, _(" mday="), sizeof(buf)); - for (i=0; i<31; i++) { + for (i=0; i<32; i++) { if (bit_is_set(i, run->mday)) { bsnprintf(num, sizeof(num), "%d ", i); bstrncat(buf, num, sizeof(buf)); @@ -849,7 +955,7 @@ next_run: bstrncat(buf, "\n", sizeof(buf)); sendit(sock, buf); bstrncpy(buf, _(" wom="), sizeof(buf)); - for (i=0; i<5; i++) { + for (i=0; i<6; i++) { if (bit_is_set(i, run->wom)) { bsnprintf(num, sizeof(num), "%d ", i); bstrncat(buf, num, sizeof(buf)); @@ -890,6 +996,9 @@ next_run: break; case R_POOL: + if (!acl_access_ok(ua, Pool_ACL, res->res_pool.hdr.name)) { + break; + } sendit(sock, _("Pool: name=%s PoolType=%s\n"), res->res_pool.hdr.name, res->res_pool.pool_type); sendit(sock, _(" use_cat=%d use_once=%d cat_files=%d\n"), @@ -904,23 +1013,30 @@ 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\n"), + sendit(sock, _(" RecyleOldest=%d PurgeOldest=%d ActionOnPurge=%d\n"), res->res_pool.recycle_oldest_volume, - res->res_pool.purge_oldest_volume); + res->res_pool.purge_oldest_volume, + res->res_pool.action_on_purge); sendit(sock, _(" MaxVolJobs=%d MaxVolFiles=%d MaxVolBytes=%s\n"), - res->res_pool.MaxVolJobs, + res->res_pool.MaxVolJobs, res->res_pool.MaxVolFiles, - edit_uint64(res->res_pool.MaxVolFiles, ed1)); + 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)); + sendit(sock, _(" JobRetention=%s FileRetention=%s\n"), + edit_utime(res->res_pool.JobRetention, ed1, sizeof(ed1)), + edit_utime(res->res_pool.FileRetention, ed2, sizeof(ed2))); if (res->res_pool.NextPool) { 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()); } @@ -956,6 +1072,7 @@ next_run: if (recurse && res->res_dir.hdr.next) { dump_resource(type, res->res_dir.hdr.next, sendit, sock); } + } /* @@ -991,9 +1108,13 @@ static void free_incexe(INCEXE *incexe) if (incexe->opts_list) { free(incexe->opts_list); } + if (incexe->ignoredir) { + free(incexe->ignoredir); + } free(incexe); } + /* * Free memory of resource -- called when daemon terminates. * NB, we don't need to worry about freeing any references @@ -1001,15 +1122,17 @@ static void free_incexe(INCEXE *incexe) * resource chain is traversed. Mainly we worry about freeing * allocated strings (names). */ -void free_resource(RES *sres, int type) +void free_resource(RES *rres, int type) { int num; - RES *nres; /* next resource if linked */ - URES *res = (URES *)sres; + RES *nres; + URES *res = (URES *)rres; - if (res == NULL) + if (res == NULL) { return; + } + Dmsg3(200, "type=%d res=%p name=%s\n", type, res, res->res_dir.hdr.name); /* common stuff -- free the resource name and description */ nres = (RES *)res->res_dir.hdr.next; if (res->res_dir.hdr.name) { @@ -1045,7 +1168,10 @@ void free_resource(RES *sres, int type) if (res->res_dir.DIRaddrs) { free_addresses(res->res_dir.DIRaddrs); } - if (res->res_dir.tls_ctx) { + 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); } if (res->res_dir.tls_ca_certfile) { @@ -1066,6 +1192,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: @@ -1074,7 +1203,7 @@ void free_resource(RES *sres, int type) if (res->res_con.password) { free(res->res_con.password); } - if (res->res_con.tls_ctx) { + if (res->res_con.tls_ctx) { free_tls_context(res->res_con.tls_ctx); } if (res->res_con.tls_ca_certfile) { @@ -1106,10 +1235,13 @@ void free_resource(RES *sres, int type) if (res->res_client.address) { free(res->res_client.address); } + if (res->res_client.fd_storage_address) { + free(res->res_client.fd_storage_address); + } if (res->res_client.password) { free(res->res_client.password); } - if (res->res_client.tls_ctx) { + if (res->res_client.tls_ctx) { free_tls_context(res->res_client.tls_ctx); } if (res->res_client.tls_ca_certfile) { @@ -1132,6 +1264,9 @@ void free_resource(RES *sres, int type) if (res->res_store.address) { free(res->res_store.address); } + if (res->res_store.fd_storage_address) { + free(res->res_store.fd_storage_address); + } if (res->res_store.password) { free(res->res_store.password); } @@ -1141,7 +1276,7 @@ void free_resource(RES *sres, int type) if (res->res_store.device) { delete res->res_store.device; } - if (res->res_store.tls_ctx) { + if (res->res_store.tls_ctx) { free_tls_context(res->res_store.tls_ctx); } if (res->res_store.tls_ca_certfile) { @@ -1253,6 +1388,9 @@ void free_resource(RES *sres, int type) if (res->res_job.storage) { delete res->res_job.storage; } + if (res->res_job.base) { + delete res->res_job.base; + } if (res->res_job.RunScripts) { free_runscripts(res->res_job.RunScripts); delete res->res_job.RunScripts; @@ -1352,6 +1490,7 @@ 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; @@ -1387,7 +1526,9 @@ void save_resource(int type, RES_ITEM *items, int pass) res->res_job.client = res_all.res_job.client; res->res_job.fileset = res_all.res_job.fileset; res->res_job.storage = res_all.res_job.storage; + res->res_job.base = res_all.res_job.base; res->res_job.pool = res_all.res_job.pool; + res->res_job.next_pool = res_all.res_job.next_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.diff_pool = res_all.res_job.diff_pool; @@ -1397,13 +1538,13 @@ void save_resource(int type, RES_ITEM *items, int pass) res->res_job.RunScripts = res_all.res_job.RunScripts; /* TODO: JobDefs where/regexwhere doesn't work well (but this - * is not very useful) + * 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 + if (!res->res_job.RegexWhere && (res->res_job.strip_prefix || res->res_job.add_suffix || @@ -1515,7 +1656,7 @@ void save_resource(int type, RES_ITEM *items, int pass) break; default: printf(_("Unknown resource type %d in save_resource.\n"), type); - error = true; + error = true; break; } /* Common */ @@ -1531,7 +1672,7 @@ void save_resource(int type, RES_ITEM *items, int pass) 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 (last=next=res_head[rindex]; next; next=next->next) { last = next; @@ -1548,6 +1689,20 @@ void save_resource(int type, RES_ITEM *items, int pass) } } +void store_actiononpurge(LEX *lc, RES_ITEM *item, int index, int pass) +{ + uint32_t *destination = (uint32_t*)item->value; + lex_get_token(lc, T_NAME); + if (strcasecmp(lc->str, "truncate") == 0) { + *destination = (*destination) | ON_PURGE_TRUNCATE; + } else { + scan_err2(lc, _("Expected one of: %s, got: %s"), "Truncate", lc->str); + return; + } + scan_to_eol(lc); + set_bit(index, res_all.hdr.item_present); +} + /* * Store Device. Note, the resource is created upon the * first reference. The details of the resource are obtained @@ -1555,14 +1710,13 @@ void save_resource(int type, RES_ITEM *items, int pass) */ static void store_device(LEX *lc, RES_ITEM *item, int index, int pass) { - int token; URES *res; int rindex = R_DEVICE - r_first; int size = sizeof(DEVICE); bool found = false; if (pass == 1) { - token = lex_get_token(lc, T_NAME); + lex_get_token(lc, T_NAME); if (!res_head[rindex]) { res = (URES *)malloc(size); memset(res, 0, size); @@ -1597,18 +1751,18 @@ static void store_device(LEX *lc, RES_ITEM *item, int index, int pass) } /* - * Store JobType (backup, verify, restore) + * Store Migration/Copy type * */ void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass) { - int token, i; + int i; - token = lex_get_token(lc, T_NAME); + lex_get_token(lc, T_NAME); /* 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; } @@ -1628,13 +1782,13 @@ void store_migtype(LEX *lc, RES_ITEM *item, int index, int pass) */ void store_jobtype(LEX *lc, RES_ITEM *item, int index, int pass) { - int token, i; + int i; - token = lex_get_token(lc, T_NAME); + lex_get_token(lc, T_NAME); /* 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; } @@ -1652,13 +1806,13 @@ void store_jobtype(LEX *lc, RES_ITEM *item, int index, int pass) */ void store_level(LEX *lc, RES_ITEM *item, int index, int pass) { - int token, i; + int i; - token = lex_get_token(lc, T_NAME); + lex_get_token(lc, T_NAME); /* 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; } @@ -1673,12 +1827,12 @@ void store_level(LEX *lc, RES_ITEM *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); + int i; + lex_get_token(lc, T_NAME); /* 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; } @@ -1699,7 +1853,7 @@ void store_acl(LEX *lc, RES_ITEM *item, int index, int pass) int token; for (;;) { - token = lex_get_token(lc, T_STRING); + lex_get_token(lc, T_STRING); if (pass == 1) { if (((alist **)item->value)[item->code] == NULL) { ((alist **)item->value)[item->code] = New(alist(10, owned_by_alist)); @@ -1726,13 +1880,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) { - *(int *)(item->value) = SCRIPT_AfterVSS; + *(uint32_t *)(item->value) = SCRIPT_AfterVSS; + } else if (strcasecmp(lc->str, "aftersnapshot") == 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, AfterVSS or Always", lc->str); } @@ -1740,7 +1896,7 @@ static void store_runscript_when(LEX *lc, RES_ITEM *item, int index, int pass) } /* Store a runscript->target - * + * */ static void store_runscript_target(LEX *lc, RES_ITEM *item, int index, int pass) { @@ -1779,7 +1935,7 @@ static void store_runscript_cmd(LEX *lc, RES_ITEM *item, int index, int pass) /* 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 */ + ((RUNSCRIPT*) item->value)->commands->prepend((void *)(intptr_t)item->code); /* command type */ } scan_to_eol(lc); } @@ -1791,37 +1947,37 @@ 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_job_code_callback(job_code_callback_director); script->set_command(lc->str); /* TODO: remove all script->old_proto with bacula 1.42 */ - if (strcmp(item->name, "runbeforejob") == 0) { + if (strcasecmp(item->name, "runbeforejob") == 0) { script->when = SCRIPT_Before; script->fail_on_error = true; script->set_target(""); - } else if (strcmp(item->name, "runafterjob") == 0) { + } else if (strcasecmp(item->name, "runafterjob") == 0) { script->when = SCRIPT_After; script->on_success = true; script->on_failure = false; script->set_target(""); - - } else if (strcmp(item->name, "clientrunafterjob") == 0) { + + } else if (strcasecmp(item->name, "clientrunafterjob") == 0) { script->old_proto = true; script->when = SCRIPT_After; script->set_target("%c"); script->on_success = true; script->on_failure = false; - } else if (strcmp(item->name, "clientrunbeforejob") == 0) { + } else if (strcasecmp(item->name, "clientrunbeforejob") == 0) { script->old_proto = true; script->when = SCRIPT_Before; script->set_target("%c"); script->fail_on_error = true; - } else if (strcmp(item->name, "runafterfailedjob") == 0) { + } else if (strcasecmp(item->name, "runafterfailedjob") == 0) { script->when = SCRIPT_After; script->on_failure = true; script->on_success = false; @@ -1831,15 +1987,15 @@ static void store_short_runscript(LEX *lc, RES_ITEM *item, int index, int pass) if (*runscripts == NULL) { *runscripts = New(alist(10, not_owned_by_alist)); } - + (*runscripts)->append(script); script->debug(); } - scan_to_eol(lc); + set_bit(index, res_all.hdr.item_present); } -/* Store a bool in a bit field without modifing res_all.hdr +/* 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) @@ -1860,9 +2016,9 @@ void store_runscript_bool(LEX *lc, RES_ITEM *item, int index, int pass) * name handler value code flags default_value */ static RES_ITEM runscript_items[] = { - {"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}, + {"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}, @@ -1879,7 +2035,7 @@ static RES_ITEM runscript_items[] = { * resource. We treat the RunScript like a sort of * mini-resource within the Job resource. */ -static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) +void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) { char *c; int token, i, t; @@ -1887,14 +2043,14 @@ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) Dmsg1(200, "store_runscript: begin store_runscript pass=%i\n", pass); - res_runscript.reset_default(); /* setting on_success, on_failure, fail_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)); } @@ -1912,14 +2068,14 @@ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) if (token != T_EQUALS) { scan_err1(lc, _("expected an equals, got: %s"), lc->str); } - + /* Call item handler */ runscript_items[i].handler(lc, &runscript_items[i], i, pass); i = -1; break; } } - + if (i >=0) { scan_err1(lc, _("Keyword %s not permitted in this resource"), lc->str); } @@ -1935,18 +2091,18 @@ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) } /* * commands list contains 2 values per command - * - POOLMEM command string (ex: /bin/true) + * - POOLMEM command string (ex: /bin/true) * - int command type (ex: SHELL_CMD) */ - res_runscript.set_job_code_callback(job_code_callback_filesetname); + res_runscript.set_job_code_callback(job_code_callback_director); while ((c=(char*)res_runscript.commands->pop()) != NULL) { - t = (int) res_runscript.commands->pop(); - res_runscript.command = c; - res_runscript.cmd_type = t; + 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 + * a copy */ script->target = NULL; script->set_target(res_runscript.target); @@ -1955,6 +2111,8 @@ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) script->debug(); } delete res_runscript.commands; + /* setting on_success, on_failure... cleanup target field */ + res_runscript.reset_default(true); } scan_to_eol(lc); @@ -1962,11 +2120,45 @@ static void store_runscript(LEX *lc, RES_ITEM *item, int index, int pass) } /* callback function for edit_job_codes */ -extern "C" char *job_code_callback_filesetname(JCR *jcr, const char* param) +/* See ../lib/util.c, function edit_job_codes, for more remaining codes */ +extern "C" char *job_code_callback_director(JCR *jcr, const char* param) { - if (param[0] == 'f') { - return jcr->fileset->name(); - } else { - return NULL; + static char yes[] = "yes"; + static char no[] = "no"; + switch (param[0]) { + case 'f': + if (jcr->fileset) { + return jcr->fileset->name(); + } + break; + case 'h': + if (jcr->client && jcr->client->address) { + return jcr->client->address; + } + break; + case 'p': + if (jcr->pool) { + return jcr->pool->name(); + } + break; + case 'w': + if (jcr->wstore) { + return jcr->wstore->name(); + } + break; + case 'x': + return jcr->spool_data ? yes : no; + case 'D': + return my_name; + case 'C': + return jcr->cloned ? yes : no; } + 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(); }