git.gag.com Git - debian/amanda/blob - perl/Amanda/Config.pm

   1 # This file was automatically generated by SWIG (http://www.swig.org).
   2 # Version 2.0.4
   3 #
   4 # Do not make changes to this file unless you know what you are doing--modify
   5 # the SWIG interface file instead.
   6
   7 package Amanda::Config;
   8 use base qw(Exporter);
   9 use base qw(DynaLoader);
  10 package Amanda::Configc;
  11 bootstrap Amanda::Config;
  12 package Amanda::Config;
  13 @EXPORT = qw();
  14
  15 # ---------- BASE METHODS -------------
  16
  17 package Amanda::Config;
  18
  19 sub TIEHASH {
  20     my ($classname,$obj) = @_;
  21     return bless $obj, $classname;
  22 }
  23
  24 sub CLEAR { }
  25
  26 sub FIRSTKEY { }
  27
  28 sub NEXTKEY { }
  29
  30 sub FETCH {
  31     my ($self,$field) = @_;
  32     my $member_func = "swig_${field}_get";
  33     $self->$member_func();
  34 }
  35
  36 sub STORE {
  37     my ($self,$field,$newval) = @_;
  38     my $member_func = "swig_${field}_set";
  39     $self->$member_func($newval);
  40 }
  41
  42 sub this {
  43     my $ptr = shift;
  44     return tied(%$ptr);
  45 }
  46
  47
  48 # ------- FUNCTION WRAPPERS --------
  49
  50 package Amanda::Config;
  51
  52 *data_path_from_string = *Amanda::Configc::data_path_from_string;
  53 *getconf = *Amanda::Configc::getconf;
  54 *getconf_seen = *Amanda::Configc::getconf_seen;
  55 *getconf_linenum = *Amanda::Configc::getconf_linenum;
  56 *getconf_byname = *Amanda::Configc::getconf_byname;
  57 *getconf_list = *Amanda::Configc::getconf_list;
  58 *getconf_byname_strs = *Amanda::Configc::getconf_byname_strs;
  59 *lookup_tapetype = *Amanda::Configc::lookup_tapetype;
  60 *tapetype_getconf = *Amanda::Configc::tapetype_getconf;
  61 *tapetype_name = *Amanda::Configc::tapetype_name;
  62 *tapetype_seen = *Amanda::Configc::tapetype_seen;
  63 *lookup_dumptype = *Amanda::Configc::lookup_dumptype;
  64 *dumptype_getconf = *Amanda::Configc::dumptype_getconf;
  65 *dumptype_name = *Amanda::Configc::dumptype_name;
  66 *dumptype_seen = *Amanda::Configc::dumptype_seen;
  67 *lookup_interface = *Amanda::Configc::lookup_interface;
  68 *interface_getconf = *Amanda::Configc::interface_getconf;
  69 *interface_name = *Amanda::Configc::interface_name;
  70 *interface_seen = *Amanda::Configc::interface_seen;
  71 *lookup_holdingdisk = *Amanda::Configc::lookup_holdingdisk;
  72 *getconf_holdingdisks = *Amanda::Configc::getconf_holdingdisks;
  73 *holdingdisk_getconf = *Amanda::Configc::holdingdisk_getconf;
  74 *holdingdisk_name = *Amanda::Configc::holdingdisk_name;
  75 *holdingdisk_seen = *Amanda::Configc::holdingdisk_seen;
  76 *lookup_application = *Amanda::Configc::lookup_application;
  77 *application_getconf = *Amanda::Configc::application_getconf;
  78 *application_name = *Amanda::Configc::application_name;
  79 *application_seen = *Amanda::Configc::application_seen;
  80 *lookup_pp_script = *Amanda::Configc::lookup_pp_script;
  81 *pp_script_getconf = *Amanda::Configc::pp_script_getconf;
  82 *pp_script_name = *Amanda::Configc::pp_script_name;
  83 *pp_script_seen = *Amanda::Configc::pp_script_seen;
  84 *lookup_device_config = *Amanda::Configc::lookup_device_config;
  85 *device_config_getconf = *Amanda::Configc::device_config_getconf;
  86 *device_config_name = *Amanda::Configc::device_config_name;
  87 *device_config_seen = *Amanda::Configc::device_config_seen;
  88 *lookup_changer_config = *Amanda::Configc::lookup_changer_config;
  89 *changer_config_getconf = *Amanda::Configc::changer_config_getconf;
  90 *changer_config_name = *Amanda::Configc::changer_config_name;
  91 *changer_config_seen = *Amanda::Configc::changer_config_seen;
  92 *lookup_interactivity = *Amanda::Configc::lookup_interactivity;
  93 *interactivity_getconf = *Amanda::Configc::interactivity_getconf;
  94 *interactivity_name = *Amanda::Configc::interactivity_name;
  95 *interactivity_seen = *Amanda::Configc::interactivity_seen;
  96 *lookup_taperscan = *Amanda::Configc::lookup_taperscan;
  97 *taperscan_getconf = *Amanda::Configc::taperscan_getconf;
  98 *taperscan_name = *Amanda::Configc::taperscan_name;
  99 *taperscan_seen = *Amanda::Configc::taperscan_seen;
 100 *getconf_unit_divisor = *Amanda::Configc::getconf_unit_divisor;
 101 *config_init = *Amanda::Configc::config_init;
 102 *config_uninit = *Amanda::Configc::config_uninit;
 103 *get_config_options = *Amanda::Configc::get_config_options;
 104 *get_config_name = *Amanda::Configc::get_config_name;
 105 *get_config_dir = *Amanda::Configc::get_config_dir;
 106 *get_config_filename = *Amanda::Configc::get_config_filename;
 107 *config_print_errors = *Amanda::Configc::config_print_errors;
 108 *config_clear_errors = *Amanda::Configc::config_clear_errors;
 109 *config_errors = *Amanda::Configc::config_errors;
 110 *new_config_overrides = *Amanda::Configc::new_config_overrides;
 111 *free_config_overrides = *Amanda::Configc::free_config_overrides;
 112 *add_config_override = *Amanda::Configc::add_config_override;
 113 *add_config_override_opt = *Amanda::Configc::add_config_override_opt;
 114 *set_config_overrides = *Amanda::Configc::set_config_overrides;
 115 *dump_configuration = *Amanda::Configc::dump_configuration;
 116 *config_dir_relative = *Amanda::Configc::config_dir_relative;
 117 *taperalgo2str = *Amanda::Configc::taperalgo2str;
 118 *find_multiplier = *Amanda::Configc::find_multiplier;
 119 *C_string_to_boolean = *Amanda::Configc::C_string_to_boolean;
 120 *amandaify_property_name = *Amanda::Configc::amandaify_property_name;
 121
 122 # ------- VARIABLE STUBS --------
 123
 124 package Amanda::Config;
 125
 126 *CNF_ORG = *Amanda::Configc::CNF_ORG;
 127 *CNF_CONF = *Amanda::Configc::CNF_CONF;
 128 *CNF_AMDUMP_SERVER = *Amanda::Configc::CNF_AMDUMP_SERVER;
 129 *CNF_INDEX_SERVER = *Amanda::Configc::CNF_INDEX_SERVER;
 130 *CNF_TAPE_SERVER = *Amanda::Configc::CNF_TAPE_SERVER;
 131 *CNF_AUTH = *Amanda::Configc::CNF_AUTH;
 132 *CNF_SSH_KEYS = *Amanda::Configc::CNF_SSH_KEYS;
 133 *CNF_AMANDAD_PATH = *Amanda::Configc::CNF_AMANDAD_PATH;
 134 *CNF_CLIENT_USERNAME = *Amanda::Configc::CNF_CLIENT_USERNAME;
 135 *CNF_CLIENT_PORT = *Amanda::Configc::CNF_CLIENT_PORT;
 136 *CNF_GNUTAR_LIST_DIR = *Amanda::Configc::CNF_GNUTAR_LIST_DIR;
 137 *CNF_AMANDATES = *Amanda::Configc::CNF_AMANDATES;
 138 *CNF_MAILER = *Amanda::Configc::CNF_MAILER;
 139 *CNF_MAILTO = *Amanda::Configc::CNF_MAILTO;
 140 *CNF_DUMPUSER = *Amanda::Configc::CNF_DUMPUSER;
 141 *CNF_TAPEDEV = *Amanda::Configc::CNF_TAPEDEV;
 142 *CNF_DEVICE_PROPERTY = *Amanda::Configc::CNF_DEVICE_PROPERTY;
 143 *CNF_PROPERTY = *Amanda::Configc::CNF_PROPERTY;
 144 *CNF_CHANGERDEV = *Amanda::Configc::CNF_CHANGERDEV;
 145 *CNF_CHANGERFILE = *Amanda::Configc::CNF_CHANGERFILE;
 146 *CNF_LABELSTR = *Amanda::Configc::CNF_LABELSTR;
 147 *CNF_AUTOLABEL = *Amanda::Configc::CNF_AUTOLABEL;
 148 *CNF_META_AUTOLABEL = *Amanda::Configc::CNF_META_AUTOLABEL;
 149 *CNF_TAPELIST = *Amanda::Configc::CNF_TAPELIST;
 150 *CNF_DISKFILE = *Amanda::Configc::CNF_DISKFILE;
 151 *CNF_INFOFILE = *Amanda::Configc::CNF_INFOFILE;
 152 *CNF_LOGDIR = *Amanda::Configc::CNF_LOGDIR;
 153 *CNF_INDEXDIR = *Amanda::Configc::CNF_INDEXDIR;
 154 *CNF_TAPETYPE = *Amanda::Configc::CNF_TAPETYPE;
 155 *CNF_DUMPCYCLE = *Amanda::Configc::CNF_DUMPCYCLE;
 156 *CNF_RUNSPERCYCLE = *Amanda::Configc::CNF_RUNSPERCYCLE;
 157 *CNF_TAPECYCLE = *Amanda::Configc::CNF_TAPECYCLE;
 158 *CNF_NETUSAGE = *Amanda::Configc::CNF_NETUSAGE;
 159 *CNF_INPARALLEL = *Amanda::Configc::CNF_INPARALLEL;
 160 *CNF_DUMPORDER = *Amanda::Configc::CNF_DUMPORDER;
 161 *CNF_BUMPPERCENT = *Amanda::Configc::CNF_BUMPPERCENT;
 162 *CNF_BUMPSIZE = *Amanda::Configc::CNF_BUMPSIZE;
 163 *CNF_BUMPMULT = *Amanda::Configc::CNF_BUMPMULT;
 164 *CNF_BUMPDAYS = *Amanda::Configc::CNF_BUMPDAYS;
 165 *CNF_TPCHANGER = *Amanda::Configc::CNF_TPCHANGER;
 166 *CNF_RUNTAPES = *Amanda::Configc::CNF_RUNTAPES;
 167 *CNF_MAX_DLE_BY_VOLUME = *Amanda::Configc::CNF_MAX_DLE_BY_VOLUME;
 168 *CNF_MAXDUMPS = *Amanda::Configc::CNF_MAXDUMPS;
 169 *CNF_ETIMEOUT = *Amanda::Configc::CNF_ETIMEOUT;
 170 *CNF_DTIMEOUT = *Amanda::Configc::CNF_DTIMEOUT;
 171 *CNF_CTIMEOUT = *Amanda::Configc::CNF_CTIMEOUT;
 172 *CNF_DEVICE_OUTPUT_BUFFER_SIZE = *Amanda::Configc::CNF_DEVICE_OUTPUT_BUFFER_SIZE;
 173 *CNF_PRINTER = *Amanda::Configc::CNF_PRINTER;
 174 *CNF_AUTOFLUSH = *Amanda::Configc::CNF_AUTOFLUSH;
 175 *CNF_RESERVE = *Amanda::Configc::CNF_RESERVE;
 176 *CNF_MAXDUMPSIZE = *Amanda::Configc::CNF_MAXDUMPSIZE;
 177 *CNF_COLUMNSPEC = *Amanda::Configc::CNF_COLUMNSPEC;
 178 *CNF_AMRECOVER_DO_FSF = *Amanda::Configc::CNF_AMRECOVER_DO_FSF;
 179 *CNF_AMRECOVER_CHECK_LABEL = *Amanda::Configc::CNF_AMRECOVER_CHECK_LABEL;
 180 *CNF_AMRECOVER_CHANGER = *Amanda::Configc::CNF_AMRECOVER_CHANGER;
 181 *CNF_TAPERALGO = *Amanda::Configc::CNF_TAPERALGO;
 182 *CNF_FLUSH_THRESHOLD_DUMPED = *Amanda::Configc::CNF_FLUSH_THRESHOLD_DUMPED;
 183 *CNF_FLUSH_THRESHOLD_SCHEDULED = *Amanda::Configc::CNF_FLUSH_THRESHOLD_SCHEDULED;
 184 *CNF_TAPERFLUSH = *Amanda::Configc::CNF_TAPERFLUSH;
 185 *CNF_DISPLAYUNIT = *Amanda::Configc::CNF_DISPLAYUNIT;
 186 *CNF_KRB5KEYTAB = *Amanda::Configc::CNF_KRB5KEYTAB;
 187 *CNF_KRB5PRINCIPAL = *Amanda::Configc::CNF_KRB5PRINCIPAL;
 188 *CNF_LABEL_NEW_TAPES = *Amanda::Configc::CNF_LABEL_NEW_TAPES;
 189 *CNF_USETIMESTAMPS = *Amanda::Configc::CNF_USETIMESTAMPS;
 190 *CNF_REP_TRIES = *Amanda::Configc::CNF_REP_TRIES;
 191 *CNF_CONNECT_TRIES = *Amanda::Configc::CNF_CONNECT_TRIES;
 192 *CNF_REQ_TRIES = *Amanda::Configc::CNF_REQ_TRIES;
 193 *CNF_DEBUG_AMANDAD = *Amanda::Configc::CNF_DEBUG_AMANDAD;
 194 *CNF_DEBUG_RECOVERY = *Amanda::Configc::CNF_DEBUG_RECOVERY;
 195 *CNF_DEBUG_AMIDXTAPED = *Amanda::Configc::CNF_DEBUG_AMIDXTAPED;
 196 *CNF_DEBUG_AMINDEXD = *Amanda::Configc::CNF_DEBUG_AMINDEXD;
 197 *CNF_DEBUG_AMRECOVER = *Amanda::Configc::CNF_DEBUG_AMRECOVER;
 198 *CNF_DEBUG_AUTH = *Amanda::Configc::CNF_DEBUG_AUTH;
 199 *CNF_DEBUG_EVENT = *Amanda::Configc::CNF_DEBUG_EVENT;
 200 *CNF_DEBUG_HOLDING = *Amanda::Configc::CNF_DEBUG_HOLDING;
 201 *CNF_DEBUG_PROTOCOL = *Amanda::Configc::CNF_DEBUG_PROTOCOL;
 202 *CNF_DEBUG_PLANNER = *Amanda::Configc::CNF_DEBUG_PLANNER;
 203 *CNF_DEBUG_DRIVER = *Amanda::Configc::CNF_DEBUG_DRIVER;
 204 *CNF_DEBUG_DUMPER = *Amanda::Configc::CNF_DEBUG_DUMPER;
 205 *CNF_DEBUG_CHUNKER = *Amanda::Configc::CNF_DEBUG_CHUNKER;
 206 *CNF_DEBUG_TAPER = *Amanda::Configc::CNF_DEBUG_TAPER;
 207 *CNF_DEBUG_SELFCHECK = *Amanda::Configc::CNF_DEBUG_SELFCHECK;
 208 *CNF_DEBUG_SENDSIZE = *Amanda::Configc::CNF_DEBUG_SENDSIZE;
 209 *CNF_DEBUG_SENDBACKUP = *Amanda::Configc::CNF_DEBUG_SENDBACKUP;
 210 *CNF_RESERVED_UDP_PORT = *Amanda::Configc::CNF_RESERVED_UDP_PORT;
 211 *CNF_RESERVED_TCP_PORT = *Amanda::Configc::CNF_RESERVED_TCP_PORT;
 212 *CNF_UNRESERVED_TCP_PORT = *Amanda::Configc::CNF_UNRESERVED_TCP_PORT;
 213 *CNF_HOLDINGDISK = *Amanda::Configc::CNF_HOLDINGDISK;
 214 *CNF_SEND_AMREPORT_ON = *Amanda::Configc::CNF_SEND_AMREPORT_ON;
 215 *CNF_TAPER_PARALLEL_WRITE = *Amanda::Configc::CNF_TAPER_PARALLEL_WRITE;
 216 *CNF_RECOVERY_LIMIT = *Amanda::Configc::CNF_RECOVERY_LIMIT;
 217 *CNF_INTERACTIVITY = *Amanda::Configc::CNF_INTERACTIVITY;
 218 *CNF_TAPERSCAN = *Amanda::Configc::CNF_TAPERSCAN;
 219 *CNF_EJECT_VOLUME = *Amanda::Configc::CNF_EJECT_VOLUME;
 220 *CNF_TMPDIR = *Amanda::Configc::CNF_TMPDIR;
 221 *CNF_REPORT_USE_MEDIA = *Amanda::Configc::CNF_REPORT_USE_MEDIA;
 222 *CNF_REPORT_NEXT_MEDIA = *Amanda::Configc::CNF_REPORT_NEXT_MEDIA;
 223 *TAPETYPE_COMMENT = *Amanda::Configc::TAPETYPE_COMMENT;
 224 *TAPETYPE_LBL_TEMPL = *Amanda::Configc::TAPETYPE_LBL_TEMPL;
 225 *TAPETYPE_BLOCKSIZE = *Amanda::Configc::TAPETYPE_BLOCKSIZE;
 226 *TAPETYPE_READBLOCKSIZE = *Amanda::Configc::TAPETYPE_READBLOCKSIZE;
 227 *TAPETYPE_LENGTH = *Amanda::Configc::TAPETYPE_LENGTH;
 228 *TAPETYPE_FILEMARK = *Amanda::Configc::TAPETYPE_FILEMARK;
 229 *TAPETYPE_SPEED = *Amanda::Configc::TAPETYPE_SPEED;
 230 *TAPETYPE_PART_SIZE = *Amanda::Configc::TAPETYPE_PART_SIZE;
 231 *TAPETYPE_PART_CACHE_TYPE = *Amanda::Configc::TAPETYPE_PART_CACHE_TYPE;
 232 *TAPETYPE_PART_CACHE_DIR = *Amanda::Configc::TAPETYPE_PART_CACHE_DIR;
 233 *TAPETYPE_PART_CACHE_MAX_SIZE = *Amanda::Configc::TAPETYPE_PART_CACHE_MAX_SIZE;
 234 *DUMPTYPE_COMMENT = *Amanda::Configc::DUMPTYPE_COMMENT;
 235 *DUMPTYPE_PROGRAM = *Amanda::Configc::DUMPTYPE_PROGRAM;
 236 *DUMPTYPE_SRVCOMPPROG = *Amanda::Configc::DUMPTYPE_SRVCOMPPROG;
 237 *DUMPTYPE_CLNTCOMPPROG = *Amanda::Configc::DUMPTYPE_CLNTCOMPPROG;
 238 *DUMPTYPE_SRV_ENCRYPT = *Amanda::Configc::DUMPTYPE_SRV_ENCRYPT;
 239 *DUMPTYPE_CLNT_ENCRYPT = *Amanda::Configc::DUMPTYPE_CLNT_ENCRYPT;
 240 *DUMPTYPE_AMANDAD_PATH = *Amanda::Configc::DUMPTYPE_AMANDAD_PATH;
 241 *DUMPTYPE_CLIENT_USERNAME = *Amanda::Configc::DUMPTYPE_CLIENT_USERNAME;
 242 *DUMPTYPE_CLIENT_PORT = *Amanda::Configc::DUMPTYPE_CLIENT_PORT;
 243 *DUMPTYPE_SSH_KEYS = *Amanda::Configc::DUMPTYPE_SSH_KEYS;
 244 *DUMPTYPE_AUTH = *Amanda::Configc::DUMPTYPE_AUTH;
 245 *DUMPTYPE_EXCLUDE = *Amanda::Configc::DUMPTYPE_EXCLUDE;
 246 *DUMPTYPE_INCLUDE = *Amanda::Configc::DUMPTYPE_INCLUDE;
 247 *DUMPTYPE_PRIORITY = *Amanda::Configc::DUMPTYPE_PRIORITY;
 248 *DUMPTYPE_DUMPCYCLE = *Amanda::Configc::DUMPTYPE_DUMPCYCLE;
 249 *DUMPTYPE_MAXDUMPS = *Amanda::Configc::DUMPTYPE_MAXDUMPS;
 250 *DUMPTYPE_MAXPROMOTEDAY = *Amanda::Configc::DUMPTYPE_MAXPROMOTEDAY;
 251 *DUMPTYPE_BUMPPERCENT = *Amanda::Configc::DUMPTYPE_BUMPPERCENT;
 252 *DUMPTYPE_BUMPSIZE = *Amanda::Configc::DUMPTYPE_BUMPSIZE;
 253 *DUMPTYPE_BUMPDAYS = *Amanda::Configc::DUMPTYPE_BUMPDAYS;
 254 *DUMPTYPE_BUMPMULT = *Amanda::Configc::DUMPTYPE_BUMPMULT;
 255 *DUMPTYPE_STARTTIME = *Amanda::Configc::DUMPTYPE_STARTTIME;
 256 *DUMPTYPE_STRATEGY = *Amanda::Configc::DUMPTYPE_STRATEGY;
 257 *DUMPTYPE_ESTIMATELIST = *Amanda::Configc::DUMPTYPE_ESTIMATELIST;
 258 *DUMPTYPE_COMPRESS = *Amanda::Configc::DUMPTYPE_COMPRESS;
 259 *DUMPTYPE_ENCRYPT = *Amanda::Configc::DUMPTYPE_ENCRYPT;
 260 *DUMPTYPE_SRV_DECRYPT_OPT = *Amanda::Configc::DUMPTYPE_SRV_DECRYPT_OPT;
 261 *DUMPTYPE_CLNT_DECRYPT_OPT = *Amanda::Configc::DUMPTYPE_CLNT_DECRYPT_OPT;
 262 *DUMPTYPE_COMPRATE = *Amanda::Configc::DUMPTYPE_COMPRATE;
 263 *DUMPTYPE_TAPE_SPLITSIZE = *Amanda::Configc::DUMPTYPE_TAPE_SPLITSIZE;
 264 *DUMPTYPE_FALLBACK_SPLITSIZE = *Amanda::Configc::DUMPTYPE_FALLBACK_SPLITSIZE;
 265 *DUMPTYPE_SPLIT_DISKBUFFER = *Amanda::Configc::DUMPTYPE_SPLIT_DISKBUFFER;
 266 *DUMPTYPE_RECORD = *Amanda::Configc::DUMPTYPE_RECORD;
 267 *DUMPTYPE_SKIP_INCR = *Amanda::Configc::DUMPTYPE_SKIP_INCR;
 268 *DUMPTYPE_SKIP_FULL = *Amanda::Configc::DUMPTYPE_SKIP_FULL;
 269 *DUMPTYPE_HOLDINGDISK = *Amanda::Configc::DUMPTYPE_HOLDINGDISK;
 270 *DUMPTYPE_KENCRYPT = *Amanda::Configc::DUMPTYPE_KENCRYPT;
 271 *DUMPTYPE_IGNORE = *Amanda::Configc::DUMPTYPE_IGNORE;
 272 *DUMPTYPE_INDEX = *Amanda::Configc::DUMPTYPE_INDEX;
 273 *DUMPTYPE_APPLICATION = *Amanda::Configc::DUMPTYPE_APPLICATION;
 274 *DUMPTYPE_SCRIPTLIST = *Amanda::Configc::DUMPTYPE_SCRIPTLIST;
 275 *DUMPTYPE_PROPERTY = *Amanda::Configc::DUMPTYPE_PROPERTY;
 276 *DUMPTYPE_DATA_PATH = *Amanda::Configc::DUMPTYPE_DATA_PATH;
 277 *DUMPTYPE_ALLOW_SPLIT = *Amanda::Configc::DUMPTYPE_ALLOW_SPLIT;
 278 *DUMPTYPE_MAX_WARNINGS = *Amanda::Configc::DUMPTYPE_MAX_WARNINGS;
 279 *DUMPTYPE_RECOVERY_LIMIT = *Amanda::Configc::DUMPTYPE_RECOVERY_LIMIT;
 280 *DUMPTYPE_DUMP_LIMIT = *Amanda::Configc::DUMPTYPE_DUMP_LIMIT;
 281 *INTER_COMMENT = *Amanda::Configc::INTER_COMMENT;
 282 *INTER_MAXUSAGE = *Amanda::Configc::INTER_MAXUSAGE;
 283 *HOLDING_COMMENT = *Amanda::Configc::HOLDING_COMMENT;
 284 *HOLDING_DISKDIR = *Amanda::Configc::HOLDING_DISKDIR;
 285 *HOLDING_DISKSIZE = *Amanda::Configc::HOLDING_DISKSIZE;
 286 *HOLDING_CHUNKSIZE = *Amanda::Configc::HOLDING_CHUNKSIZE;
 287 *APPLICATION_COMMENT = *Amanda::Configc::APPLICATION_COMMENT;
 288 *APPLICATION_PLUGIN = *Amanda::Configc::APPLICATION_PLUGIN;
 289 *APPLICATION_PROPERTY = *Amanda::Configc::APPLICATION_PROPERTY;
 290 *APPLICATION_CLIENT_NAME = *Amanda::Configc::APPLICATION_CLIENT_NAME;
 291 *PP_SCRIPT_COMMENT = *Amanda::Configc::PP_SCRIPT_COMMENT;
 292 *PP_SCRIPT_PLUGIN = *Amanda::Configc::PP_SCRIPT_PLUGIN;
 293 *PP_SCRIPT_PROPERTY = *Amanda::Configc::PP_SCRIPT_PROPERTY;
 294 *PP_SCRIPT_EXECUTE_ON = *Amanda::Configc::PP_SCRIPT_EXECUTE_ON;
 295 *PP_SCRIPT_EXECUTE_WHERE = *Amanda::Configc::PP_SCRIPT_EXECUTE_WHERE;
 296 *PP_SCRIPT_ORDER = *Amanda::Configc::PP_SCRIPT_ORDER;
 297 *PP_SCRIPT_SINGLE_EXECUTION = *Amanda::Configc::PP_SCRIPT_SINGLE_EXECUTION;
 298 *PP_SCRIPT_CLIENT_NAME = *Amanda::Configc::PP_SCRIPT_CLIENT_NAME;
 299 *DEVICE_CONFIG_COMMENT = *Amanda::Configc::DEVICE_CONFIG_COMMENT;
 300 *DEVICE_CONFIG_TAPEDEV = *Amanda::Configc::DEVICE_CONFIG_TAPEDEV;
 301 *DEVICE_CONFIG_DEVICE_PROPERTY = *Amanda::Configc::DEVICE_CONFIG_DEVICE_PROPERTY;
 302 *CHANGER_CONFIG_COMMENT = *Amanda::Configc::CHANGER_CONFIG_COMMENT;
 303 *CHANGER_CONFIG_TAPEDEV = *Amanda::Configc::CHANGER_CONFIG_TAPEDEV;
 304 *CHANGER_CONFIG_TPCHANGER = *Amanda::Configc::CHANGER_CONFIG_TPCHANGER;
 305 *CHANGER_CONFIG_CHANGERDEV = *Amanda::Configc::CHANGER_CONFIG_CHANGERDEV;
 306 *CHANGER_CONFIG_CHANGERFILE = *Amanda::Configc::CHANGER_CONFIG_CHANGERFILE;
 307 *CHANGER_CONFIG_PROPERTY = *Amanda::Configc::CHANGER_CONFIG_PROPERTY;
 308 *CHANGER_CONFIG_DEVICE_PROPERTY = *Amanda::Configc::CHANGER_CONFIG_DEVICE_PROPERTY;
 309 *INTERACTIVITY_COMMENT = *Amanda::Configc::INTERACTIVITY_COMMENT;
 310 *INTERACTIVITY_PLUGIN = *Amanda::Configc::INTERACTIVITY_PLUGIN;
 311 *INTERACTIVITY_PROPERTY = *Amanda::Configc::INTERACTIVITY_PROPERTY;
 312 *TAPERSCAN_COMMENT = *Amanda::Configc::TAPERSCAN_COMMENT;
 313 *TAPERSCAN_PLUGIN = *Amanda::Configc::TAPERSCAN_PLUGIN;
 314 *TAPERSCAN_PROPERTY = *Amanda::Configc::TAPERSCAN_PROPERTY;
 315 *HOLD_NEVER = *Amanda::Configc::HOLD_NEVER;
 316 *HOLD_AUTO = *Amanda::Configc::HOLD_AUTO;
 317 *HOLD_REQUIRED = *Amanda::Configc::HOLD_REQUIRED;
 318 *COMP_NONE = *Amanda::Configc::COMP_NONE;
 319 *COMP_FAST = *Amanda::Configc::COMP_FAST;
 320 *COMP_BEST = *Amanda::Configc::COMP_BEST;
 321 *COMP_CUST = *Amanda::Configc::COMP_CUST;
 322 *COMP_SERVER_FAST = *Amanda::Configc::COMP_SERVER_FAST;
 323 *COMP_SERVER_BEST = *Amanda::Configc::COMP_SERVER_BEST;
 324 *COMP_SERVER_CUST = *Amanda::Configc::COMP_SERVER_CUST;
 325 *ENCRYPT_NONE = *Amanda::Configc::ENCRYPT_NONE;
 326 *ENCRYPT_CUST = *Amanda::Configc::ENCRYPT_CUST;
 327 *ENCRYPT_SERV_CUST = *Amanda::Configc::ENCRYPT_SERV_CUST;
 328 *DS_SKIP = *Amanda::Configc::DS_SKIP;
 329 *DS_STANDARD = *Amanda::Configc::DS_STANDARD;
 330 *DS_NOFULL = *Amanda::Configc::DS_NOFULL;
 331 *DS_NOINC = *Amanda::Configc::DS_NOINC;
 332 *DS_4 = *Amanda::Configc::DS_4;
 333 *DS_5 = *Amanda::Configc::DS_5;
 334 *DS_HANOI = *Amanda::Configc::DS_HANOI;
 335 *DS_INCRONLY = *Amanda::Configc::DS_INCRONLY;
 336 *ES_CLIENT = *Amanda::Configc::ES_CLIENT;
 337 *ES_SERVER = *Amanda::Configc::ES_SERVER;
 338 *ES_CALCSIZE = *Amanda::Configc::ES_CALCSIZE;
 339 *AL_OTHER_CONFIG = *Amanda::Configc::AL_OTHER_CONFIG;
 340 *AL_NON_AMANDA = *Amanda::Configc::AL_NON_AMANDA;
 341 *AL_VOLUME_ERROR = *Amanda::Configc::AL_VOLUME_ERROR;
 342 *AL_EMPTY = *Amanda::Configc::AL_EMPTY;
 343 *ALGO_FIRST = *Amanda::Configc::ALGO_FIRST;
 344 *ALGO_FIRSTFIT = *Amanda::Configc::ALGO_FIRSTFIT;
 345 *ALGO_LARGEST = *Amanda::Configc::ALGO_LARGEST;
 346 *ALGO_LARGESTFIT = *Amanda::Configc::ALGO_LARGESTFIT;
 347 *ALGO_SMALLEST = *Amanda::Configc::ALGO_SMALLEST;
 348 *ALGO_LAST = *Amanda::Configc::ALGO_LAST;
 349 *EXECUTE_ON_PRE_AMCHECK = *Amanda::Configc::EXECUTE_ON_PRE_AMCHECK;
 350 *EXECUTE_ON_PRE_DLE_AMCHECK = *Amanda::Configc::EXECUTE_ON_PRE_DLE_AMCHECK;
 351 *EXECUTE_ON_PRE_HOST_AMCHECK = *Amanda::Configc::EXECUTE_ON_PRE_HOST_AMCHECK;
 352 *EXECUTE_ON_POST_AMCHECK = *Amanda::Configc::EXECUTE_ON_POST_AMCHECK;
 353 *EXECUTE_ON_POST_DLE_AMCHECK = *Amanda::Configc::EXECUTE_ON_POST_DLE_AMCHECK;
 354 *EXECUTE_ON_POST_HOST_AMCHECK = *Amanda::Configc::EXECUTE_ON_POST_HOST_AMCHECK;
 355 *EXECUTE_ON_PRE_ESTIMATE = *Amanda::Configc::EXECUTE_ON_PRE_ESTIMATE;
 356 *EXECUTE_ON_PRE_DLE_ESTIMATE = *Amanda::Configc::EXECUTE_ON_PRE_DLE_ESTIMATE;
 357 *EXECUTE_ON_PRE_HOST_ESTIMATE = *Amanda::Configc::EXECUTE_ON_PRE_HOST_ESTIMATE;
 358 *EXECUTE_ON_POST_ESTIMATE = *Amanda::Configc::EXECUTE_ON_POST_ESTIMATE;
 359 *EXECUTE_ON_POST_DLE_ESTIMATE = *Amanda::Configc::EXECUTE_ON_POST_DLE_ESTIMATE;
 360 *EXECUTE_ON_POST_HOST_ESTIMATE = *Amanda::Configc::EXECUTE_ON_POST_HOST_ESTIMATE;
 361 *EXECUTE_ON_PRE_BACKUP = *Amanda::Configc::EXECUTE_ON_PRE_BACKUP;
 362 *EXECUTE_ON_PRE_DLE_BACKUP = *Amanda::Configc::EXECUTE_ON_PRE_DLE_BACKUP;
 363 *EXECUTE_ON_PRE_HOST_BACKUP = *Amanda::Configc::EXECUTE_ON_PRE_HOST_BACKUP;
 364 *EXECUTE_ON_POST_BACKUP = *Amanda::Configc::EXECUTE_ON_POST_BACKUP;
 365 *EXECUTE_ON_POST_DLE_BACKUP = *Amanda::Configc::EXECUTE_ON_POST_DLE_BACKUP;
 366 *EXECUTE_ON_POST_HOST_BACKUP = *Amanda::Configc::EXECUTE_ON_POST_HOST_BACKUP;
 367 *SEND_AMREPORT_ALL = *Amanda::Configc::SEND_AMREPORT_ALL;
 368 *SEND_AMREPORT_STRANGE = *Amanda::Configc::SEND_AMREPORT_STRANGE;
 369 *SEND_AMREPORT_ERROR = *Amanda::Configc::SEND_AMREPORT_ERROR;
 370 *SEND_AMREPORT_NEVER = *Amanda::Configc::SEND_AMREPORT_NEVER;
 371 *DATA_PATH_AMANDA = *Amanda::Configc::DATA_PATH_AMANDA;
 372 *DATA_PATH_DIRECTTCP = *Amanda::Configc::DATA_PATH_DIRECTTCP;
 373 *PART_CACHE_TYPE_NONE = *Amanda::Configc::PART_CACHE_TYPE_NONE;
 374 *PART_CACHE_TYPE_DISK = *Amanda::Configc::PART_CACHE_TYPE_DISK;
 375 *PART_CACHE_TYPE_MEMORY = *Amanda::Configc::PART_CACHE_TYPE_MEMORY;
 376 *debug_amandad = *Amanda::Configc::debug_amandad;
 377 *debug_recovery = *Amanda::Configc::debug_recovery;
 378 *debug_amidxtaped = *Amanda::Configc::debug_amidxtaped;
 379 *debug_amindexd = *Amanda::Configc::debug_amindexd;
 380 *debug_amrecover = *Amanda::Configc::debug_amrecover;
 381 *debug_auth = *Amanda::Configc::debug_auth;
 382 *debug_event = *Amanda::Configc::debug_event;
 383 *debug_holding = *Amanda::Configc::debug_holding;
 384 *debug_protocol = *Amanda::Configc::debug_protocol;
 385 *debug_planner = *Amanda::Configc::debug_planner;
 386 *debug_driver = *Amanda::Configc::debug_driver;
 387 *debug_dumper = *Amanda::Configc::debug_dumper;
 388 *debug_chunker = *Amanda::Configc::debug_chunker;
 389 *debug_taper = *Amanda::Configc::debug_taper;
 390 *debug_selfcheck = *Amanda::Configc::debug_selfcheck;
 391 *debug_sendsize = *Amanda::Configc::debug_sendsize;
 392 *debug_sendbackup = *Amanda::Configc::debug_sendbackup;
 393 *CFGERR_OK = *Amanda::Configc::CFGERR_OK;
 394 *CFGERR_WARNINGS = *Amanda::Configc::CFGERR_WARNINGS;
 395 *CFGERR_ERRORS = *Amanda::Configc::CFGERR_ERRORS;
 396 *CONFIG_INIT_EXPLICIT_NAME = *Amanda::Configc::CONFIG_INIT_EXPLICIT_NAME;
 397 *CONFIG_INIT_USE_CWD = *Amanda::Configc::CONFIG_INIT_USE_CWD;
 398 *CONFIG_INIT_CLIENT = *Amanda::Configc::CONFIG_INIT_CLIENT;
 399 *CONFIG_INIT_OVERLAY = *Amanda::Configc::CONFIG_INIT_OVERLAY;
 400
 401 @EXPORT_OK = ();
 402 %EXPORT_TAGS = ();
 403
 404
 405 =head1 NAME
 406
 407 Amanda::Config - access to Amanda configuration parameters
 408
 409 =head1 SYNOPSIS
 410
 411     use Amanda::Config qw( :init :getconf );
 412
 413     my $config_name = shift @ARGV;
 414     config_init($CONFIG_INIT_EXPLICIT_NAME, $config_name);
 415     apply_config_overrides($config_overrides);
 416     my ($cfgerr_level, @cfgerr_errors) = config_errors();
 417     if ($cfgerr_level >= $CFGERR_WARNINGS) {
 418         config_print_errors();
 419         if ($cfgerr_level >= $CFGERR_ERRORS) {
 420             die("errors processing config file");
 421         }
 422     }
 423
 424     print "tape device is ", getconf($CNF_TAPEDEV), "\n";
 425
 426 This API closely parallels the C API.
 427
 428 =head1 INITIALIZATION
 429
 430 The Amanda configuration is treated as a global state for the
 431 application.  It is not possible to load two configurations
 432 simultaneously.
 433
 434 All initialization-related symbols can be imported with the tag
 435 C<:init>.
 436
 437 =head2 LOADING CONFIGURATION
 438
 439 The Amanda configuration is loaded with the aptly named
 440 C<config_init($flags, $name)>.  Because of the great variety in
 441 invocation method among Amanda applications, this function has a number
 442 of flags that affect its behavior.  These flags can be OR'd together.
 443
 444 =over
 445
 446 =item If C<CONFIG_INIT_EXPLICIT_NAME> is given, then the C<$name> parameter can
 447 contain the name of a configuration to load.  Note that if the parameter is
 448 C<".">, this is equivalent to C<CONFIG_INIT_USE_CWD>.
 449
 450 =item If C<CONFIG_INIT_USE_CWD> is given, and if the current directory
 451 contains C<amanda.conf>, then that file is loaded.
 452
 453 =item If C<CONFIG_INIT_CLIENT> is given, then a client configuration
 454 is loaded.
 455
 456 =item If C<CONFIG_INIT_OVERLAY> is given, then any existing
 457 configuration is not reset.
 458
 459 =back
 460
 461 See C<conffile.h> for more detailed information on these flags and
 462 their interactions.
 463
 464 C<config_uninit()> reverses the effects of C<config_init>.  It is
 465 not often used.
 466
 467 Once the configuration is loaded, the configuration name
 468 (e.g., "DailySet1"), directory (C</etc/amanda/DailySet1>),
 469 and filename (C</etc/amanda/DailySet1/amanda.conf>) are
 470 available from C<get_config_name()>, C<get_config_dir()>, and
 471 C<get_config_filename()>, respectively.
 472
 473 =head3 CONFIG ERRORS
 474
 475 This module collects configuration errors and warnings in a list, and also
 476 tracks the overall error level with an enumeration: C<$CFGERR_OK>,
 477 C<$CFGERR_WARNINGS>, and C<$CFGERR_ERRORS>.  C<config_init> and
 478 C<apply_config_overrides> both return the current level.  The level and the
 479 list of error messages are available from C<config_errors>:
 480
 481   my ($cfgerr_level, @errors) = Amanda::Config::config_errors();
 482
 483 As a convenience, C<config_print_errors> will print all error messages to
 484 stderr.  The error state can be cleared with C<config_clear_errors>.
 485
 486 =head2 CONFIG OVERWRITES
 487
 488 Most Amanda applications accept the command-line option C<-o>
 489 to "overwrite" configuration values in C<amanda.conf>.  In Perl
 490 applications, these options should be parsed with L<Getopt::Long|Getopt::Long>, with
 491 the action being a call to C<add_config_override_opt>.  For example:
 492
 493   my $config_overrides = new_config_overrides($#ARGV+1);
 494     GetOptions(
 495         # ...
 496         'o=s' => sub { add_config_override_opt($config_overrides, $_[1]); },
 497     ) or usage();
 498   my $cfg_ok = config_init($CONFIG_INIT_EXPLICIT_NAME | $CONFIG_INIT_USE_CWD, $config_name);
 499   apply_config_overrides($config_overrides);
 500
 501 C<new_config_overrides($size_estimate)> creates a new
 502 overwrites object, using the given size as an estimate of
 503 the number of items it will contain (C<$#ARGC/2> is a good
 504 estimate).  Individual configuration options are then added via
 505 C<add_config_override($co, $key, $value)> (which takes a key/value
 506 pair) or C<add_config_override_opt($co, $optarg)>, which parses a
 507 string following C<-o> on the command line.
 508
 509 Once the overwrites are gathered, they are applied with
 510 C<apply_config_overrides($co)>, which applies the overwrites to the
 511 active configuration.  No further operations can be performed on the
 512 overwrites object after C<apply_config_overrides> has been called.
 513
 514 The utility function C<get_config_options()> returns a list of
 515 command-line arguments to represent any overwrites that were used
 516 to generate the current configuration.  (TODO: this function isn't
 517 available yet)
 518
 519 =head1 PARAMETER ACCESS
 520
 521 Amanda configurations consist of "global" parameters and several
 522 sets of "subsections" -- one set for dumptypes, one for tapetypes,
 523 and so on.
 524
 525 All of the global parameters are represented by a constant beginning with
 526 C<$CNF_>, e.g., C<$CNF_LABELSTR>.  The function C<getconf($cnf)> returns the
 527 value of parameter C<$cnf>, in whatever format is appropriate for the parameter
 528 (see DATA FORMATS, below).  C<getconf_seen($cnf)> returns a true value if
 529 C<$cnf> was seen in the configuration file.  If it was not seen, then it will
 530 have its default value.  C<getconf_linenum($cnf)> returns the line number in
 531 the configuration file where it is set, 0 if it is not in a configuration file,
 532 or -2 if it is set in a command line argument.
 533
 534 Some parameters have enumerated types.  The values for those
 535 enumerations are available from this module with the same name as
 536 in C<conffile.h>.  For example, C<$CNF_TAPERALGO> will yield a value
 537 from the enumeration C<taperalgo_t>, the constants for which all
 538 begin with C<$ALGO_>.  See C<conffile.h> for the details.
 539
 540 Each subsection type C<TYP> has the following functions:
 541
 542 =over
 543
 544 =item C<lookup_TYP($subsec_name)>
 545
 546 which returns an opaque object
 547 (C<$ss>) representing the subsection, or C<undef> if no subsection
 548 with that name exists;
 549
 550 =item C<TYP_name($ss)>
 551
 552 returning the name of the subsection;
 553
 554 =item C<TYP_getconf($ss, $cnf)>
 555
 556 which fetches a parameter value from C<$ss>; and
 557
 558 =item C<TYP_seen($ss, $cnf)>
 559
 560 which returns a true value if <$cnf> was seen in the subsection.
 561
 562 =back
 563
 564 The subsections are:
 565
 566 =over
 567
 568 =item C<tapetype>
 569
 570 with constants beginning with C<$TAPETYPE_>
 571
 572 =item C<dumptype>
 573
 574 with constants beginning with C<$DUMPTYPE_>
 575
 576 =item C<interface>
 577
 578 with constants beginning with C<$INTER_>
 579
 580 =item C<holdingdisk>
 581
 582 with constants beginning with C<$HOLDING_>
 583
 584 =item C<application>
 585
 586 with constants beginning with C<$APPLICATION_>
 587
 588 =item C<script>
 589
 590 with constants beginning with C<$PP_SCRIPT_>
 591
 592 =item C<device>
 593
 594 with constants beginning with C<$DEVICE_CONFIG_>.
 595
 596 =item C<changer>
 597
 598 with constants beginning with C<$CHANGER_CONFIG_>.
 599
 600 =back
 601
 602 See C<conffile.h> for the names of the constants themselves.
 603
 604 =head2 DATA FORMATS
 605
 606 Each configuration parameter has a "conftype", as assigned in
 607 C<common-src/conffile.c>.  The translation of most of these types into Perl
 608 values is straightforward:
 609
 610   CONFTYPE_INT                        Math::BigInt
 611   CONFTYPE_INT64                      Math::BigInt
 612   CONFTYPE_REAL                       floating-point value
 613   CONFTYPE_STR                        string
 614   CONFTYPE_IDENT                      string
 615   CONFTYPE_TIME                       Math::BigInt (epoch value)
 616   CONFTYPE_SIZE                       Math::BigInt
 617   CONFTYPE_BOOLEAN                    Math::BigInt
 618   CONFTYPE_COMPRESS                   Math::BigInt
 619   CONFTYPE_ENCRYPT                    Math::BigInt
 620   CONFTYPE_HOLDING                    Math::BigInt
 621   CONFTYPE_ESTIMATELIST               [ Math::BigInt, .. ]
 622   CONFTYPE_STRATEGY                   Math::BigInt
 623   CONFTYPE_TAPERALGO                  Math::BigInt
 624   CONFTYPE_PRIORITY                   Math::BigInt
 625   CONFTYPE_RATE                       float, float
 626   CONFTYPE_INTRANGE                   Math::BigInt, Math::BigInt
 627   CONFTYPE_APPLICATION                string
 628   CONFTYPE_EXECUTE_ON                 string
 629   CONFTYPE_EXECUTE_WHERE              Math::BigInt
 630   CONFTYPE_SEND_AMREPORT_ON           Math::BigInt
 631   CONFTYPE_IDENTLIST                  [ string, .. ]
 632   CONFTYPE_PART_CACHE_TYPE            Math::BigInt
 633   CONFTYPE_RECOVERY_LIMIT             [ string, .. ] (undef if not specified;
 634                                             undef in the list means same-host)
 635
 636 Note that C<CONFTYPE_INTRANGE> and C<CONFTYPE_RATE> each return two values, not
 637 an array reference.
 638
 639 Include and exclude lists with type C<CONFTYPE_EXINCLUDE> return a hash giving
 640 all listed filenames (in the C<list> key), include/exclude files (C<files>),
 641 and a boolean indicating that the list is optional (C<optional>):
 642
 643   { list => [ str, .. ], file => [ str, .. ], optional => Math::BigInt }
 644
 645 Properties are represented as a hash of hashes.  The keys are the property
 646 names, converted to ASCII lowercase.  Each property has a C<values> array
 647 giving all values specified for this property, as well as booleans C<priority>
 648 and C<append> that are true if the corresponding keyword was supplied.
 649
 650   { prop1 => { values => [ str, .. ] priority => int, append => int },
 651     prop2 => { .. } .. }
 652
 653 Note that integer types of all sizes become C<Math::BigInt> objects rather than
 654 Perl integers, as is the habit throughout Amanda.
 655
 656 The C<CNF_AUTOLABEL> value is a hash with the following keys
 657
 658   template      label template, or undef
 659   other_config  boolean
 660   non_amanda    boolean
 661   volume_error  boolean
 662   empty         boolean
 663
 664 =head2 OTHER ACCESS
 665
 666 Parameter values are available by name from C<getconf_byname($name)> and
 667 C<getconf_byname_strs($name, $str_needs_quotes)>.  These functions implement
 668 the C<TYP:NAME:PARAM> syntax advertised by C<amgetconf> to access values in
 669 subsections.  The first function returns a Perl value (see DATA FORMATS,
 670 above), while the second returns a list of strings suitable for use in
 671 C<amanda.conf>, including quotes around strings if C<$str_needs_quotes> is
 672 true.
 673
 674 C<getconf_list($typ)> returns a list of the names of all subsections of the
 675 given type.  C<%subsection_names> is a hash whose keys are allowed subsection
 676 names.
 677
 678 =head2 DERIVED VALUES
 679
 680 The C<$CNF_DISPLAYUNIT> implies a certain divisor to convert from
 681 kilobytes to the desired unit.  This divisor is available from
 682 C<getconf_unit_divisor()>.  Note carefully that it is a I<divisor>
 683 for a value in I<kilobytes>!
 684
 685 Finally, various subsections of Amanda enable verbose debugging via
 686 configuration parameters.  The status of each parameter is available
 687 a similarly-named variable, e.g., C<$debug_auth>.
 688
 689 All parameter access functions and constants can be imported with
 690 the tag C<:getconf>.
 691
 692 =head1 MISCELLANEOUS
 693
 694 These functions defy categorization.
 695
 696 The function C<config_dir_relative> will interpret a path relative to
 697 the current configuration directory.  Absolute paths are passed through
 698 unchanged, while relative paths are converted to absolute paths.
 699
 700 C<dump_configuration()> dumps the current configuration, in a format
 701 suitable for re-evaluation for this module, to standard output.
 702 This function may be revised to return a string.
 703
 704 Several parts of Amanda need to convert unit modifier value like
 705 "gbytes" to a multiplier.  The function C<find_multiplier($str)>
 706 returns the unit multiplier for such a string.  For example, "mbytes"
 707 is converted to 1048576 (1024*1024).
 708
 709 C<string_to_boolean()> takes a string and returns 0 if it matches any of
 710 Amanda's names for false, or 1 if matches a name for true. If it can't be
 711 interpreted, C<undef> is returned.
 712
 713 C<amandaify_property_name()> converts a string into Amanda's property style:
 714 all lower-case and with "-" replacing "_".
 715
 716 =head1 CONSTANTS
 717
 718 This section lists all of the configuration parameter constants defined in this
 719 module.  All of these constants are available with the C<:getconf> export tag.
 720
 721 =cut
 722
 723
 724 push @EXPORT_OK, qw(confparm_key_to_string);
 725 push @{$EXPORT_TAGS{"confparm_key"}}, qw(confparm_key_to_string);
 726
 727 my %_confparm_key_VALUES;
 728 #Convert an enum value to a single string
 729 sub confparm_key_to_string {
 730     my ($enumval) = @_;
 731
 732     for my $k (keys %_confparm_key_VALUES) {
 733         my $v = $_confparm_key_VALUES{$k};
 734
 735         #is this a matching flag?
 736         if ($enumval == $v) {
 737             return $k;
 738         }
 739     }
 740
 741 #default, just return the number
 742     return $enumval;
 743 }
 744
 745 push @EXPORT_OK, qw( $CNF_ORG $CNF_CONF $CNF_AMDUMP_SERVER $CNF_INDEX_SERVER $CNF_TAPE_SERVER $CNF_AUTH $CNF_SSH_KEYS $CNF_AMANDAD_PATH $CNF_CLIENT_USERNAME $CNF_CLIENT_PORT $CNF_GNUTAR_LIST_DIR $CNF_AMANDATES $CNF_MAILER $CNF_MAILTO $CNF_DUMPUSER $CNF_TAPEDEV $CNF_DEVICE_PROPERTY $CNF_PROPERTY $CNF_CHANGERDEV $CNF_CHANGERFILE $CNF_LABELSTR $CNF_AUTOLABEL $CNF_META_AUTOLABEL $CNF_TAPELIST $CNF_DISKFILE $CNF_INFOFILE $CNF_LOGDIR $CNF_INDEXDIR $CNF_TAPETYPE $CNF_DUMPCYCLE $CNF_RUNSPERCYCLE $CNF_TAPECYCLE $CNF_NETUSAGE $CNF_INPARALLEL $CNF_DUMPORDER $CNF_BUMPPERCENT $CNF_BUMPSIZE $CNF_BUMPMULT $CNF_BUMPDAYS $CNF_TPCHANGER $CNF_RUNTAPES $CNF_MAX_DLE_BY_VOLUME $CNF_MAXDUMPS $CNF_ETIMEOUT $CNF_DTIMEOUT $CNF_CTIMEOUT $CNF_DEVICE_OUTPUT_BUFFER_SIZE $CNF_PRINTER $CNF_AUTOFLUSH $CNF_RESERVE $CNF_MAXDUMPSIZE $CNF_COLUMNSPEC $CNF_AMRECOVER_DO_FSF $CNF_AMRECOVER_CHECK_LABEL $CNF_AMRECOVER_CHANGER $CNF_TAPERALGO $CNF_FLUSH_THRESHOLD_DUMPED $CNF_FLUSH_THRESHOLD_SCHEDULED $CNF_TAPERFLUSH $CNF_DISPLAYUNIT $CNF_KRB5KEYTAB $CNF_KRB5PRINCIPAL $CNF_LABEL_NEW_TAPES $CNF_USETIMESTAMPS $CNF_REP_TRIES $CNF_CONNECT_TRIES $CNF_REQ_TRIES $CNF_DEBUG_AMANDAD $CNF_DEBUG_RECOVERY $CNF_DEBUG_AMIDXTAPED $CNF_DEBUG_AMINDEXD $CNF_DEBUG_AMRECOVER $CNF_DEBUG_AUTH $CNF_DEBUG_EVENT $CNF_DEBUG_HOLDING $CNF_DEBUG_PROTOCOL $CNF_DEBUG_PLANNER $CNF_DEBUG_DRIVER $CNF_DEBUG_DUMPER $CNF_DEBUG_CHUNKER $CNF_DEBUG_TAPER $CNF_DEBUG_SELFCHECK $CNF_DEBUG_SENDSIZE $CNF_DEBUG_SENDBACKUP $CNF_RESERVED_UDP_PORT $CNF_RESERVED_TCP_PORT $CNF_UNRESERVED_TCP_PORT $CNF_HOLDINGDISK $CNF_SEND_AMREPORT_ON $CNF_TAPER_PARALLEL_WRITE $CNF_RECOVERY_LIMIT  $CNF_INTERACTIVITY  $CNF_TAPERSCAN  $CNF_EJECT_VOLUME  $CNF_TMPDIR  $CNF_REPORT_USE_MEDIA  $CNF_REPORT_NEXT_MEDIA);
 746 push @{$EXPORT_TAGS{"confparm_key"}}, qw( $CNF_ORG $CNF_CONF $CNF_AMDUMP_SERVER $CNF_INDEX_SERVER $CNF_TAPE_SERVER $CNF_AUTH $CNF_SSH_KEYS $CNF_AMANDAD_PATH $CNF_CLIENT_USERNAME $CNF_CLIENT_PORT $CNF_GNUTAR_LIST_DIR $CNF_AMANDATES $CNF_MAILER $CNF_MAILTO $CNF_DUMPUSER $CNF_TAPEDEV $CNF_DEVICE_PROPERTY $CNF_PROPERTY $CNF_CHANGERDEV $CNF_CHANGERFILE $CNF_LABELSTR $CNF_AUTOLABEL $CNF_META_AUTOLABEL $CNF_TAPELIST $CNF_DISKFILE $CNF_INFOFILE $CNF_LOGDIR $CNF_INDEXDIR $CNF_TAPETYPE $CNF_DUMPCYCLE $CNF_RUNSPERCYCLE $CNF_TAPECYCLE $CNF_NETUSAGE $CNF_INPARALLEL $CNF_DUMPORDER $CNF_BUMPPERCENT $CNF_BUMPSIZE $CNF_BUMPMULT $CNF_BUMPDAYS $CNF_TPCHANGER $CNF_RUNTAPES $CNF_MAX_DLE_BY_VOLUME $CNF_MAXDUMPS $CNF_ETIMEOUT $CNF_DTIMEOUT $CNF_CTIMEOUT $CNF_DEVICE_OUTPUT_BUFFER_SIZE $CNF_PRINTER $CNF_AUTOFLUSH $CNF_RESERVE $CNF_MAXDUMPSIZE $CNF_COLUMNSPEC $CNF_AMRECOVER_DO_FSF $CNF_AMRECOVER_CHECK_LABEL $CNF_AMRECOVER_CHANGER $CNF_TAPERALGO $CNF_FLUSH_THRESHOLD_DUMPED $CNF_FLUSH_THRESHOLD_SCHEDULED $CNF_TAPERFLUSH $CNF_DISPLAYUNIT $CNF_KRB5KEYTAB $CNF_KRB5PRINCIPAL $CNF_LABEL_NEW_TAPES $CNF_USETIMESTAMPS $CNF_REP_TRIES $CNF_CONNECT_TRIES $CNF_REQ_TRIES $CNF_DEBUG_AMANDAD $CNF_DEBUG_RECOVERY $CNF_DEBUG_AMIDXTAPED $CNF_DEBUG_AMINDEXD $CNF_DEBUG_AMRECOVER $CNF_DEBUG_AUTH $CNF_DEBUG_EVENT $CNF_DEBUG_HOLDING $CNF_DEBUG_PROTOCOL $CNF_DEBUG_PLANNER $CNF_DEBUG_DRIVER $CNF_DEBUG_DUMPER $CNF_DEBUG_CHUNKER $CNF_DEBUG_TAPER $CNF_DEBUG_SELFCHECK $CNF_DEBUG_SENDSIZE $CNF_DEBUG_SENDBACKUP $CNF_RESERVED_UDP_PORT $CNF_RESERVED_TCP_PORT $CNF_UNRESERVED_TCP_PORT $CNF_HOLDINGDISK $CNF_SEND_AMREPORT_ON $CNF_TAPER_PARALLEL_WRITE $CNF_RECOVERY_LIMIT  $CNF_INTERACTIVITY  $CNF_TAPERSCAN  $CNF_EJECT_VOLUME  $CNF_TMPDIR  $CNF_REPORT_USE_MEDIA  $CNF_REPORT_NEXT_MEDIA);
 747       foreach (qw(  CNF_ORG CNF_CONF CNF_AMDUMP_SERVER CNF_INDEX_SERVER CNF_TAPE_SERVER CNF_AUTH CNF_SSH_KEYS CNF_AMANDAD_PATH CNF_CLIENT_USERNAME CNF_CLIENT_PORT CNF_GNUTAR_LIST_DIR CNF_AMANDATES CNF_MAILER CNF_MAILTO CNF_DUMPUSER CNF_TAPEDEV CNF_DEVICE_PROPERTY CNF_PROPERTY CNF_CHANGERDEV CNF_CHANGERFILE CNF_LABELSTR CNF_AUTOLABEL CNF_META_AUTOLABEL CNF_TAPELIST CNF_DISKFILE CNF_INFOFILE CNF_LOGDIR CNF_INDEXDIR CNF_TAPETYPE CNF_DUMPCYCLE CNF_RUNSPERCYCLE CNF_TAPECYCLE CNF_NETUSAGE CNF_INPARALLEL CNF_DUMPORDER CNF_BUMPPERCENT CNF_BUMPSIZE CNF_BUMPMULT CNF_BUMPDAYS CNF_TPCHANGER CNF_RUNTAPES CNF_MAX_DLE_BY_VOLUME CNF_MAXDUMPS CNF_ETIMEOUT CNF_DTIMEOUT CNF_CTIMEOUT CNF_DEVICE_OUTPUT_BUFFER_SIZE CNF_PRINTER CNF_AUTOFLUSH CNF_RESERVE CNF_MAXDUMPSIZE CNF_COLUMNSPEC CNF_AMRECOVER_DO_FSF CNF_AMRECOVER_CHECK_LABEL CNF_AMRECOVER_CHANGER CNF_TAPERALGO CNF_FLUSH_THRESHOLD_DUMPED CNF_FLUSH_THRESHOLD_SCHEDULED CNF_TAPERFLUSH CNF_DISPLAYUNIT CNF_KRB5KEYTAB CNF_KRB5PRINCIPAL CNF_LABEL_NEW_TAPES CNF_USETIMESTAMPS CNF_REP_TRIES CNF_CONNECT_TRIES CNF_REQ_TRIES CNF_DEBUG_AMANDAD CNF_DEBUG_RECOVERY CNF_DEBUG_AMIDXTAPED CNF_DEBUG_AMINDEXD CNF_DEBUG_AMRECOVER CNF_DEBUG_AUTH CNF_DEBUG_EVENT CNF_DEBUG_HOLDING CNF_DEBUG_PROTOCOL CNF_DEBUG_PLANNER CNF_DEBUG_DRIVER CNF_DEBUG_DUMPER CNF_DEBUG_CHUNKER CNF_DEBUG_TAPER CNF_DEBUG_SELFCHECK CNF_DEBUG_SENDSIZE CNF_DEBUG_SENDBACKUP CNF_RESERVED_UDP_PORT CNF_RESERVED_TCP_PORT CNF_UNRESERVED_TCP_PORT CNF_HOLDINGDISK CNF_SEND_AMREPORT_ON CNF_TAPER_PARALLEL_WRITE CNF_RECOVERY_LIMIT  CNF_INTERACTIVITY  CNF_TAPERSCAN  CNF_EJECT_VOLUME  CNF_TMPDIR  CNF_REPORT_USE_MEDIA  CNF_REPORT_NEXT_MEDIA)) {        $_confparm_key_VALUES{$_} = $$_;      }
 748 #copy symbols in confparm_key to getconf
 749 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"confparm_key"}};
 750
 751
 752 use Amanda::Config::FoldingHash;
 753
 754 =pod
 755
 756 Global Parameters:       C<$CNF_ORG> C<$CNF_CONF> C<$CNF_AMDUMP_SERVER> C<$CNF_INDEX_SERVER> C<$CNF_TAPE_SERVER> C<$CNF_AUTH> C<$CNF_SSH_KEYS> C<$CNF_AMANDAD_PATH> C<$CNF_CLIENT_USERNAME> C<$CNF_CLIENT_PORT> C<$CNF_GNUTAR_LIST_DIR> C<$CNF_AMANDATES> C<$CNF_MAILER> C<$CNF_MAILTO> C<$CNF_DUMPUSER> C<$CNF_TAPEDEV> C<$CNF_DEVICE_PROPERTY> C<$CNF_PROPERTY> C<$CNF_CHANGERDEV> C<$CNF_CHANGERFILE> C<$CNF_LABELSTR> C<$CNF_AUTOLABEL> C<$CNF_META_AUTOLABEL> C<$CNF_TAPELIST> C<$CNF_DISKFILE> C<$CNF_INFOFILE> C<$CNF_LOGDIR> C<$CNF_INDEXDIR> C<$CNF_TAPETYPE> C<$CNF_DUMPCYCLE> C<$CNF_RUNSPERCYCLE> C<$CNF_TAPECYCLE> C<$CNF_NETUSAGE> C<$CNF_INPARALLEL> C<$CNF_DUMPORDER> C<$CNF_BUMPPERCENT> C<$CNF_BUMPSIZE> C<$CNF_BUMPMULT> C<$CNF_BUMPDAYS> C<$CNF_TPCHANGER> C<$CNF_RUNTAPES> C<$CNF_MAX_DLE_BY_VOLUME> C<$CNF_MAXDUMPS> C<$CNF_ETIMEOUT> C<$CNF_DTIMEOUT> C<$CNF_CTIMEOUT> C<$CNF_DEVICE_OUTPUT_BUFFER_SIZE> C<$CNF_PRINTER> C<$CNF_AUTOFLUSH> C<$CNF_RESERVE> C<$CNF_MAXDUMPSIZE> C<$CNF_COLUMNSPEC> C<$CNF_AMRECOVER_DO_FSF> C<$CNF_AMRECOVER_CHECK_LABEL> C<$CNF_AMRECOVER_CHANGER> C<$CNF_TAPERALGO> C<$CNF_FLUSH_THRESHOLD_DUMPED> C<$CNF_FLUSH_THRESHOLD_SCHEDULED> C<$CNF_TAPERFLUSH> C<$CNF_DISPLAYUNIT> C<$CNF_KRB5KEYTAB> C<$CNF_KRB5PRINCIPAL> C<$CNF_LABEL_NEW_TAPES> C<$CNF_USETIMESTAMPS> C<$CNF_REP_TRIES> C<$CNF_CONNECT_TRIES> C<$CNF_REQ_TRIES> C<$CNF_DEBUG_AMANDAD> C<$CNF_DEBUG_RECOVERY> C<$CNF_DEBUG_AMIDXTAPED> C<$CNF_DEBUG_AMINDEXD> C<$CNF_DEBUG_AMRECOVER> C<$CNF_DEBUG_AUTH> C<$CNF_DEBUG_EVENT> C<$CNF_DEBUG_HOLDING> C<$CNF_DEBUG_PROTOCOL> C<$CNF_DEBUG_PLANNER> C<$CNF_DEBUG_DRIVER> C<$CNF_DEBUG_DUMPER> C<$CNF_DEBUG_CHUNKER> C<$CNF_DEBUG_TAPER> C<$CNF_DEBUG_SELFCHECK> C<$CNF_DEBUG_SENDSIZE> C<$CNF_DEBUG_SENDBACKUP> C<$CNF_RESERVED_UDP_PORT> C<$CNF_RESERVED_TCP_PORT> C<$CNF_UNRESERVED_TCP_PORT> C<$CNF_HOLDINGDISK> C<$CNF_SEND_AMREPORT_ON> C<$CNF_TAPER_PARALLEL_WRITE> C<$CNF_RECOVERY_LIMIT>  C<$CNF_INTERACTIVITY>  C<$CNF_TAPERSCAN>  C<$CNF_EJECT_VOLUME>  C<$CNF_TMPDIR>  C<$CNF_REPORT_USE_MEDIA>  C<$CNF_REPORT_NEXT_MEDIA>
 757
 758 =cut
 759
 760 push @EXPORT_OK, qw(tapetype_key_to_string);
 761 push @{$EXPORT_TAGS{"tapetype_key"}}, qw(tapetype_key_to_string);
 762
 763 my %_tapetype_key_VALUES;
 764 #Convert an enum value to a single string
 765 sub tapetype_key_to_string {
 766     my ($enumval) = @_;
 767
 768     for my $k (keys %_tapetype_key_VALUES) {
 769         my $v = $_tapetype_key_VALUES{$k};
 770
 771         #is this a matching flag?
 772         if ($enumval == $v) {
 773             return $k;
 774         }
 775     }
 776
 777 #default, just return the number
 778     return $enumval;
 779 }
 780
 781 push @EXPORT_OK, qw( $TAPETYPE_COMMENT $TAPETYPE_LBL_TEMPL $TAPETYPE_BLOCKSIZE $TAPETYPE_READBLOCKSIZE $TAPETYPE_LENGTH $TAPETYPE_FILEMARK $TAPETYPE_SPEED $TAPETYPE_PART_SIZE $TAPETYPE_PART_CACHE_TYPE $TAPETYPE_PART_CACHE_DIR $TAPETYPE_PART_CACHE_MAX_SIZE);
 782 push @{$EXPORT_TAGS{"tapetype_key"}}, qw( $TAPETYPE_COMMENT $TAPETYPE_LBL_TEMPL $TAPETYPE_BLOCKSIZE $TAPETYPE_READBLOCKSIZE $TAPETYPE_LENGTH $TAPETYPE_FILEMARK $TAPETYPE_SPEED $TAPETYPE_PART_SIZE $TAPETYPE_PART_CACHE_TYPE $TAPETYPE_PART_CACHE_DIR $TAPETYPE_PART_CACHE_MAX_SIZE);
 783       foreach (qw(  TAPETYPE_COMMENT TAPETYPE_LBL_TEMPL TAPETYPE_BLOCKSIZE TAPETYPE_READBLOCKSIZE TAPETYPE_LENGTH TAPETYPE_FILEMARK TAPETYPE_SPEED TAPETYPE_PART_SIZE TAPETYPE_PART_CACHE_TYPE TAPETYPE_PART_CACHE_DIR TAPETYPE_PART_CACHE_MAX_SIZE)) {         $_tapetype_key_VALUES{$_} = $$_;      }
 784 #copy symbols in tapetype_key to getconf
 785 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"tapetype_key"}};
 786
 787
 788 use Amanda::Config::FoldingHash;
 789
 790 =pod
 791
 792 Tapetype Parameters:       C<$TAPETYPE_COMMENT> C<$TAPETYPE_LBL_TEMPL> C<$TAPETYPE_BLOCKSIZE> C<$TAPETYPE_READBLOCKSIZE> C<$TAPETYPE_LENGTH> C<$TAPETYPE_FILEMARK> C<$TAPETYPE_SPEED> C<$TAPETYPE_PART_SIZE> C<$TAPETYPE_PART_CACHE_TYPE> C<$TAPETYPE_PART_CACHE_DIR> C<$TAPETYPE_PART_CACHE_MAX_SIZE>
 793
 794 =cut
 795
 796 push @EXPORT_OK, qw(dumptype_key_to_string);
 797 push @{$EXPORT_TAGS{"dumptype_key"}}, qw(dumptype_key_to_string);
 798
 799 my %_dumptype_key_VALUES;
 800 #Convert an enum value to a single string
 801 sub dumptype_key_to_string {
 802     my ($enumval) = @_;
 803
 804     for my $k (keys %_dumptype_key_VALUES) {
 805         my $v = $_dumptype_key_VALUES{$k};
 806
 807         #is this a matching flag?
 808         if ($enumval == $v) {
 809             return $k;
 810         }
 811     }
 812
 813 #default, just return the number
 814     return $enumval;
 815 }
 816
 817 push @EXPORT_OK, qw( $DUMPTYPE_COMMENT $DUMPTYPE_PROGRAM $DUMPTYPE_SRVCOMPPROG $DUMPTYPE_CLNTCOMPPROG $DUMPTYPE_SRV_ENCRYPT $DUMPTYPE_CLNT_ENCRYPT $DUMPTYPE_AMANDAD_PATH $DUMPTYPE_CLIENT_USERNAME $DUMPTYPE_CLIENT_PORT $DUMPTYPE_SSH_KEYS $DUMPTYPE_AUTH $DUMPTYPE_EXCLUDE $DUMPTYPE_INCLUDE $DUMPTYPE_PRIORITY $DUMPTYPE_DUMPCYCLE $DUMPTYPE_MAXDUMPS $DUMPTYPE_MAXPROMOTEDAY $DUMPTYPE_BUMPPERCENT $DUMPTYPE_BUMPSIZE $DUMPTYPE_BUMPDAYS $DUMPTYPE_BUMPMULT $DUMPTYPE_STARTTIME $DUMPTYPE_STRATEGY $DUMPTYPE_ESTIMATELIST $DUMPTYPE_COMPRESS $DUMPTYPE_ENCRYPT $DUMPTYPE_SRV_DECRYPT_OPT $DUMPTYPE_CLNT_DECRYPT_OPT $DUMPTYPE_COMPRATE $DUMPTYPE_TAPE_SPLITSIZE $DUMPTYPE_FALLBACK_SPLITSIZE $DUMPTYPE_SPLIT_DISKBUFFER $DUMPTYPE_RECORD $DUMPTYPE_SKIP_INCR $DUMPTYPE_SKIP_FULL $DUMPTYPE_HOLDINGDISK $DUMPTYPE_KENCRYPT $DUMPTYPE_IGNORE $DUMPTYPE_INDEX $DUMPTYPE_APPLICATION $DUMPTYPE_SCRIPTLIST $DUMPTYPE_PROPERTY $DUMPTYPE_DATA_PATH $DUMPTYPE_ALLOW_SPLIT $DUMPTYPE_MAX_WARNINGS $DUMPTYPE_RECOVERY_LIMIT  $DUMPTYPE_DUMP_LIMIT);
 818 push @{$EXPORT_TAGS{"dumptype_key"}}, qw( $DUMPTYPE_COMMENT $DUMPTYPE_PROGRAM $DUMPTYPE_SRVCOMPPROG $DUMPTYPE_CLNTCOMPPROG $DUMPTYPE_SRV_ENCRYPT $DUMPTYPE_CLNT_ENCRYPT $DUMPTYPE_AMANDAD_PATH $DUMPTYPE_CLIENT_USERNAME $DUMPTYPE_CLIENT_PORT $DUMPTYPE_SSH_KEYS $DUMPTYPE_AUTH $DUMPTYPE_EXCLUDE $DUMPTYPE_INCLUDE $DUMPTYPE_PRIORITY $DUMPTYPE_DUMPCYCLE $DUMPTYPE_MAXDUMPS $DUMPTYPE_MAXPROMOTEDAY $DUMPTYPE_BUMPPERCENT $DUMPTYPE_BUMPSIZE $DUMPTYPE_BUMPDAYS $DUMPTYPE_BUMPMULT $DUMPTYPE_STARTTIME $DUMPTYPE_STRATEGY $DUMPTYPE_ESTIMATELIST $DUMPTYPE_COMPRESS $DUMPTYPE_ENCRYPT $DUMPTYPE_SRV_DECRYPT_OPT $DUMPTYPE_CLNT_DECRYPT_OPT $DUMPTYPE_COMPRATE $DUMPTYPE_TAPE_SPLITSIZE $DUMPTYPE_FALLBACK_SPLITSIZE $DUMPTYPE_SPLIT_DISKBUFFER $DUMPTYPE_RECORD $DUMPTYPE_SKIP_INCR $DUMPTYPE_SKIP_FULL $DUMPTYPE_HOLDINGDISK $DUMPTYPE_KENCRYPT $DUMPTYPE_IGNORE $DUMPTYPE_INDEX $DUMPTYPE_APPLICATION $DUMPTYPE_SCRIPTLIST $DUMPTYPE_PROPERTY $DUMPTYPE_DATA_PATH $DUMPTYPE_ALLOW_SPLIT $DUMPTYPE_MAX_WARNINGS $DUMPTYPE_RECOVERY_LIMIT  $DUMPTYPE_DUMP_LIMIT);
 819       foreach (qw(  DUMPTYPE_COMMENT DUMPTYPE_PROGRAM DUMPTYPE_SRVCOMPPROG DUMPTYPE_CLNTCOMPPROG DUMPTYPE_SRV_ENCRYPT DUMPTYPE_CLNT_ENCRYPT DUMPTYPE_AMANDAD_PATH DUMPTYPE_CLIENT_USERNAME DUMPTYPE_CLIENT_PORT DUMPTYPE_SSH_KEYS DUMPTYPE_AUTH DUMPTYPE_EXCLUDE DUMPTYPE_INCLUDE DUMPTYPE_PRIORITY DUMPTYPE_DUMPCYCLE DUMPTYPE_MAXDUMPS DUMPTYPE_MAXPROMOTEDAY DUMPTYPE_BUMPPERCENT DUMPTYPE_BUMPSIZE DUMPTYPE_BUMPDAYS DUMPTYPE_BUMPMULT DUMPTYPE_STARTTIME DUMPTYPE_STRATEGY DUMPTYPE_ESTIMATELIST DUMPTYPE_COMPRESS DUMPTYPE_ENCRYPT DUMPTYPE_SRV_DECRYPT_OPT DUMPTYPE_CLNT_DECRYPT_OPT DUMPTYPE_COMPRATE DUMPTYPE_TAPE_SPLITSIZE DUMPTYPE_FALLBACK_SPLITSIZE DUMPTYPE_SPLIT_DISKBUFFER DUMPTYPE_RECORD DUMPTYPE_SKIP_INCR DUMPTYPE_SKIP_FULL DUMPTYPE_HOLDINGDISK DUMPTYPE_KENCRYPT DUMPTYPE_IGNORE DUMPTYPE_INDEX DUMPTYPE_APPLICATION DUMPTYPE_SCRIPTLIST DUMPTYPE_PROPERTY DUMPTYPE_DATA_PATH DUMPTYPE_ALLOW_SPLIT DUMPTYPE_MAX_WARNINGS DUMPTYPE_RECOVERY_LIMIT  DUMPTYPE_DUMP_LIMIT)) {       $_dumptype_key_VALUES{$_} = $$_;      }
 820 #copy symbols in dumptype_key to getconf
 821 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"dumptype_key"}};
 822
 823
 824 use Amanda::Config::FoldingHash;
 825
 826 =pod
 827
 828 Dumptype Parameters:       C<$DUMPTYPE_COMMENT> C<$DUMPTYPE_PROGRAM> C<$DUMPTYPE_SRVCOMPPROG> C<$DUMPTYPE_CLNTCOMPPROG> C<$DUMPTYPE_SRV_ENCRYPT> C<$DUMPTYPE_CLNT_ENCRYPT> C<$DUMPTYPE_AMANDAD_PATH> C<$DUMPTYPE_CLIENT_USERNAME> C<$DUMPTYPE_CLIENT_PORT> C<$DUMPTYPE_SSH_KEYS> C<$DUMPTYPE_AUTH> C<$DUMPTYPE_EXCLUDE> C<$DUMPTYPE_INCLUDE> C<$DUMPTYPE_PRIORITY> C<$DUMPTYPE_DUMPCYCLE> C<$DUMPTYPE_MAXDUMPS> C<$DUMPTYPE_MAXPROMOTEDAY> C<$DUMPTYPE_BUMPPERCENT> C<$DUMPTYPE_BUMPSIZE> C<$DUMPTYPE_BUMPDAYS> C<$DUMPTYPE_BUMPMULT> C<$DUMPTYPE_STARTTIME> C<$DUMPTYPE_STRATEGY> C<$DUMPTYPE_ESTIMATELIST> C<$DUMPTYPE_COMPRESS> C<$DUMPTYPE_ENCRYPT> C<$DUMPTYPE_SRV_DECRYPT_OPT> C<$DUMPTYPE_CLNT_DECRYPT_OPT> C<$DUMPTYPE_COMPRATE> C<$DUMPTYPE_TAPE_SPLITSIZE> C<$DUMPTYPE_FALLBACK_SPLITSIZE> C<$DUMPTYPE_SPLIT_DISKBUFFER> C<$DUMPTYPE_RECORD> C<$DUMPTYPE_SKIP_INCR> C<$DUMPTYPE_SKIP_FULL> C<$DUMPTYPE_HOLDINGDISK> C<$DUMPTYPE_KENCRYPT> C<$DUMPTYPE_IGNORE> C<$DUMPTYPE_INDEX> C<$DUMPTYPE_APPLICATION> C<$DUMPTYPE_SCRIPTLIST> C<$DUMPTYPE_PROPERTY> C<$DUMPTYPE_DATA_PATH> C<$DUMPTYPE_ALLOW_SPLIT> C<$DUMPTYPE_MAX_WARNINGS> C<$DUMPTYPE_RECOVERY_LIMIT>  C<$DUMPTYPE_DUMP_LIMIT>
 829
 830 =cut
 831
 832 push @EXPORT_OK, qw(interface_key_to_string);
 833 push @{$EXPORT_TAGS{"interface_key"}}, qw(interface_key_to_string);
 834
 835 my %_interface_key_VALUES;
 836 #Convert an enum value to a single string
 837 sub interface_key_to_string {
 838     my ($enumval) = @_;
 839
 840     for my $k (keys %_interface_key_VALUES) {
 841         my $v = $_interface_key_VALUES{$k};
 842
 843         #is this a matching flag?
 844         if ($enumval == $v) {
 845             return $k;
 846         }
 847     }
 848
 849 #default, just return the number
 850     return $enumval;
 851 }
 852
 853 push @EXPORT_OK, qw( $INTER_COMMENT $INTER_MAXUSAGE);
 854 push @{$EXPORT_TAGS{"interface_key"}}, qw( $INTER_COMMENT $INTER_MAXUSAGE);
 855       foreach (qw(  INTER_COMMENT INTER_MAXUSAGE)) {    $_interface_key_VALUES{$_} = $$_;      }
 856 #copy symbols in interface_key to getconf
 857 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"interface_key"}};
 858
 859
 860 use Amanda::Config::FoldingHash;
 861
 862 =pod
 863
 864 Dumptype Parameters:       C<$INTER_COMMENT> C<$INTER_MAXUSAGE>
 865
 866 =cut
 867
 868 push @EXPORT_OK, qw(holdingdisk_key_to_string);
 869 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw(holdingdisk_key_to_string);
 870
 871 my %_holdingdisk_key_VALUES;
 872 #Convert an enum value to a single string
 873 sub holdingdisk_key_to_string {
 874     my ($enumval) = @_;
 875
 876     for my $k (keys %_holdingdisk_key_VALUES) {
 877         my $v = $_holdingdisk_key_VALUES{$k};
 878
 879         #is this a matching flag?
 880         if ($enumval == $v) {
 881             return $k;
 882         }
 883     }
 884
 885 #default, just return the number
 886     return $enumval;
 887 }
 888
 889 push @EXPORT_OK, qw( $HOLDING_COMMENT $HOLDING_DISKDIR $HOLDING_DISKSIZE $HOLDING_CHUNKSIZE);
 890 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw( $HOLDING_COMMENT $HOLDING_DISKDIR $HOLDING_DISKSIZE $HOLDING_CHUNKSIZE);
 891       foreach (qw(  HOLDING_COMMENT HOLDING_DISKDIR HOLDING_DISKSIZE HOLDING_CHUNKSIZE)) {      $_holdingdisk_key_VALUES{$_} = $$_;      }
 892 #copy symbols in holdingdisk_key to getconf
 893 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"holdingdisk_key"}};
 894
 895
 896 use Amanda::Config::FoldingHash;
 897
 898 =pod
 899
 900 Holdingdisk Parameters:       C<$HOLDING_COMMENT> C<$HOLDING_DISKDIR> C<$HOLDING_DISKSIZE> C<$HOLDING_CHUNKSIZE>
 901
 902 =cut
 903
 904 push @EXPORT_OK, qw(application_key_to_string);
 905 push @{$EXPORT_TAGS{"application_key"}}, qw(application_key_to_string);
 906
 907 my %_application_key_VALUES;
 908 #Convert an enum value to a single string
 909 sub application_key_to_string {
 910     my ($enumval) = @_;
 911
 912     for my $k (keys %_application_key_VALUES) {
 913         my $v = $_application_key_VALUES{$k};
 914
 915         #is this a matching flag?
 916         if ($enumval == $v) {
 917             return $k;
 918         }
 919     }
 920
 921 #default, just return the number
 922     return $enumval;
 923 }
 924
 925 push @EXPORT_OK, qw( $APPLICATION_COMMENT $APPLICATION_PLUGIN $APPLICATION_PROPERTY  $APPLICATION_CLIENT_NAME);
 926 push @{$EXPORT_TAGS{"application_key"}}, qw( $APPLICATION_COMMENT $APPLICATION_PLUGIN $APPLICATION_PROPERTY  $APPLICATION_CLIENT_NAME);
 927       foreach (qw(  APPLICATION_COMMENT APPLICATION_PLUGIN APPLICATION_PROPERTY  APPLICATION_CLIENT_NAME)) {    $_application_key_VALUES{$_} = $$_;      }
 928 #copy symbols in application_key to getconf
 929 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"application_key"}};
 930
 931
 932 use Amanda::Config::FoldingHash;
 933
 934 =pod
 935
 936 Application Parameters:       C<$APPLICATION_COMMENT> C<$APPLICATION_PLUGIN> C<$APPLICATION_PROPERTY>  C<$APPLICATION_CLIENT_NAME>
 937
 938 =cut
 939
 940 push @EXPORT_OK, qw(pp_script_key_to_string);
 941 push @{$EXPORT_TAGS{"pp_script_key"}}, qw(pp_script_key_to_string);
 942
 943 my %_pp_script_key_VALUES;
 944 #Convert an enum value to a single string
 945 sub pp_script_key_to_string {
 946     my ($enumval) = @_;
 947
 948     for my $k (keys %_pp_script_key_VALUES) {
 949         my $v = $_pp_script_key_VALUES{$k};
 950
 951         #is this a matching flag?
 952         if ($enumval == $v) {
 953             return $k;
 954         }
 955     }
 956
 957 #default, just return the number
 958     return $enumval;
 959 }
 960
 961 push @EXPORT_OK, qw( $PP_SCRIPT_COMMENT $PP_SCRIPT_PLUGIN $PP_SCRIPT_PROPERTY $PP_SCRIPT_EXECUTE_ON $PP_SCRIPT_EXECUTE_WHERE $PP_SCRIPT_ORDER $PP_SCRIPT_SINGLE_EXECUTION $PP_SCRIPT_CLIENT_NAME);
 962 push @{$EXPORT_TAGS{"pp_script_key"}}, qw( $PP_SCRIPT_COMMENT $PP_SCRIPT_PLUGIN $PP_SCRIPT_PROPERTY $PP_SCRIPT_EXECUTE_ON $PP_SCRIPT_EXECUTE_WHERE $PP_SCRIPT_ORDER $PP_SCRIPT_SINGLE_EXECUTION $PP_SCRIPT_CLIENT_NAME);
 963       foreach (qw(  PP_SCRIPT_COMMENT PP_SCRIPT_PLUGIN PP_SCRIPT_PROPERTY PP_SCRIPT_EXECUTE_ON PP_SCRIPT_EXECUTE_WHERE PP_SCRIPT_ORDER PP_SCRIPT_SINGLE_EXECUTION PP_SCRIPT_CLIENT_NAME)) {     $_pp_script_key_VALUES{$_} = $$_;      }
 964 #copy symbols in pp_script_key to getconf
 965 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"pp_script_key"}};
 966
 967
 968 use Amanda::Config::FoldingHash;
 969
 970 =pod
 971
 972 Pre/Post-Script Parameters:       C<$PP_SCRIPT_COMMENT> C<$PP_SCRIPT_PLUGIN> C<$PP_SCRIPT_PROPERTY> C<$PP_SCRIPT_EXECUTE_ON> C<$PP_SCRIPT_EXECUTE_WHERE> C<$PP_SCRIPT_ORDER> C<$PP_SCRIPT_SINGLE_EXECUTION> C<$PP_SCRIPT_CLIENT_NAME>
 973
 974 =cut
 975
 976 push @EXPORT_OK, qw(device_config_key_to_string);
 977 push @{$EXPORT_TAGS{"device_config_key"}}, qw(device_config_key_to_string);
 978
 979 my %_device_config_key_VALUES;
 980 #Convert an enum value to a single string
 981 sub device_config_key_to_string {
 982     my ($enumval) = @_;
 983
 984     for my $k (keys %_device_config_key_VALUES) {
 985         my $v = $_device_config_key_VALUES{$k};
 986
 987         #is this a matching flag?
 988         if ($enumval == $v) {
 989             return $k;
 990         }
 991     }
 992
 993 #default, just return the number
 994     return $enumval;
 995 }
 996
 997 push @EXPORT_OK, qw( $DEVICE_CONFIG_COMMENT $DEVICE_CONFIG_TAPEDEV $DEVICE_CONFIG_DEVICE_PROPERTY);
 998 push @{$EXPORT_TAGS{"device_config_key"}}, qw( $DEVICE_CONFIG_COMMENT $DEVICE_CONFIG_TAPEDEV $DEVICE_CONFIG_DEVICE_PROPERTY);
 999       foreach (qw(  DEVICE_CONFIG_COMMENT DEVICE_CONFIG_TAPEDEV DEVICE_CONFIG_DEVICE_PROPERTY)) {       $_device_config_key_VALUES{$_} = $$_;      }
1000 #copy symbols in device_config_key to getconf
1001 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"device_config_key"}};
1002
1003
1004 use Amanda::Config::FoldingHash;
1005
1006 =pod
1007
1008 Pre/Post-Script Parameters:       C<$DEVICE_CONFIG_COMMENT> C<$DEVICE_CONFIG_TAPEDEV> C<$DEVICE_CONFIG_DEVICE_PROPERTY>
1009
1010 =cut
1011
1012 push @EXPORT_OK, qw(changer_config_key_to_string);
1013 push @{$EXPORT_TAGS{"changer_config_key"}}, qw(changer_config_key_to_string);
1014
1015 my %_changer_config_key_VALUES;
1016 #Convert an enum value to a single string
1017 sub changer_config_key_to_string {
1018     my ($enumval) = @_;
1019
1020     for my $k (keys %_changer_config_key_VALUES) {
1021         my $v = $_changer_config_key_VALUES{$k};
1022
1023         #is this a matching flag?
1024         if ($enumval == $v) {
1025             return $k;
1026         }
1027     }
1028
1029 #default, just return the number
1030     return $enumval;
1031 }
1032
1033 push @EXPORT_OK, qw( $CHANGER_CONFIG_COMMENT $CHANGER_CONFIG_TAPEDEV $CHANGER_CONFIG_TPCHANGER $CHANGER_CONFIG_CHANGERDEV $CHANGER_CONFIG_CHANGERFILE $CHANGER_CONFIG_PROPERTY $CHANGER_CONFIG_DEVICE_PROPERTY);
1034 push @{$EXPORT_TAGS{"changer_config_key"}}, qw( $CHANGER_CONFIG_COMMENT $CHANGER_CONFIG_TAPEDEV $CHANGER_CONFIG_TPCHANGER $CHANGER_CONFIG_CHANGERDEV $CHANGER_CONFIG_CHANGERFILE $CHANGER_CONFIG_PROPERTY $CHANGER_CONFIG_DEVICE_PROPERTY);
1035       foreach (qw(  CHANGER_CONFIG_COMMENT CHANGER_CONFIG_TAPEDEV CHANGER_CONFIG_TPCHANGER CHANGER_CONFIG_CHANGERDEV CHANGER_CONFIG_CHANGERFILE CHANGER_CONFIG_PROPERTY CHANGER_CONFIG_DEVICE_PROPERTY)) {      $_changer_config_key_VALUES{$_} = $$_;      }
1036 #copy symbols in changer_config_key to getconf
1037 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"changer_config_key"}};
1038
1039
1040 use Amanda::Config::FoldingHash;
1041
1042 =pod
1043
1044 Pre/Post-Script Parameters:       C<$CHANGER_CONFIG_COMMENT> C<$CHANGER_CONFIG_TAPEDEV> C<$CHANGER_CONFIG_TPCHANGER> C<$CHANGER_CONFIG_CHANGERDEV> C<$CHANGER_CONFIG_CHANGERFILE> C<$CHANGER_CONFIG_PROPERTY> C<$CHANGER_CONFIG_DEVICE_PROPERTY>
1045
1046 =cut
1047
1048 push @EXPORT_OK, qw(interactivity_key_to_string);
1049 push @{$EXPORT_TAGS{"interactivity_key"}}, qw(interactivity_key_to_string);
1050
1051 my %_interactivity_key_VALUES;
1052 #Convert an enum value to a single string
1053 sub interactivity_key_to_string {
1054     my ($enumval) = @_;
1055
1056     for my $k (keys %_interactivity_key_VALUES) {
1057         my $v = $_interactivity_key_VALUES{$k};
1058
1059         #is this a matching flag?
1060         if ($enumval == $v) {
1061             return $k;
1062         }
1063     }
1064
1065 #default, just return the number
1066     return $enumval;
1067 }
1068
1069 push @EXPORT_OK, qw( $INTERACTIVITY_COMMENT $INTERACTIVITY_PLUGIN $INTERACTIVITY_PROPERTY);
1070 push @{$EXPORT_TAGS{"interactivity_key"}}, qw( $INTERACTIVITY_COMMENT $INTERACTIVITY_PLUGIN $INTERACTIVITY_PROPERTY);
1071       foreach (qw(  INTERACTIVITY_COMMENT INTERACTIVITY_PLUGIN INTERACTIVITY_PROPERTY)) {       $_interactivity_key_VALUES{$_} = $$_;      }
1072 #copy symbols in interactivity_key to getconf
1073 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"interactivity_key"}};
1074
1075
1076 use Amanda::Config::FoldingHash;
1077
1078 =pod
1079
1080 Interactivity Parameters:       C<$INTERACTIVITY_COMMENT> C<$INTERACTIVITY_PLUGIN> C<$INTERACTIVITY_PROPERTY>
1081
1082 =cut
1083
1084 push @EXPORT_OK, qw(taperscan_key_to_string);
1085 push @{$EXPORT_TAGS{"taperscan_key"}}, qw(taperscan_key_to_string);
1086
1087 my %_taperscan_key_VALUES;
1088 #Convert an enum value to a single string
1089 sub taperscan_key_to_string {
1090     my ($enumval) = @_;
1091
1092     for my $k (keys %_taperscan_key_VALUES) {
1093         my $v = $_taperscan_key_VALUES{$k};
1094
1095         #is this a matching flag?
1096         if ($enumval == $v) {
1097             return $k;
1098         }
1099     }
1100
1101 #default, just return the number
1102     return $enumval;
1103 }
1104
1105 push @EXPORT_OK, qw( $TAPERSCAN_COMMENT $TAPERSCAN_PLUGIN $TAPERSCAN_PROPERTY);
1106 push @{$EXPORT_TAGS{"taperscan_key"}}, qw( $TAPERSCAN_COMMENT $TAPERSCAN_PLUGIN $TAPERSCAN_PROPERTY);
1107       foreach (qw(  TAPERSCAN_COMMENT TAPERSCAN_PLUGIN TAPERSCAN_PROPERTY)) {   $_taperscan_key_VALUES{$_} = $$_;      }
1108 #copy symbols in taperscan_key to getconf
1109 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"taperscan_key"}};
1110
1111
1112 use Amanda::Config::FoldingHash;
1113
1114 =pod
1115
1116 Taperscan Parameters:       C<$TAPERSCAN_COMMENT> C<$TAPERSCAN_PLUGIN> C<$TAPERSCAN_PROPERTY>
1117
1118 =cut
1119
1120 push @EXPORT_OK, qw(dump_holdingdisk_t_to_string);
1121 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw(dump_holdingdisk_t_to_string);
1122
1123 my %_dump_holdingdisk_t_VALUES;
1124 #Convert an enum value to a single string
1125 sub dump_holdingdisk_t_to_string {
1126     my ($enumval) = @_;
1127
1128     for my $k (keys %_dump_holdingdisk_t_VALUES) {
1129         my $v = $_dump_holdingdisk_t_VALUES{$k};
1130
1131         #is this a matching flag?
1132         if ($enumval == $v) {
1133             return $k;
1134         }
1135     }
1136
1137 #default, just return the number
1138     return $enumval;
1139 }
1140
1141 push @EXPORT_OK, qw($HOLD_NEVER);
1142 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw($HOLD_NEVER);
1143
1144 $_dump_holdingdisk_t_VALUES{"HOLD_NEVER"} = $HOLD_NEVER;
1145
1146 push @EXPORT_OK, qw($HOLD_AUTO);
1147 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw($HOLD_AUTO);
1148
1149 $_dump_holdingdisk_t_VALUES{"HOLD_AUTO"} = $HOLD_AUTO;
1150
1151 push @EXPORT_OK, qw($HOLD_REQUIRED);
1152 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw($HOLD_REQUIRED);
1153
1154 $_dump_holdingdisk_t_VALUES{"HOLD_REQUIRED"} = $HOLD_REQUIRED;
1155
1156 #copy symbols in dump_holdingdisk_t to getconf
1157 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"dump_holdingdisk_t"}};
1158
1159 push @EXPORT_OK, qw(comp_t_to_string);
1160 push @{$EXPORT_TAGS{"comp_t"}}, qw(comp_t_to_string);
1161
1162 my %_comp_t_VALUES;
1163 #Convert an enum value to a single string
1164 sub comp_t_to_string {
1165     my ($enumval) = @_;
1166
1167     for my $k (keys %_comp_t_VALUES) {
1168         my $v = $_comp_t_VALUES{$k};
1169
1170         #is this a matching flag?
1171         if ($enumval == $v) {
1172             return $k;
1173         }
1174     }
1175
1176 #default, just return the number
1177     return $enumval;
1178 }
1179
1180 push @EXPORT_OK, qw($COMP_NONE);
1181 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_NONE);
1182
1183 $_comp_t_VALUES{"COMP_NONE"} = $COMP_NONE;
1184
1185 push @EXPORT_OK, qw($COMP_FAST);
1186 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_FAST);
1187
1188 $_comp_t_VALUES{"COMP_FAST"} = $COMP_FAST;
1189
1190 push @EXPORT_OK, qw($COMP_BEST);
1191 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_BEST);
1192
1193 $_comp_t_VALUES{"COMP_BEST"} = $COMP_BEST;
1194
1195 push @EXPORT_OK, qw($COMP_CUST);
1196 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_CUST);
1197
1198 $_comp_t_VALUES{"COMP_CUST"} = $COMP_CUST;
1199
1200 push @EXPORT_OK, qw($COMP_SERVER_FAST);
1201 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_SERVER_FAST);
1202
1203 $_comp_t_VALUES{"COMP_SERVER_FAST"} = $COMP_SERVER_FAST;
1204
1205 push @EXPORT_OK, qw($COMP_SERVER_BEST);
1206 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_SERVER_BEST);
1207
1208 $_comp_t_VALUES{"COMP_SERVER_BEST"} = $COMP_SERVER_BEST;
1209
1210 push @EXPORT_OK, qw($COMP_SERVER_CUST);
1211 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_SERVER_CUST);
1212
1213 $_comp_t_VALUES{"COMP_SERVER_CUST"} = $COMP_SERVER_CUST;
1214
1215 #copy symbols in comp_t to getconf
1216 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"comp_t"}};
1217
1218 push @EXPORT_OK, qw(encrypt_t_to_string);
1219 push @{$EXPORT_TAGS{"encrypt_t"}}, qw(encrypt_t_to_string);
1220
1221 my %_encrypt_t_VALUES;
1222 #Convert an enum value to a single string
1223 sub encrypt_t_to_string {
1224     my ($enumval) = @_;
1225
1226     for my $k (keys %_encrypt_t_VALUES) {
1227         my $v = $_encrypt_t_VALUES{$k};
1228
1229         #is this a matching flag?
1230         if ($enumval == $v) {
1231             return $k;
1232         }
1233     }
1234
1235 #default, just return the number
1236     return $enumval;
1237 }
1238
1239 push @EXPORT_OK, qw($ENCRYPT_NONE);
1240 push @{$EXPORT_TAGS{"encrypt_t"}}, qw($ENCRYPT_NONE);
1241
1242 $_encrypt_t_VALUES{"ENCRYPT_NONE"} = $ENCRYPT_NONE;
1243
1244 push @EXPORT_OK, qw($ENCRYPT_CUST);
1245 push @{$EXPORT_TAGS{"encrypt_t"}}, qw($ENCRYPT_CUST);
1246
1247 $_encrypt_t_VALUES{"ENCRYPT_CUST"} = $ENCRYPT_CUST;
1248
1249 push @EXPORT_OK, qw($ENCRYPT_SERV_CUST);
1250 push @{$EXPORT_TAGS{"encrypt_t"}}, qw($ENCRYPT_SERV_CUST);
1251
1252 $_encrypt_t_VALUES{"ENCRYPT_SERV_CUST"} = $ENCRYPT_SERV_CUST;
1253
1254 #copy symbols in encrypt_t to getconf
1255 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"encrypt_t"}};
1256
1257 push @EXPORT_OK, qw(strategy_t_to_string);
1258 push @{$EXPORT_TAGS{"strategy_t"}}, qw(strategy_t_to_string);
1259
1260 my %_strategy_t_VALUES;
1261 #Convert an enum value to a single string
1262 sub strategy_t_to_string {
1263     my ($enumval) = @_;
1264
1265     for my $k (keys %_strategy_t_VALUES) {
1266         my $v = $_strategy_t_VALUES{$k};
1267
1268         #is this a matching flag?
1269         if ($enumval == $v) {
1270             return $k;
1271         }
1272     }
1273
1274 #default, just return the number
1275     return $enumval;
1276 }
1277
1278 push @EXPORT_OK, qw($DS_SKIP);
1279 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_SKIP);
1280
1281 $_strategy_t_VALUES{"DS_SKIP"} = $DS_SKIP;
1282
1283 push @EXPORT_OK, qw($DS_STANDARD);
1284 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_STANDARD);
1285
1286 $_strategy_t_VALUES{"DS_STANDARD"} = $DS_STANDARD;
1287
1288 push @EXPORT_OK, qw($DS_NOFULL);
1289 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_NOFULL);
1290
1291 $_strategy_t_VALUES{"DS_NOFULL"} = $DS_NOFULL;
1292
1293 push @EXPORT_OK, qw($DS_NOINC);
1294 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_NOINC);
1295
1296 $_strategy_t_VALUES{"DS_NOINC"} = $DS_NOINC;
1297
1298 push @EXPORT_OK, qw($DS_4);
1299 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_4);
1300
1301 $_strategy_t_VALUES{"DS_4"} = $DS_4;
1302
1303 push @EXPORT_OK, qw($DS_5);
1304 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_5);
1305
1306 $_strategy_t_VALUES{"DS_5"} = $DS_5;
1307
1308 push @EXPORT_OK, qw($DS_HANOI);
1309 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_HANOI);
1310
1311 $_strategy_t_VALUES{"DS_HANOI"} = $DS_HANOI;
1312
1313 push @EXPORT_OK, qw($DS_INCRONLY);
1314 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_INCRONLY);
1315
1316 $_strategy_t_VALUES{"DS_INCRONLY"} = $DS_INCRONLY;
1317
1318 #copy symbols in strategy_t to getconf
1319 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"strategy_t"}};
1320
1321 push @EXPORT_OK, qw(estimate_t_to_string);
1322 push @{$EXPORT_TAGS{"estimate_t"}}, qw(estimate_t_to_string);
1323
1324 my %_estimate_t_VALUES;
1325 #Convert an enum value to a single string
1326 sub estimate_t_to_string {
1327     my ($enumval) = @_;
1328
1329     for my $k (keys %_estimate_t_VALUES) {
1330         my $v = $_estimate_t_VALUES{$k};
1331
1332         #is this a matching flag?
1333         if ($enumval == $v) {
1334             return $k;
1335         }
1336     }
1337
1338 #default, just return the number
1339     return $enumval;
1340 }
1341
1342 push @EXPORT_OK, qw($ES_CLIENT);
1343 push @{$EXPORT_TAGS{"estimate_t"}}, qw($ES_CLIENT);
1344
1345 $_estimate_t_VALUES{"ES_CLIENT"} = $ES_CLIENT;
1346
1347 push @EXPORT_OK, qw($ES_SERVER);
1348 push @{$EXPORT_TAGS{"estimate_t"}}, qw($ES_SERVER);
1349
1350 $_estimate_t_VALUES{"ES_SERVER"} = $ES_SERVER;
1351
1352 push @EXPORT_OK, qw($ES_CALCSIZE);
1353 push @{$EXPORT_TAGS{"estimate_t"}}, qw($ES_CALCSIZE);
1354
1355 $_estimate_t_VALUES{"ES_CALCSIZE"} = $ES_CALCSIZE;
1356
1357 #copy symbols in estimate_t to getconf
1358 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"estimate_t"}};
1359
1360 push @EXPORT_OK, qw(autolabel_enum_t_to_string);
1361 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw(autolabel_enum_t_to_string);
1362
1363 my %_autolabel_enum_t_VALUES;
1364 #Convert an enum value to a single string
1365 sub autolabel_enum_t_to_string {
1366     my ($enumval) = @_;
1367
1368     for my $k (keys %_autolabel_enum_t_VALUES) {
1369         my $v = $_autolabel_enum_t_VALUES{$k};
1370
1371         #is this a matching flag?
1372         if ($enumval == $v) {
1373             return $k;
1374         }
1375     }
1376
1377 #default, just return the number
1378     return $enumval;
1379 }
1380
1381 push @EXPORT_OK, qw($AL_OTHER_CONFIG);
1382 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_OTHER_CONFIG);
1383
1384 $_autolabel_enum_t_VALUES{"AL_OTHER_CONFIG"} = $AL_OTHER_CONFIG;
1385
1386 push @EXPORT_OK, qw($AL_NON_AMANDA);
1387 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_NON_AMANDA);
1388
1389 $_autolabel_enum_t_VALUES{"AL_NON_AMANDA"} = $AL_NON_AMANDA;
1390
1391 push @EXPORT_OK, qw($AL_VOLUME_ERROR);
1392 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_VOLUME_ERROR);
1393
1394 $_autolabel_enum_t_VALUES{"AL_VOLUME_ERROR"} = $AL_VOLUME_ERROR;
1395
1396 push @EXPORT_OK, qw($AL_EMPTY);
1397 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_EMPTY);
1398
1399 $_autolabel_enum_t_VALUES{"AL_EMPTY"} = $AL_EMPTY;
1400
1401 #copy symbols in autolabel_enum_t to getconf
1402 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"autolabel_enum_t"}};
1403
1404 push @EXPORT_OK, qw(taperalgo_t_to_string);
1405 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw(taperalgo_t_to_string);
1406
1407 my %_taperalgo_t_VALUES;
1408 #Convert an enum value to a single string
1409 sub taperalgo_t_to_string {
1410     my ($enumval) = @_;
1411
1412     for my $k (keys %_taperalgo_t_VALUES) {
1413         my $v = $_taperalgo_t_VALUES{$k};
1414
1415         #is this a matching flag?
1416         if ($enumval == $v) {
1417             return $k;
1418         }
1419     }
1420
1421 #default, just return the number
1422     return $enumval;
1423 }
1424
1425 push @EXPORT_OK, qw($ALGO_FIRST);
1426 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_FIRST);
1427
1428 $_taperalgo_t_VALUES{"ALGO_FIRST"} = $ALGO_FIRST;
1429
1430 push @EXPORT_OK, qw($ALGO_FIRSTFIT);
1431 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_FIRSTFIT);
1432
1433 $_taperalgo_t_VALUES{"ALGO_FIRSTFIT"} = $ALGO_FIRSTFIT;
1434
1435 push @EXPORT_OK, qw($ALGO_LARGEST);
1436 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_LARGEST);
1437
1438 $_taperalgo_t_VALUES{"ALGO_LARGEST"} = $ALGO_LARGEST;
1439
1440 push @EXPORT_OK, qw($ALGO_LARGESTFIT);
1441 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_LARGESTFIT);
1442
1443 $_taperalgo_t_VALUES{"ALGO_LARGESTFIT"} = $ALGO_LARGESTFIT;
1444
1445 push @EXPORT_OK, qw($ALGO_SMALLEST);
1446 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_SMALLEST);
1447
1448 $_taperalgo_t_VALUES{"ALGO_SMALLEST"} = $ALGO_SMALLEST;
1449
1450 push @EXPORT_OK, qw($ALGO_LAST);
1451 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_LAST);
1452
1453 $_taperalgo_t_VALUES{"ALGO_LAST"} = $ALGO_LAST;
1454
1455 #copy symbols in taperalgo_t to getconf
1456 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"taperalgo_t"}};
1457
1458 push @EXPORT_OK, qw(execute_on_t_to_string);
1459 push @{$EXPORT_TAGS{"execute_on_t"}}, qw(execute_on_t_to_string);
1460
1461 my %_execute_on_t_VALUES;
1462 #Convert an enum value to a single string
1463 sub execute_on_t_to_string {
1464     my ($enumval) = @_;
1465
1466     for my $k (keys %_execute_on_t_VALUES) {
1467         my $v = $_execute_on_t_VALUES{$k};
1468
1469         #is this a matching flag?
1470         if ($enumval == $v) {
1471             return $k;
1472         }
1473     }
1474
1475 #default, just return the number
1476     return $enumval;
1477 }
1478
1479 push @EXPORT_OK, qw($EXECUTE_ON_PRE_AMCHECK);
1480 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_AMCHECK);
1481
1482 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_AMCHECK"} = $EXECUTE_ON_PRE_AMCHECK;
1483
1484 push @EXPORT_OK, qw($EXECUTE_ON_PRE_DLE_AMCHECK);
1485 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_DLE_AMCHECK);
1486
1487 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_DLE_AMCHECK"} = $EXECUTE_ON_PRE_DLE_AMCHECK;
1488
1489 push @EXPORT_OK, qw($EXECUTE_ON_PRE_HOST_AMCHECK);
1490 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_HOST_AMCHECK);
1491
1492 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_HOST_AMCHECK"} = $EXECUTE_ON_PRE_HOST_AMCHECK;
1493
1494 push @EXPORT_OK, qw($EXECUTE_ON_POST_AMCHECK);
1495 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_AMCHECK);
1496
1497 $_execute_on_t_VALUES{"EXECUTE_ON_POST_AMCHECK"} = $EXECUTE_ON_POST_AMCHECK;
1498
1499 push @EXPORT_OK, qw($EXECUTE_ON_POST_DLE_AMCHECK);
1500 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_DLE_AMCHECK);
1501
1502 $_execute_on_t_VALUES{"EXECUTE_ON_POST_DLE_AMCHECK"} = $EXECUTE_ON_POST_DLE_AMCHECK;
1503
1504 push @EXPORT_OK, qw($EXECUTE_ON_POST_HOST_AMCHECK);
1505 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_HOST_AMCHECK);
1506
1507 $_execute_on_t_VALUES{"EXECUTE_ON_POST_HOST_AMCHECK"} = $EXECUTE_ON_POST_HOST_AMCHECK;
1508
1509 push @EXPORT_OK, qw($EXECUTE_ON_PRE_ESTIMATE);
1510 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_ESTIMATE);
1511
1512 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_ESTIMATE"} = $EXECUTE_ON_PRE_ESTIMATE;
1513
1514 push @EXPORT_OK, qw($EXECUTE_ON_PRE_DLE_ESTIMATE);
1515 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_DLE_ESTIMATE);
1516
1517 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_DLE_ESTIMATE"} = $EXECUTE_ON_PRE_DLE_ESTIMATE;
1518
1519 push @EXPORT_OK, qw($EXECUTE_ON_PRE_HOST_ESTIMATE);
1520 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_HOST_ESTIMATE);
1521
1522 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_HOST_ESTIMATE"} = $EXECUTE_ON_PRE_HOST_ESTIMATE;
1523
1524 push @EXPORT_OK, qw($EXECUTE_ON_POST_ESTIMATE);
1525 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_ESTIMATE);
1526
1527 $_execute_on_t_VALUES{"EXECUTE_ON_POST_ESTIMATE"} = $EXECUTE_ON_POST_ESTIMATE;
1528
1529 push @EXPORT_OK, qw($EXECUTE_ON_POST_DLE_ESTIMATE);
1530 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_DLE_ESTIMATE);
1531
1532 $_execute_on_t_VALUES{"EXECUTE_ON_POST_DLE_ESTIMATE"} = $EXECUTE_ON_POST_DLE_ESTIMATE;
1533
1534 push @EXPORT_OK, qw($EXECUTE_ON_POST_HOST_ESTIMATE);
1535 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_HOST_ESTIMATE);
1536
1537 $_execute_on_t_VALUES{"EXECUTE_ON_POST_HOST_ESTIMATE"} = $EXECUTE_ON_POST_HOST_ESTIMATE;
1538
1539 push @EXPORT_OK, qw($EXECUTE_ON_PRE_BACKUP);
1540 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_BACKUP);
1541
1542 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_BACKUP"} = $EXECUTE_ON_PRE_BACKUP;
1543
1544 push @EXPORT_OK, qw($EXECUTE_ON_PRE_DLE_BACKUP);
1545 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_DLE_BACKUP);
1546
1547 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_DLE_BACKUP"} = $EXECUTE_ON_PRE_DLE_BACKUP;
1548
1549 push @EXPORT_OK, qw($EXECUTE_ON_PRE_HOST_BACKUP);
1550 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_HOST_BACKUP);
1551
1552 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_HOST_BACKUP"} = $EXECUTE_ON_PRE_HOST_BACKUP;
1553
1554 push @EXPORT_OK, qw($EXECUTE_ON_POST_BACKUP);
1555 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_BACKUP);
1556
1557 $_execute_on_t_VALUES{"EXECUTE_ON_POST_BACKUP"} = $EXECUTE_ON_POST_BACKUP;
1558
1559 push @EXPORT_OK, qw($EXECUTE_ON_POST_DLE_BACKUP);
1560 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_DLE_BACKUP);
1561
1562 $_execute_on_t_VALUES{"EXECUTE_ON_POST_DLE_BACKUP"} = $EXECUTE_ON_POST_DLE_BACKUP;
1563
1564 push @EXPORT_OK, qw($EXECUTE_ON_POST_HOST_BACKUP);
1565 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_HOST_BACKUP);
1566
1567 $_execute_on_t_VALUES{"EXECUTE_ON_POST_HOST_BACKUP"} = $EXECUTE_ON_POST_HOST_BACKUP;
1568
1569 #copy symbols in execute_on_t to getconf
1570 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"execute_on_t"}};
1571
1572 push @EXPORT_OK, qw(send_amreport_on_t_to_string);
1573 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw(send_amreport_on_t_to_string);
1574
1575 my %_send_amreport_on_t_VALUES;
1576 #Convert an enum value to a single string
1577 sub send_amreport_on_t_to_string {
1578     my ($enumval) = @_;
1579
1580     for my $k (keys %_send_amreport_on_t_VALUES) {
1581         my $v = $_send_amreport_on_t_VALUES{$k};
1582
1583         #is this a matching flag?
1584         if ($enumval == $v) {
1585             return $k;
1586         }
1587     }
1588
1589 #default, just return the number
1590     return $enumval;
1591 }
1592
1593 push @EXPORT_OK, qw($SEND_AMREPORT_ALL);
1594 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_ALL);
1595
1596 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_ALL"} = $SEND_AMREPORT_ALL;
1597
1598 push @EXPORT_OK, qw($SEND_AMREPORT_STRANGE);
1599 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_STRANGE);
1600
1601 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_STRANGE"} = $SEND_AMREPORT_STRANGE;
1602
1603 push @EXPORT_OK, qw($SEND_AMREPORT_ERROR);
1604 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_ERROR);
1605
1606 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_ERROR"} = $SEND_AMREPORT_ERROR;
1607
1608 push @EXPORT_OK, qw($SEND_AMREPORT_NEVER);
1609 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_NEVER);
1610
1611 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_NEVER"} = $SEND_AMREPORT_NEVER;
1612
1613 #copy symbols in send_amreport_on_t to getconf
1614 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"send_amreport_on_t"}};
1615
1616 push @EXPORT_OK, qw(data_path_t_to_string);
1617 push @{$EXPORT_TAGS{"data_path_t"}}, qw(data_path_t_to_string);
1618
1619 my %_data_path_t_VALUES;
1620 #Convert an enum value to a single string
1621 sub data_path_t_to_string {
1622     my ($enumval) = @_;
1623
1624     for my $k (keys %_data_path_t_VALUES) {
1625         my $v = $_data_path_t_VALUES{$k};
1626
1627         #is this a matching flag?
1628         if ($enumval == $v) {
1629             return $k;
1630         }
1631     }
1632
1633 #default, just return the number
1634     return $enumval;
1635 }
1636
1637 push @EXPORT_OK, qw($DATA_PATH_AMANDA);
1638 push @{$EXPORT_TAGS{"data_path_t"}}, qw($DATA_PATH_AMANDA);
1639
1640 $_data_path_t_VALUES{"DATA_PATH_AMANDA"} = $DATA_PATH_AMANDA;
1641
1642 push @EXPORT_OK, qw($DATA_PATH_DIRECTTCP);
1643 push @{$EXPORT_TAGS{"data_path_t"}}, qw($DATA_PATH_DIRECTTCP);
1644
1645 $_data_path_t_VALUES{"DATA_PATH_DIRECTTCP"} = $DATA_PATH_DIRECTTCP;
1646
1647 #copy symbols in data_path_t to getconf
1648 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"data_path_t"}};
1649
1650 push @EXPORT_OK, qw(part_cache_type_t_to_string);
1651 push @{$EXPORT_TAGS{"part_cache_type_t"}}, qw(part_cache_type_t_to_string);
1652
1653 my %_part_cache_type_t_VALUES;
1654 #Convert an enum value to a single string
1655 sub part_cache_type_t_to_string {
1656     my ($enumval) = @_;
1657
1658     for my $k (keys %_part_cache_type_t_VALUES) {
1659         my $v = $_part_cache_type_t_VALUES{$k};
1660
1661         #is this a matching flag?
1662         if ($enumval == $v) {
1663             return $k;
1664         }
1665     }
1666
1667 #default, just return the number
1668     return $enumval;
1669 }
1670
1671 push @EXPORT_OK, qw($PART_CACHE_TYPE_NONE);
1672 push @{$EXPORT_TAGS{"part_cache_type_t"}}, qw($PART_CACHE_TYPE_NONE);
1673
1674 $_part_cache_type_t_VALUES{"PART_CACHE_TYPE_NONE"} = $PART_CACHE_TYPE_NONE;
1675
1676 push @EXPORT_OK, qw($PART_CACHE_TYPE_DISK);
1677 push @{$EXPORT_TAGS{"part_cache_type_t"}}, qw($PART_CACHE_TYPE_DISK);
1678
1679 $_part_cache_type_t_VALUES{"PART_CACHE_TYPE_DISK"} = $PART_CACHE_TYPE_DISK;
1680
1681 push @EXPORT_OK, qw($PART_CACHE_TYPE_MEMORY);
1682 push @{$EXPORT_TAGS{"part_cache_type_t"}}, qw($PART_CACHE_TYPE_MEMORY);
1683
1684 $_part_cache_type_t_VALUES{"PART_CACHE_TYPE_MEMORY"} = $PART_CACHE_TYPE_MEMORY;
1685
1686 #copy symbols in part_cache_type_t to getconf
1687 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"part_cache_type_t"}};
1688
1689 $LIMIT_SAMEHOST="SAMEHOST-SAMEHOST-SAMEHOST";
1690 $LIMIT_SERVER="SERVER-SERVER-SERVER";
1691
1692 push @EXPORT_OK, qw(getconf getconf_seen getconf_linenum
1693     getconf_byname getconf_byname_strs
1694     getconf_list);
1695 push @{$EXPORT_TAGS{"getconf"}}, qw(getconf getconf_seen getconf_linenum
1696     getconf_byname getconf_byname_strs
1697     getconf_list);
1698
1699 push @EXPORT_OK, qw(lookup_tapetype tapetype_getconf tapetype_name
1700     tapetype_seen tapetype_seen);
1701 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_tapetype tapetype_getconf tapetype_name
1702     tapetype_seen tapetype_seen);
1703
1704 push @EXPORT_OK, qw(lookup_dumptype dumptype_getconf dumptype_name
1705     dumptype_seen dumptype_seen);
1706 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_dumptype dumptype_getconf dumptype_name
1707     dumptype_seen dumptype_seen);
1708
1709 push @EXPORT_OK, qw(lookup_interface interface_getconf interface_name
1710     interface_seen interface_seen);
1711 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_interface interface_getconf interface_name
1712     interface_seen interface_seen);
1713
1714 push @EXPORT_OK, qw(lookup_holdingdisk holdingdisk_getconf holdingdisk_name
1715     getconf_holdingdisks
1716     holdingdisk_seen holdingdisk_seen);
1717 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_holdingdisk holdingdisk_getconf holdingdisk_name
1718     getconf_holdingdisks
1719     holdingdisk_seen holdingdisk_seen);
1720
1721 push @EXPORT_OK, qw(lookup_application application_getconf application_name
1722     application_seen application_seen);
1723 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_application application_getconf application_name
1724     application_seen application_seen);
1725
1726 push @EXPORT_OK, qw(lookup_pp_script pp_script_getconf pp_script_name
1727     pp_script_seen pp_script_seen);
1728 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_pp_script pp_script_getconf pp_script_name
1729     pp_script_seen pp_script_seen);
1730
1731 push @EXPORT_OK, qw(lookup_device_config device_config_getconf device_config_name
1732     device_config_seen device_config_seen);
1733 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_device_config device_config_getconf device_config_name
1734     device_config_seen device_config_seen);
1735
1736 push @EXPORT_OK, qw(lookup_changer_config changer_config_getconf changer_config_name
1737     changer_config_seen changer_config_seen);
1738 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_changer_config changer_config_getconf changer_config_name
1739     changer_config_seen changer_config_seen);
1740
1741 push @EXPORT_OK, qw(lookup_interactivity interactivity_getconf interactivity_name
1742     interactivity_seen interactivity_seen);
1743 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_interactivity interactivity_getconf interactivity_name
1744     interactivity_seen interactivity_seen);
1745
1746 push @EXPORT_OK, qw(lookup_taperscan taperscan_getconf taperscan_name
1747     taperscan_seen taperscan_seen);
1748 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_taperscan taperscan_getconf taperscan_name
1749     taperscan_seen taperscan_seen);
1750
1751 # only those keys with a value of '1' should be shown; the
1752 # others are deprecated
1753 our %subsection_names = (
1754     "tapetype" => 1,
1755     "dumptype" => 1,
1756     "interface" => 1,
1757     "holdingdisk" => 1,
1758     "application" => 1,
1759     "script" => 1,
1760     "application-tool" => 0,
1761     "script-tool" => 0,
1762     "device" => 1,
1763     "changer" => 1,
1764 );
1765
1766 push @EXPORT_OK, qw(%subsection_names);
1767 push @{$EXPORT_TAGS{"getconf"}}, qw(%subsection_names);
1768
1769 push @EXPORT_OK, qw(getconf_unit_divisor
1770
1771     $debug_amandad $debug_recovery $debug_amidxtaped $debug_amindexd $debug_amrecover
1772     $debug_auth $debug_event $debug_holding $debug_protocol
1773     $debug_planner $debug_driver $debug_dumper $debug_chunker
1774     $debug_taper $debug_selfcheck $debug_sendsize $debug_sendbackup);
1775 push @{$EXPORT_TAGS{"getconf"}}, qw(getconf_unit_divisor
1776
1777     $debug_amandad $debug_recovery $debug_amidxtaped $debug_amindexd $debug_amrecover
1778     $debug_auth $debug_event $debug_holding $debug_protocol
1779     $debug_planner $debug_driver $debug_dumper $debug_chunker
1780     $debug_taper $debug_selfcheck $debug_sendsize $debug_sendbackup);
1781
1782 push @EXPORT_OK, qw(cfgerr_level_t_to_string);
1783 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw(cfgerr_level_t_to_string);
1784
1785 my %_cfgerr_level_t_VALUES;
1786 #Convert an enum value to a single string
1787 sub cfgerr_level_t_to_string {
1788     my ($enumval) = @_;
1789
1790     for my $k (keys %_cfgerr_level_t_VALUES) {
1791         my $v = $_cfgerr_level_t_VALUES{$k};
1792
1793         #is this a matching flag?
1794         if ($enumval == $v) {
1795             return $k;
1796         }
1797     }
1798
1799 #default, just return the number
1800     return $enumval;
1801 }
1802
1803 push @EXPORT_OK, qw($CFGERR_OK);
1804 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw($CFGERR_OK);
1805
1806 $_cfgerr_level_t_VALUES{"CFGERR_OK"} = $CFGERR_OK;
1807
1808 push @EXPORT_OK, qw($CFGERR_WARNINGS);
1809 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw($CFGERR_WARNINGS);
1810
1811 $_cfgerr_level_t_VALUES{"CFGERR_WARNINGS"} = $CFGERR_WARNINGS;
1812
1813 push @EXPORT_OK, qw($CFGERR_ERRORS);
1814 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw($CFGERR_ERRORS);
1815
1816 $_cfgerr_level_t_VALUES{"CFGERR_ERRORS"} = $CFGERR_ERRORS;
1817
1818 #copy symbols in cfgerr_level_t to init
1819 push @{$EXPORT_TAGS{"init"}},  @{$EXPORT_TAGS{"cfgerr_level_t"}};
1820
1821 push @EXPORT_OK, qw(config_init_flags_to_strings);
1822 push @{$EXPORT_TAGS{"config_init_flags"}}, qw(config_init_flags_to_strings);
1823
1824 my %_config_init_flags_VALUES;
1825 #Convert a flag value to a list of names for flags that are set.
1826 sub config_init_flags_to_strings {
1827     my ($flags) = @_;
1828     my @result = ();
1829
1830     for my $k (keys %_config_init_flags_VALUES) {
1831         my $v = $_config_init_flags_VALUES{$k};
1832
1833         #is this a matching flag?
1834         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
1835             push @result, $k;
1836         }
1837     }
1838
1839 #by default, just return the number as a 1-element list
1840     if (!@result) {
1841         return ($flags);
1842     }
1843
1844     return @result;
1845 }
1846
1847 push @EXPORT_OK, qw($CONFIG_INIT_EXPLICIT_NAME);
1848 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_EXPLICIT_NAME);
1849
1850 $_config_init_flags_VALUES{"CONFIG_INIT_EXPLICIT_NAME"} = $CONFIG_INIT_EXPLICIT_NAME;
1851
1852 push @EXPORT_OK, qw($CONFIG_INIT_USE_CWD);
1853 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_USE_CWD);
1854
1855 $_config_init_flags_VALUES{"CONFIG_INIT_USE_CWD"} = $CONFIG_INIT_USE_CWD;
1856
1857 push @EXPORT_OK, qw($CONFIG_INIT_CLIENT);
1858 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_CLIENT);
1859
1860 $_config_init_flags_VALUES{"CONFIG_INIT_CLIENT"} = $CONFIG_INIT_CLIENT;
1861
1862 push @EXPORT_OK, qw($CONFIG_INIT_OVERLAY);
1863 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_OVERLAY);
1864
1865 $_config_init_flags_VALUES{"CONFIG_INIT_OVERLAY"} = $CONFIG_INIT_OVERLAY;
1866
1867 #copy symbols in config_init_flags to init
1868 push @{$EXPORT_TAGS{"init"}},  @{$EXPORT_TAGS{"config_init_flags"}};
1869
1870 push @EXPORT_OK, qw(config_init config_uninit get_config_options
1871     get_config_name get_config_dir get_config_filename
1872     config_print_errors config_clear_errors config_errors
1873     new_config_overrides free_config_overrides add_config_override
1874     add_config_override_opt set_config_overrides);
1875 push @{$EXPORT_TAGS{"init"}}, qw(config_init config_uninit get_config_options
1876     get_config_name get_config_dir get_config_filename
1877     config_print_errors config_clear_errors config_errors
1878     new_config_overrides free_config_overrides add_config_override
1879     add_config_override_opt set_config_overrides);
1880
1881 push @EXPORT_OK, qw(dump_configuration config_dir_relative taperalgo2str find_multiplier);
1882
1883
1884 sub string_to_boolean {
1885     my ($str) = @_;
1886     my $ret = C_string_to_boolean($str);
1887     return undef unless $ret >= 0;
1888     return $ret;
1889 }
1890
1891
1892 push @EXPORT_OK, qw(string_to_boolean);
1893
1894 push @EXPORT_OK, qw(amandaify_property_name);
1895 1;