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 1.3.39
   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 *getconf_unit_divisor = *Amanda::Configc::getconf_unit_divisor;
  93 *config_init = *Amanda::Configc::config_init;
  94 *config_uninit = *Amanda::Configc::config_uninit;
  95 *get_config_options = *Amanda::Configc::get_config_options;
  96 *get_config_name = *Amanda::Configc::get_config_name;
  97 *get_config_dir = *Amanda::Configc::get_config_dir;
  98 *get_config_filename = *Amanda::Configc::get_config_filename;
  99 *config_print_errors = *Amanda::Configc::config_print_errors;
 100 *config_clear_errors = *Amanda::Configc::config_clear_errors;
 101 *config_errors = *Amanda::Configc::config_errors;
 102 *new_config_overrides = *Amanda::Configc::new_config_overrides;
 103 *free_config_overrides = *Amanda::Configc::free_config_overrides;
 104 *add_config_override = *Amanda::Configc::add_config_override;
 105 *add_config_override_opt = *Amanda::Configc::add_config_override_opt;
 106 *set_config_overrides = *Amanda::Configc::set_config_overrides;
 107 *dump_configuration = *Amanda::Configc::dump_configuration;
 108 *config_dir_relative = *Amanda::Configc::config_dir_relative;
 109 *taperalgo2str = *Amanda::Configc::taperalgo2str;
 110 *find_multiplier = *Amanda::Configc::find_multiplier;
 111 *C_string_to_boolean = *Amanda::Configc::C_string_to_boolean;
 112
 113 # ------- VARIABLE STUBS --------
 114
 115 package Amanda::Config;
 116
 117 *CNF_ORG = *Amanda::Configc::CNF_ORG;
 118 *CNF_CONF = *Amanda::Configc::CNF_CONF;
 119 *CNF_INDEX_SERVER = *Amanda::Configc::CNF_INDEX_SERVER;
 120 *CNF_TAPE_SERVER = *Amanda::Configc::CNF_TAPE_SERVER;
 121 *CNF_AUTH = *Amanda::Configc::CNF_AUTH;
 122 *CNF_SSH_KEYS = *Amanda::Configc::CNF_SSH_KEYS;
 123 *CNF_AMANDAD_PATH = *Amanda::Configc::CNF_AMANDAD_PATH;
 124 *CNF_CLIENT_USERNAME = *Amanda::Configc::CNF_CLIENT_USERNAME;
 125 *CNF_CLIENT_PORT = *Amanda::Configc::CNF_CLIENT_PORT;
 126 *CNF_GNUTAR_LIST_DIR = *Amanda::Configc::CNF_GNUTAR_LIST_DIR;
 127 *CNF_AMANDATES = *Amanda::Configc::CNF_AMANDATES;
 128 *CNF_MAILER = *Amanda::Configc::CNF_MAILER;
 129 *CNF_MAILTO = *Amanda::Configc::CNF_MAILTO;
 130 *CNF_DUMPUSER = *Amanda::Configc::CNF_DUMPUSER;
 131 *CNF_TAPEDEV = *Amanda::Configc::CNF_TAPEDEV;
 132 *CNF_DEVICE_PROPERTY = *Amanda::Configc::CNF_DEVICE_PROPERTY;
 133 *CNF_PROPERTY = *Amanda::Configc::CNF_PROPERTY;
 134 *CNF_CHANGERDEV = *Amanda::Configc::CNF_CHANGERDEV;
 135 *CNF_CHANGERFILE = *Amanda::Configc::CNF_CHANGERFILE;
 136 *CNF_LABELSTR = *Amanda::Configc::CNF_LABELSTR;
 137 *CNF_AUTOLABEL = *Amanda::Configc::CNF_AUTOLABEL;
 138 *CNF_TAPELIST = *Amanda::Configc::CNF_TAPELIST;
 139 *CNF_DISKFILE = *Amanda::Configc::CNF_DISKFILE;
 140 *CNF_INFOFILE = *Amanda::Configc::CNF_INFOFILE;
 141 *CNF_LOGDIR = *Amanda::Configc::CNF_LOGDIR;
 142 *CNF_INDEXDIR = *Amanda::Configc::CNF_INDEXDIR;
 143 *CNF_TAPETYPE = *Amanda::Configc::CNF_TAPETYPE;
 144 *CNF_DUMPCYCLE = *Amanda::Configc::CNF_DUMPCYCLE;
 145 *CNF_RUNSPERCYCLE = *Amanda::Configc::CNF_RUNSPERCYCLE;
 146 *CNF_TAPECYCLE = *Amanda::Configc::CNF_TAPECYCLE;
 147 *CNF_NETUSAGE = *Amanda::Configc::CNF_NETUSAGE;
 148 *CNF_INPARALLEL = *Amanda::Configc::CNF_INPARALLEL;
 149 *CNF_DUMPORDER = *Amanda::Configc::CNF_DUMPORDER;
 150 *CNF_BUMPPERCENT = *Amanda::Configc::CNF_BUMPPERCENT;
 151 *CNF_BUMPSIZE = *Amanda::Configc::CNF_BUMPSIZE;
 152 *CNF_BUMPMULT = *Amanda::Configc::CNF_BUMPMULT;
 153 *CNF_BUMPDAYS = *Amanda::Configc::CNF_BUMPDAYS;
 154 *CNF_TPCHANGER = *Amanda::Configc::CNF_TPCHANGER;
 155 *CNF_RUNTAPES = *Amanda::Configc::CNF_RUNTAPES;
 156 *CNF_MAXDUMPS = *Amanda::Configc::CNF_MAXDUMPS;
 157 *CNF_ETIMEOUT = *Amanda::Configc::CNF_ETIMEOUT;
 158 *CNF_DTIMEOUT = *Amanda::Configc::CNF_DTIMEOUT;
 159 *CNF_CTIMEOUT = *Amanda::Configc::CNF_CTIMEOUT;
 160 *CNF_TAPEBUFS = *Amanda::Configc::CNF_TAPEBUFS;
 161 *CNF_DEVICE_OUTPUT_BUFFER_SIZE = *Amanda::Configc::CNF_DEVICE_OUTPUT_BUFFER_SIZE;
 162 *CNF_PRINTER = *Amanda::Configc::CNF_PRINTER;
 163 *CNF_AUTOFLUSH = *Amanda::Configc::CNF_AUTOFLUSH;
 164 *CNF_RESERVE = *Amanda::Configc::CNF_RESERVE;
 165 *CNF_MAXDUMPSIZE = *Amanda::Configc::CNF_MAXDUMPSIZE;
 166 *CNF_COLUMNSPEC = *Amanda::Configc::CNF_COLUMNSPEC;
 167 *CNF_AMRECOVER_DO_FSF = *Amanda::Configc::CNF_AMRECOVER_DO_FSF;
 168 *CNF_AMRECOVER_CHECK_LABEL = *Amanda::Configc::CNF_AMRECOVER_CHECK_LABEL;
 169 *CNF_AMRECOVER_CHANGER = *Amanda::Configc::CNF_AMRECOVER_CHANGER;
 170 *CNF_TAPERALGO = *Amanda::Configc::CNF_TAPERALGO;
 171 *CNF_FLUSH_THRESHOLD_DUMPED = *Amanda::Configc::CNF_FLUSH_THRESHOLD_DUMPED;
 172 *CNF_FLUSH_THRESHOLD_SCHEDULED = *Amanda::Configc::CNF_FLUSH_THRESHOLD_SCHEDULED;
 173 *CNF_TAPERFLUSH = *Amanda::Configc::CNF_TAPERFLUSH;
 174 *CNF_DISPLAYUNIT = *Amanda::Configc::CNF_DISPLAYUNIT;
 175 *CNF_KRB5KEYTAB = *Amanda::Configc::CNF_KRB5KEYTAB;
 176 *CNF_KRB5PRINCIPAL = *Amanda::Configc::CNF_KRB5PRINCIPAL;
 177 *CNF_LABEL_NEW_TAPES = *Amanda::Configc::CNF_LABEL_NEW_TAPES;
 178 *CNF_USETIMESTAMPS = *Amanda::Configc::CNF_USETIMESTAMPS;
 179 *CNF_REP_TRIES = *Amanda::Configc::CNF_REP_TRIES;
 180 *CNF_CONNECT_TRIES = *Amanda::Configc::CNF_CONNECT_TRIES;
 181 *CNF_REQ_TRIES = *Amanda::Configc::CNF_REQ_TRIES;
 182 *CNF_DEBUG_AMANDAD = *Amanda::Configc::CNF_DEBUG_AMANDAD;
 183 *CNF_DEBUG_RECOVERY = *Amanda::Configc::CNF_DEBUG_RECOVERY;
 184 *CNF_DEBUG_AMIDXTAPED = *Amanda::Configc::CNF_DEBUG_AMIDXTAPED;
 185 *CNF_DEBUG_AMINDEXD = *Amanda::Configc::CNF_DEBUG_AMINDEXD;
 186 *CNF_DEBUG_AMRECOVER = *Amanda::Configc::CNF_DEBUG_AMRECOVER;
 187 *CNF_DEBUG_AUTH = *Amanda::Configc::CNF_DEBUG_AUTH;
 188 *CNF_DEBUG_EVENT = *Amanda::Configc::CNF_DEBUG_EVENT;
 189 *CNF_DEBUG_HOLDING = *Amanda::Configc::CNF_DEBUG_HOLDING;
 190 *CNF_DEBUG_PROTOCOL = *Amanda::Configc::CNF_DEBUG_PROTOCOL;
 191 *CNF_DEBUG_PLANNER = *Amanda::Configc::CNF_DEBUG_PLANNER;
 192 *CNF_DEBUG_DRIVER = *Amanda::Configc::CNF_DEBUG_DRIVER;
 193 *CNF_DEBUG_DUMPER = *Amanda::Configc::CNF_DEBUG_DUMPER;
 194 *CNF_DEBUG_CHUNKER = *Amanda::Configc::CNF_DEBUG_CHUNKER;
 195 *CNF_DEBUG_TAPER = *Amanda::Configc::CNF_DEBUG_TAPER;
 196 *CNF_DEBUG_SELFCHECK = *Amanda::Configc::CNF_DEBUG_SELFCHECK;
 197 *CNF_DEBUG_SENDSIZE = *Amanda::Configc::CNF_DEBUG_SENDSIZE;
 198 *CNF_DEBUG_SENDBACKUP = *Amanda::Configc::CNF_DEBUG_SENDBACKUP;
 199 *CNF_RESERVED_UDP_PORT = *Amanda::Configc::CNF_RESERVED_UDP_PORT;
 200 *CNF_RESERVED_TCP_PORT = *Amanda::Configc::CNF_RESERVED_TCP_PORT;
 201 *CNF_UNRESERVED_TCP_PORT = *Amanda::Configc::CNF_UNRESERVED_TCP_PORT;
 202 *CNF_HOLDINGDISK = *Amanda::Configc::CNF_HOLDINGDISK;
 203 *CNF_SEND_AMREPORT_ON = *Amanda::Configc::CNF_SEND_AMREPORT_ON;
 204 *TAPETYPE_COMMENT = *Amanda::Configc::TAPETYPE_COMMENT;
 205 *TAPETYPE_LBL_TEMPL = *Amanda::Configc::TAPETYPE_LBL_TEMPL;
 206 *TAPETYPE_BLOCKSIZE = *Amanda::Configc::TAPETYPE_BLOCKSIZE;
 207 *TAPETYPE_READBLOCKSIZE = *Amanda::Configc::TAPETYPE_READBLOCKSIZE;
 208 *TAPETYPE_LENGTH = *Amanda::Configc::TAPETYPE_LENGTH;
 209 *TAPETYPE_FILEMARK = *Amanda::Configc::TAPETYPE_FILEMARK;
 210 *TAPETYPE_SPEED = *Amanda::Configc::TAPETYPE_SPEED;
 211 *TAPETYPE_FILE_PAD = *Amanda::Configc::TAPETYPE_FILE_PAD;
 212 *DUMPTYPE_COMMENT = *Amanda::Configc::DUMPTYPE_COMMENT;
 213 *DUMPTYPE_PROGRAM = *Amanda::Configc::DUMPTYPE_PROGRAM;
 214 *DUMPTYPE_SRVCOMPPROG = *Amanda::Configc::DUMPTYPE_SRVCOMPPROG;
 215 *DUMPTYPE_CLNTCOMPPROG = *Amanda::Configc::DUMPTYPE_CLNTCOMPPROG;
 216 *DUMPTYPE_SRV_ENCRYPT = *Amanda::Configc::DUMPTYPE_SRV_ENCRYPT;
 217 *DUMPTYPE_CLNT_ENCRYPT = *Amanda::Configc::DUMPTYPE_CLNT_ENCRYPT;
 218 *DUMPTYPE_AMANDAD_PATH = *Amanda::Configc::DUMPTYPE_AMANDAD_PATH;
 219 *DUMPTYPE_CLIENT_USERNAME = *Amanda::Configc::DUMPTYPE_CLIENT_USERNAME;
 220 *DUMPTYPE_CLIENT_PORT = *Amanda::Configc::DUMPTYPE_CLIENT_PORT;
 221 *DUMPTYPE_SSH_KEYS = *Amanda::Configc::DUMPTYPE_SSH_KEYS;
 222 *DUMPTYPE_AUTH = *Amanda::Configc::DUMPTYPE_AUTH;
 223 *DUMPTYPE_EXCLUDE = *Amanda::Configc::DUMPTYPE_EXCLUDE;
 224 *DUMPTYPE_INCLUDE = *Amanda::Configc::DUMPTYPE_INCLUDE;
 225 *DUMPTYPE_PRIORITY = *Amanda::Configc::DUMPTYPE_PRIORITY;
 226 *DUMPTYPE_DUMPCYCLE = *Amanda::Configc::DUMPTYPE_DUMPCYCLE;
 227 *DUMPTYPE_MAXDUMPS = *Amanda::Configc::DUMPTYPE_MAXDUMPS;
 228 *DUMPTYPE_MAXPROMOTEDAY = *Amanda::Configc::DUMPTYPE_MAXPROMOTEDAY;
 229 *DUMPTYPE_BUMPPERCENT = *Amanda::Configc::DUMPTYPE_BUMPPERCENT;
 230 *DUMPTYPE_BUMPSIZE = *Amanda::Configc::DUMPTYPE_BUMPSIZE;
 231 *DUMPTYPE_BUMPDAYS = *Amanda::Configc::DUMPTYPE_BUMPDAYS;
 232 *DUMPTYPE_BUMPMULT = *Amanda::Configc::DUMPTYPE_BUMPMULT;
 233 *DUMPTYPE_STARTTIME = *Amanda::Configc::DUMPTYPE_STARTTIME;
 234 *DUMPTYPE_STRATEGY = *Amanda::Configc::DUMPTYPE_STRATEGY;
 235 *DUMPTYPE_ESTIMATELIST = *Amanda::Configc::DUMPTYPE_ESTIMATELIST;
 236 *DUMPTYPE_COMPRESS = *Amanda::Configc::DUMPTYPE_COMPRESS;
 237 *DUMPTYPE_ENCRYPT = *Amanda::Configc::DUMPTYPE_ENCRYPT;
 238 *DUMPTYPE_SRV_DECRYPT_OPT = *Amanda::Configc::DUMPTYPE_SRV_DECRYPT_OPT;
 239 *DUMPTYPE_CLNT_DECRYPT_OPT = *Amanda::Configc::DUMPTYPE_CLNT_DECRYPT_OPT;
 240 *DUMPTYPE_COMPRATE = *Amanda::Configc::DUMPTYPE_COMPRATE;
 241 *DUMPTYPE_TAPE_SPLITSIZE = *Amanda::Configc::DUMPTYPE_TAPE_SPLITSIZE;
 242 *DUMPTYPE_FALLBACK_SPLITSIZE = *Amanda::Configc::DUMPTYPE_FALLBACK_SPLITSIZE;
 243 *DUMPTYPE_SPLIT_DISKBUFFER = *Amanda::Configc::DUMPTYPE_SPLIT_DISKBUFFER;
 244 *DUMPTYPE_RECORD = *Amanda::Configc::DUMPTYPE_RECORD;
 245 *DUMPTYPE_SKIP_INCR = *Amanda::Configc::DUMPTYPE_SKIP_INCR;
 246 *DUMPTYPE_SKIP_FULL = *Amanda::Configc::DUMPTYPE_SKIP_FULL;
 247 *DUMPTYPE_HOLDINGDISK = *Amanda::Configc::DUMPTYPE_HOLDINGDISK;
 248 *DUMPTYPE_KENCRYPT = *Amanda::Configc::DUMPTYPE_KENCRYPT;
 249 *DUMPTYPE_IGNORE = *Amanda::Configc::DUMPTYPE_IGNORE;
 250 *DUMPTYPE_INDEX = *Amanda::Configc::DUMPTYPE_INDEX;
 251 *DUMPTYPE_APPLICATION = *Amanda::Configc::DUMPTYPE_APPLICATION;
 252 *DUMPTYPE_SCRIPTLIST = *Amanda::Configc::DUMPTYPE_SCRIPTLIST;
 253 *DUMPTYPE_PROPERTY = *Amanda::Configc::DUMPTYPE_PROPERTY;
 254 *DUMPTYPE_DATA_PATH = *Amanda::Configc::DUMPTYPE_DATA_PATH;
 255 *INTER_COMMENT = *Amanda::Configc::INTER_COMMENT;
 256 *INTER_MAXUSAGE = *Amanda::Configc::INTER_MAXUSAGE;
 257 *HOLDING_COMMENT = *Amanda::Configc::HOLDING_COMMENT;
 258 *HOLDING_DISKDIR = *Amanda::Configc::HOLDING_DISKDIR;
 259 *HOLDING_DISKSIZE = *Amanda::Configc::HOLDING_DISKSIZE;
 260 *HOLDING_CHUNKSIZE = *Amanda::Configc::HOLDING_CHUNKSIZE;
 261 *APPLICATION_COMMENT = *Amanda::Configc::APPLICATION_COMMENT;
 262 *APPLICATION_PLUGIN = *Amanda::Configc::APPLICATION_PLUGIN;
 263 *APPLICATION_PROPERTY = *Amanda::Configc::APPLICATION_PROPERTY;
 264 *PP_SCRIPT_COMMENT = *Amanda::Configc::PP_SCRIPT_COMMENT;
 265 *PP_SCRIPT_PLUGIN = *Amanda::Configc::PP_SCRIPT_PLUGIN;
 266 *PP_SCRIPT_PROPERTY = *Amanda::Configc::PP_SCRIPT_PROPERTY;
 267 *PP_SCRIPT_EXECUTE_ON = *Amanda::Configc::PP_SCRIPT_EXECUTE_ON;
 268 *PP_SCRIPT_EXECUTE_WHERE = *Amanda::Configc::PP_SCRIPT_EXECUTE_WHERE;
 269 *PP_SCRIPT_ORDER = *Amanda::Configc::PP_SCRIPT_ORDER;
 270 *DEVICE_CONFIG_COMMENT = *Amanda::Configc::DEVICE_CONFIG_COMMENT;
 271 *DEVICE_CONFIG_TAPEDEV = *Amanda::Configc::DEVICE_CONFIG_TAPEDEV;
 272 *DEVICE_CONFIG_DEVICE_PROPERTY = *Amanda::Configc::DEVICE_CONFIG_DEVICE_PROPERTY;
 273 *CHANGER_CONFIG_COMMENT = *Amanda::Configc::CHANGER_CONFIG_COMMENT;
 274 *CHANGER_CONFIG_TAPEDEV = *Amanda::Configc::CHANGER_CONFIG_TAPEDEV;
 275 *CHANGER_CONFIG_TPCHANGER = *Amanda::Configc::CHANGER_CONFIG_TPCHANGER;
 276 *CHANGER_CONFIG_CHANGERDEV = *Amanda::Configc::CHANGER_CONFIG_CHANGERDEV;
 277 *CHANGER_CONFIG_CHANGERFILE = *Amanda::Configc::CHANGER_CONFIG_CHANGERFILE;
 278 *CHANGER_CONFIG_PROPERTY = *Amanda::Configc::CHANGER_CONFIG_PROPERTY;
 279 *CHANGER_CONFIG_DEVICE_PROPERTY = *Amanda::Configc::CHANGER_CONFIG_DEVICE_PROPERTY;
 280 *HOLD_NEVER = *Amanda::Configc::HOLD_NEVER;
 281 *HOLD_AUTO = *Amanda::Configc::HOLD_AUTO;
 282 *HOLD_REQUIRED = *Amanda::Configc::HOLD_REQUIRED;
 283 *COMP_NONE = *Amanda::Configc::COMP_NONE;
 284 *COMP_FAST = *Amanda::Configc::COMP_FAST;
 285 *COMP_BEST = *Amanda::Configc::COMP_BEST;
 286 *COMP_CUST = *Amanda::Configc::COMP_CUST;
 287 *COMP_SERVER_FAST = *Amanda::Configc::COMP_SERVER_FAST;
 288 *COMP_SERVER_BEST = *Amanda::Configc::COMP_SERVER_BEST;
 289 *COMP_SERVER_CUST = *Amanda::Configc::COMP_SERVER_CUST;
 290 *ENCRYPT_NONE = *Amanda::Configc::ENCRYPT_NONE;
 291 *ENCRYPT_CUST = *Amanda::Configc::ENCRYPT_CUST;
 292 *ENCRYPT_SERV_CUST = *Amanda::Configc::ENCRYPT_SERV_CUST;
 293 *DS_SKIP = *Amanda::Configc::DS_SKIP;
 294 *DS_STANDARD = *Amanda::Configc::DS_STANDARD;
 295 *DS_NOFULL = *Amanda::Configc::DS_NOFULL;
 296 *DS_NOINC = *Amanda::Configc::DS_NOINC;
 297 *DS_4 = *Amanda::Configc::DS_4;
 298 *DS_5 = *Amanda::Configc::DS_5;
 299 *DS_HANOI = *Amanda::Configc::DS_HANOI;
 300 *DS_INCRONLY = *Amanda::Configc::DS_INCRONLY;
 301 *ES_CLIENT = *Amanda::Configc::ES_CLIENT;
 302 *ES_SERVER = *Amanda::Configc::ES_SERVER;
 303 *ES_CALCSIZE = *Amanda::Configc::ES_CALCSIZE;
 304 *AL_OTHER_CONFIG = *Amanda::Configc::AL_OTHER_CONFIG;
 305 *AL_NON_AMANDA = *Amanda::Configc::AL_NON_AMANDA;
 306 *AL_VOLUME_ERROR = *Amanda::Configc::AL_VOLUME_ERROR;
 307 *AL_EMPTY = *Amanda::Configc::AL_EMPTY;
 308 *ALGO_FIRST = *Amanda::Configc::ALGO_FIRST;
 309 *ALGO_FIRSTFIT = *Amanda::Configc::ALGO_FIRSTFIT;
 310 *ALGO_LARGEST = *Amanda::Configc::ALGO_LARGEST;
 311 *ALGO_LARGESTFIT = *Amanda::Configc::ALGO_LARGESTFIT;
 312 *ALGO_SMALLEST = *Amanda::Configc::ALGO_SMALLEST;
 313 *ALGO_LAST = *Amanda::Configc::ALGO_LAST;
 314 *EXECUTE_ON_PRE_DLE_AMCHECK = *Amanda::Configc::EXECUTE_ON_PRE_DLE_AMCHECK;
 315 *EXECUTE_ON_PRE_HOST_AMCHECK = *Amanda::Configc::EXECUTE_ON_PRE_HOST_AMCHECK;
 316 *EXECUTE_ON_POST_DLE_AMCHECK = *Amanda::Configc::EXECUTE_ON_POST_DLE_AMCHECK;
 317 *EXECUTE_ON_POST_HOST_AMCHECK = *Amanda::Configc::EXECUTE_ON_POST_HOST_AMCHECK;
 318 *EXECUTE_ON_PRE_DLE_ESTIMATE = *Amanda::Configc::EXECUTE_ON_PRE_DLE_ESTIMATE;
 319 *EXECUTE_ON_PRE_HOST_ESTIMATE = *Amanda::Configc::EXECUTE_ON_PRE_HOST_ESTIMATE;
 320 *EXECUTE_ON_POST_DLE_ESTIMATE = *Amanda::Configc::EXECUTE_ON_POST_DLE_ESTIMATE;
 321 *EXECUTE_ON_POST_HOST_ESTIMATE = *Amanda::Configc::EXECUTE_ON_POST_HOST_ESTIMATE;
 322 *EXECUTE_ON_PRE_DLE_BACKUP = *Amanda::Configc::EXECUTE_ON_PRE_DLE_BACKUP;
 323 *EXECUTE_ON_PRE_HOST_BACKUP = *Amanda::Configc::EXECUTE_ON_PRE_HOST_BACKUP;
 324 *EXECUTE_ON_POST_DLE_BACKUP = *Amanda::Configc::EXECUTE_ON_POST_DLE_BACKUP;
 325 *EXECUTE_ON_POST_HOST_BACKUP = *Amanda::Configc::EXECUTE_ON_POST_HOST_BACKUP;
 326 *SEND_AMREPORT_ALL = *Amanda::Configc::SEND_AMREPORT_ALL;
 327 *SEND_AMREPORT_STRANGE = *Amanda::Configc::SEND_AMREPORT_STRANGE;
 328 *SEND_AMREPORT_ERROR = *Amanda::Configc::SEND_AMREPORT_ERROR;
 329 *SEND_AMREPORT_NEVER = *Amanda::Configc::SEND_AMREPORT_NEVER;
 330 *DATA_PATH_AMANDA = *Amanda::Configc::DATA_PATH_AMANDA;
 331 *DATA_PATH_DIRECTTCP = *Amanda::Configc::DATA_PATH_DIRECTTCP;
 332 *debug_amandad = *Amanda::Configc::debug_amandad;
 333 *debug_recovery = *Amanda::Configc::debug_recovery;
 334 *debug_amidxtaped = *Amanda::Configc::debug_amidxtaped;
 335 *debug_amindexd = *Amanda::Configc::debug_amindexd;
 336 *debug_amrecover = *Amanda::Configc::debug_amrecover;
 337 *debug_auth = *Amanda::Configc::debug_auth;
 338 *debug_event = *Amanda::Configc::debug_event;
 339 *debug_holding = *Amanda::Configc::debug_holding;
 340 *debug_protocol = *Amanda::Configc::debug_protocol;
 341 *debug_planner = *Amanda::Configc::debug_planner;
 342 *debug_driver = *Amanda::Configc::debug_driver;
 343 *debug_dumper = *Amanda::Configc::debug_dumper;
 344 *debug_chunker = *Amanda::Configc::debug_chunker;
 345 *debug_taper = *Amanda::Configc::debug_taper;
 346 *debug_selfcheck = *Amanda::Configc::debug_selfcheck;
 347 *debug_sendsize = *Amanda::Configc::debug_sendsize;
 348 *debug_sendbackup = *Amanda::Configc::debug_sendbackup;
 349 *CFGERR_OK = *Amanda::Configc::CFGERR_OK;
 350 *CFGERR_WARNINGS = *Amanda::Configc::CFGERR_WARNINGS;
 351 *CFGERR_ERRORS = *Amanda::Configc::CFGERR_ERRORS;
 352 *CONFIG_INIT_EXPLICIT_NAME = *Amanda::Configc::CONFIG_INIT_EXPLICIT_NAME;
 353 *CONFIG_INIT_USE_CWD = *Amanda::Configc::CONFIG_INIT_USE_CWD;
 354 *CONFIG_INIT_CLIENT = *Amanda::Configc::CONFIG_INIT_CLIENT;
 355 *CONFIG_INIT_OVERLAY = *Amanda::Configc::CONFIG_INIT_OVERLAY;
 356
 357 @EXPORT_OK = ();
 358 %EXPORT_TAGS = ();
 359
 360
 361 =head1 NAME
 362
 363 Amanda::Config - access to Amanda configuration parameters
 364
 365 =head1 SYNOPSIS
 366
 367     use Amanda::Config qw( :init :getconf );
 368
 369     my $config_name = shift @ARGV;
 370     config_init($CONFIG_INIT_EXPLICIT_NAME, $config_name);
 371     apply_config_overrides($config_overrides);
 372     my ($cfgerr_level, @cfgerr_errors) = config_errors();
 373     if ($cfgerr_level >= $CFGERR_WARNINGS) {
 374         config_print_errors();
 375         if ($cfgerr_level >= $CFGERR_ERRORS) {
 376             die("errors processing config file");
 377         }
 378     }
 379
 380     print "tape device is ", getconf($CNF_TAPEDEV), "\n";
 381
 382 This API closely parallels the C API.  See F<conffile.h> for details on the
 383 configuration parameter constants.
 384
 385 =head1 INITIALIZATION
 386
 387 The Amanda configuration is treated as a global state for the
 388 application.  It is not possible to load two configurations
 389 simultaneously.
 390
 391 All initialization-related symbols can be imported with the tag
 392 C<:init>.
 393
 394 =head2 LOADING CONFIGURATION
 395
 396 The Amanda configuration is loaded with the aptly named
 397 C<config_init($flags, $name)>.  Because of the great variety in
 398 invocation method among Amanda applications, this function has a number
 399 of flags that affect its behavior.  These flags can be OR'd together.
 400
 401 =over
 402
 403 =item If C<CONFIG_INIT_EXPLICIT_NAME> is given, then the C<$name> parameter can
 404 contain the name of a configuration to load.  Note that if the parameter is
 405 C<".">, this is equivalent to C<CONFIG_INIT_USE_CWD>.
 406
 407 =item If C<CONFIG_INIT_USE_CWD> is given, and if the current directory
 408 contains C<amanda.conf>, then that file is loaded.
 409
 410 =item If C<CONFIG_INIT_CLIENT> is given, then a client configuration
 411 is loaded.
 412
 413 =item If C<CONFIG_INIT_OVERLAY> is given, then any existing
 414 configuration is not reset.
 415
 416 =back
 417
 418 See C<conffile.h> for more detailed information on these flags and
 419 their interactions.
 420
 421 C<config_uninit()> reverses the effects of C<config_init>.  It is
 422 not often used.
 423
 424 Once the configuration is loaded, the configuration name
 425 (e.g., "DailySet1"), directory (C</etc/amanda/DailySet1>),
 426 and filename (C</etc/amanda/DailySet1/amanda.conf>) are
 427 available from C<get_config_name()>, C<get_config_dir()>, and
 428 C<get_config_filename()>, respectively.
 429
 430 =head3 CONFIG ERRORS
 431
 432 This module collects configuration errors and warnings in a list, and also
 433 tracks the overall error level with an enumeration: C<$CFGERR_OK>,
 434 C<$CFGERR_WARNINGS>, and C<$CFGERR_ERRORS>.  C<config_init> and
 435 C<apply_config_overrides> both return the current level.  The level and the
 436 list of error messages are available from C<config_errors>:
 437
 438   my ($cfgerr_level, @errors) = Amanda::Config::config_errors();
 439
 440 As a convenience, C<config_print_errors> will print all error messages to
 441 stderr.  The error state can be cleared with C<config_clear_errors>.
 442
 443 =head2 CONFIG OVERWRITES
 444
 445 Most Amanda applications accept the command-line option C<-o>
 446 to "overwrite" configuration values in C<amanda.conf>.  In Perl
 447 applications, these options should be parsed with L<Getopt::Long|Getopt::Long>, with
 448 the action being a call to C<add_config_override_opt>.  For example:
 449
 450   my $config_overrides = new_config_overrides($#ARGV+1);
 451     GetOptions(
 452         # ...
 453         'o=s' => sub { add_config_override_opt($config_overrides, $_[1]); },
 454     ) or usage();
 455   my $cfg_ok = config_init($CONFIG_INIT_EXPLICIT_NAME | $CONFIG_INIT_USE_CWD, $config_name);
 456   apply_config_overrides($config_overrides);
 457
 458 C<new_config_overrides($size_estimate)> creates a new
 459 overwrites object, using the given size as an estimate of
 460 the number of items it will contain (C<$#ARGC/2> is a good
 461 estimate).  Individual configuration options are then added via
 462 C<add_config_override($co, $key, $value)> (which takes a key/value
 463 pair) or C<add_config_override_opt($co, $optarg)>, which parses a
 464 string following C<-o> on the command line.
 465
 466 Once the overwrites are gathered, they are applied with
 467 C<apply_config_overrides($co)>, which applies the overwrites to the
 468 active configuration.  No further operations can be performed on the
 469 overwrites object after C<apply_config_overrides> has been called.
 470
 471 The utility function C<get_config_options()> returns a list of
 472 command-line arguments to represent any overwrites that were used
 473 to generate the current configuration.  (TODO: this function isn't
 474 available yet)
 475
 476 =head1 PARAMETER ACCESS
 477
 478 Amanda configurations consist of "global" parameters and several
 479 sets of "subsections" -- one set for dumptypes, one for tapetypes,
 480 and so on.
 481
 482 All of the global parameters are represented by a constant beginning with
 483 C<$CNF_>, e.g., C<$CNF_LABELSTR>.  The function C<getconf($cnf)> returns the
 484 value of parameter C<$cnf>, in whatever format is appropriate for the parameter
 485 (see DATA FORMATS, below).  C<getconf_seen($cnf)> returns a true value if
 486 C<$cnf> was seen in the configuration file.  If it was not seen, then it will
 487 have its default value.  C<getconf_linenum($cnf)> returns the line number in
 488 the configuration file where it is set, 0 if it is not in a configuration file,
 489 or -2 if it is set in a command line argument.
 490
 491 Some parameters have enumerated types.  The values for those
 492 enumerations are available from this module with the same name as
 493 in C<conffile.h>.  For example, C<$CNF_TAPERALGO> will yield a value
 494 from the enumeration C<taperalgo_t>, the constants for which all
 495 begin with C<$ALGO_>.  See C<conffile.h> for the details.
 496
 497 Each subsection type C<TYP> has the following functions:
 498
 499 =over
 500
 501 =item C<lookup_TYP($subsec_name)>
 502
 503 which returns an opaque object
 504 (C<$ss>) representing the subsection, or C<undef> if no subsection
 505 with that name exists;
 506
 507 =item C<TYP_name($ss)>
 508
 509 returning the name of the subsection;
 510
 511 =item C<TYP_getconf($ss, $cnf)>
 512
 513 which fetches a parameter value from C<$ss>; and
 514
 515 =item C<TYP_seen($ss, $cnf)>
 516
 517 which returns a true value if <$cnf> was seen in the subsection.
 518
 519 =back
 520
 521 The subsections are:
 522
 523 =over
 524
 525 =item C<tapetype>
 526
 527 with constants beginning with C<$TAPETYPE_>
 528
 529 =item C<dumptype>
 530
 531 with constants beginning with C<$DUMPTYPE_>
 532
 533 =item C<interface>
 534
 535 with constants beginning with C<$INTER_>
 536
 537 =item C<holdingdisk>
 538
 539 with constants beginning with C<$HOLDING_>
 540
 541 =item C<application>
 542
 543 with constants beginning with C<$APPLICATION_>
 544
 545 =item C<script>
 546
 547 with constants beginning with C<$PP_SCRIPT_>
 548
 549 =item C<device>
 550
 551 with constants beginning with C<$DEVICE_CONFIG_>.
 552
 553 =item C<changer>
 554
 555 with constants beginning with C<$CHANGER_CONFIG_>.
 556
 557 =back
 558
 559 See C<conffile.h> for the names of the constants themselves.
 560
 561 =head2 DATA FORMATS
 562
 563 Each configuration parameter has a "conftype", as assigned in
 564 C<common-src/conffile.c>.  The translation of most of these types into Perl
 565 values is straightforward:
 566
 567   CONFTYPE_INT                        Math::BigInt
 568   CONFTYPE_INT64                      Math::BigInt
 569   CONFTYPE_REAL                       floating-point value
 570   CONFTYPE_STR                        string
 571   CONFTYPE_IDENT                      string
 572   CONFTYPE_TIME                       Math::BigInt (epoch value)
 573   CONFTYPE_SIZE                       Math::BigInt
 574   CONFTYPE_BOOLEAN                    Math::BigInt
 575   CONFTYPE_COMPRESS                   Math::BigInt
 576   CONFTYPE_ENCRYPT                    Math::BigInt
 577   CONFTYPE_HOLDING                    Math::BigInt
 578   CONFTYPE_ESTIMATELIST               [ Math::BigInt, .. ]
 579   CONFTYPE_STRATEGY                   Math::BigInt
 580   CONFTYPE_TAPERALGO                  Math::BigInt
 581   CONFTYPE_PRIORITY                   Math::BigInt
 582   CONFTYPE_RATE                       float, float
 583   CONFTYPE_INTRANGE                   Math::BigInt, Math::BigInt
 584   CONFTYPE_APPLICATION                string
 585   CONFTYPE_EXECUTE_ON                 string
 586   CONFTYPE_EXECUTE_WHERE              Math::BigInt
 587   CONFTYPE_SEND_AMREPORT_ON           Math::BigInt
 588   CONFTYPE_IDENTLIST                  [ string, .. ]
 589
 590 Note that C<CONFTYPE_INTRANGE> and C<CONFTYPE_RATE> each return two values, not
 591 an array reference.
 592
 593 Include and exclude lists with type C<CONFTYPE_EXINCLUDE> return a hash giving
 594 all listed filenames (in the C<list> key), include/exclude files (C<files>),
 595 and a boolean indicating that the list is optional (C<optional>):
 596
 597   { list => [ str, .. ], file => [ str, .. ], optional => Math::BigInt }
 598
 599 Properties are represented as a hash of hashes.  The keys are the property
 600 names, converted to ASCII lowercase.  Each property has a C<values> array
 601 giving all values specified for this property, as well as booleans C<priority>
 602 and C<append> that are true if the corresponding keyword was supplied.
 603
 604   { prop1 => { values => [ str, .. ] priority => int, append => int },
 605     prop2 => { .. } .. }
 606
 607 Note that integer types of all sizes become C<Math::BigInt> objects rather than
 608 Perl integers, as is the habit throughout Amanda.
 609
 610 The C<CNF_AUTOLABEL> value is a hash with the following keys
 611
 612   template      label template, or undef
 613   other_config  boolean
 614   non_amanda    boolean
 615   volume_error  boolean
 616   empty         boolean
 617
 618 =head2 OTHER ACCESS
 619
 620 Parameter values are available by name from C<getconf_byname($name)> and
 621 C<getconf_byname_strs($name, $str_needs_quotes)>.  These functions implement
 622 the C<TYP:NAME:PARAM> syntax advertised by C<amgetconf> to access values in
 623 subsections.  The first function returns a Perl value (see DATA FORMATS,
 624 above), while the second returns a list of strings suitable for use in
 625 C<amanda.conf>, including quotes around strings if C<$str_needs_quotes> is
 626 true.
 627
 628 C<getconf_list($typ)> returns a list of the names of all subsections of the
 629 given type.  C<%subsection_names> is a hash whose keys are allowed subsection
 630 names.
 631
 632 =head2 DERIVED VALUES
 633
 634 The C<$CNF_DISPLAYUNIT> implies a certain divisor to convert from
 635 kilobytes to the desired unit.  This divisor is available from
 636 C<getconf_unit_divisor()>.  Note carefully that it is a I<divisor>
 637 for a value in I<kilobytes>!
 638
 639 Finally, various subsections of Amanda enable verbose debugging via
 640 configuration parameters.  The status of each parameter is available
 641 a similarly-named variable, e.g., C<$debug_auth>.
 642
 643 All parameter access functions and constants can be imported with
 644 the tag C<:getconf>.
 645
 646 =head1 MISCELLANEOUS
 647
 648 These functions defy categorization.
 649
 650 The function C<config_dir_relative> will interpret a path relative to
 651 the current configuration directory.  Absolute paths are passed through
 652 unchanged, while relative paths are converted to absolute paths.
 653
 654 C<dump_configuration()> dumps the current configuration, in a format
 655 suitable for re-evaluation for this module, to standard output.
 656 This function may be revised to return a string.
 657
 658 Several parts of Amanda need to convert unit modifier value like
 659 "gbytes" to a multiplier.  The function C<find_multiplier($str)>
 660 returns the unit multiplier for such a string.  For example, "mbytes"
 661 is converted to 1048576 (1024*1024).
 662
 663 C<string_to_boolean()> takes a string and returns 0 if it matches any of
 664 Amanda's names for false, or 1 if matches a name for true. If it can't be
 665 interpreted, C<undef> is returned.
 666
 667 =cut
 668
 669
 670
 671 push @EXPORT_OK, qw(confparm_key_to_string);
 672 push @{$EXPORT_TAGS{"confparm_key"}}, qw(confparm_key_to_string);
 673
 674 my %_confparm_key_VALUES;
 675 #Convert an enum value to a single string
 676 sub confparm_key_to_string {
 677     my ($enumval) = @_;
 678
 679     for my $k (keys %_confparm_key_VALUES) {
 680         my $v = $_confparm_key_VALUES{$k};
 681
 682         #is this a matching flag?
 683         if ($enumval == $v) {
 684             return $k;
 685         }
 686     }
 687
 688 #default, just return the number
 689     return $enumval;
 690 }
 691
 692 push @EXPORT_OK, qw($CNF_ORG);
 693 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_ORG);
 694
 695 $_confparm_key_VALUES{"CNF_ORG"} = $CNF_ORG;
 696
 697 push @EXPORT_OK, qw($CNF_CONF);
 698 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CONF);
 699
 700 $_confparm_key_VALUES{"CNF_CONF"} = $CNF_CONF;
 701
 702 push @EXPORT_OK, qw($CNF_INDEX_SERVER);
 703 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_INDEX_SERVER);
 704
 705 $_confparm_key_VALUES{"CNF_INDEX_SERVER"} = $CNF_INDEX_SERVER;
 706
 707 push @EXPORT_OK, qw($CNF_TAPE_SERVER);
 708 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPE_SERVER);
 709
 710 $_confparm_key_VALUES{"CNF_TAPE_SERVER"} = $CNF_TAPE_SERVER;
 711
 712 push @EXPORT_OK, qw($CNF_AUTH);
 713 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AUTH);
 714
 715 $_confparm_key_VALUES{"CNF_AUTH"} = $CNF_AUTH;
 716
 717 push @EXPORT_OK, qw($CNF_SSH_KEYS);
 718 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_SSH_KEYS);
 719
 720 $_confparm_key_VALUES{"CNF_SSH_KEYS"} = $CNF_SSH_KEYS;
 721
 722 push @EXPORT_OK, qw($CNF_AMANDAD_PATH);
 723 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AMANDAD_PATH);
 724
 725 $_confparm_key_VALUES{"CNF_AMANDAD_PATH"} = $CNF_AMANDAD_PATH;
 726
 727 push @EXPORT_OK, qw($CNF_CLIENT_USERNAME);
 728 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CLIENT_USERNAME);
 729
 730 $_confparm_key_VALUES{"CNF_CLIENT_USERNAME"} = $CNF_CLIENT_USERNAME;
 731
 732 push @EXPORT_OK, qw($CNF_CLIENT_PORT);
 733 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CLIENT_PORT);
 734
 735 $_confparm_key_VALUES{"CNF_CLIENT_PORT"} = $CNF_CLIENT_PORT;
 736
 737 push @EXPORT_OK, qw($CNF_GNUTAR_LIST_DIR);
 738 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_GNUTAR_LIST_DIR);
 739
 740 $_confparm_key_VALUES{"CNF_GNUTAR_LIST_DIR"} = $CNF_GNUTAR_LIST_DIR;
 741
 742 push @EXPORT_OK, qw($CNF_AMANDATES);
 743 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AMANDATES);
 744
 745 $_confparm_key_VALUES{"CNF_AMANDATES"} = $CNF_AMANDATES;
 746
 747 push @EXPORT_OK, qw($CNF_MAILER);
 748 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_MAILER);
 749
 750 $_confparm_key_VALUES{"CNF_MAILER"} = $CNF_MAILER;
 751
 752 push @EXPORT_OK, qw($CNF_MAILTO);
 753 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_MAILTO);
 754
 755 $_confparm_key_VALUES{"CNF_MAILTO"} = $CNF_MAILTO;
 756
 757 push @EXPORT_OK, qw($CNF_DUMPUSER);
 758 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DUMPUSER);
 759
 760 $_confparm_key_VALUES{"CNF_DUMPUSER"} = $CNF_DUMPUSER;
 761
 762 push @EXPORT_OK, qw($CNF_TAPEDEV);
 763 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPEDEV);
 764
 765 $_confparm_key_VALUES{"CNF_TAPEDEV"} = $CNF_TAPEDEV;
 766
 767 push @EXPORT_OK, qw($CNF_DEVICE_PROPERTY);
 768 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEVICE_PROPERTY);
 769
 770 $_confparm_key_VALUES{"CNF_DEVICE_PROPERTY"} = $CNF_DEVICE_PROPERTY;
 771
 772 push @EXPORT_OK, qw($CNF_PROPERTY);
 773 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_PROPERTY);
 774
 775 $_confparm_key_VALUES{"CNF_PROPERTY"} = $CNF_PROPERTY;
 776
 777 push @EXPORT_OK, qw($CNF_CHANGERDEV);
 778 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CHANGERDEV);
 779
 780 $_confparm_key_VALUES{"CNF_CHANGERDEV"} = $CNF_CHANGERDEV;
 781
 782 push @EXPORT_OK, qw($CNF_CHANGERFILE);
 783 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CHANGERFILE);
 784
 785 $_confparm_key_VALUES{"CNF_CHANGERFILE"} = $CNF_CHANGERFILE;
 786
 787 push @EXPORT_OK, qw($CNF_LABELSTR);
 788 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_LABELSTR);
 789
 790 $_confparm_key_VALUES{"CNF_LABELSTR"} = $CNF_LABELSTR;
 791
 792 push @EXPORT_OK, qw($CNF_AUTOLABEL);
 793 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AUTOLABEL);
 794
 795 $_confparm_key_VALUES{"CNF_AUTOLABEL"} = $CNF_AUTOLABEL;
 796
 797 push @EXPORT_OK, qw($CNF_TAPELIST);
 798 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPELIST);
 799
 800 $_confparm_key_VALUES{"CNF_TAPELIST"} = $CNF_TAPELIST;
 801
 802 push @EXPORT_OK, qw($CNF_DISKFILE);
 803 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DISKFILE);
 804
 805 $_confparm_key_VALUES{"CNF_DISKFILE"} = $CNF_DISKFILE;
 806
 807 push @EXPORT_OK, qw($CNF_INFOFILE);
 808 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_INFOFILE);
 809
 810 $_confparm_key_VALUES{"CNF_INFOFILE"} = $CNF_INFOFILE;
 811
 812 push @EXPORT_OK, qw($CNF_LOGDIR);
 813 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_LOGDIR);
 814
 815 $_confparm_key_VALUES{"CNF_LOGDIR"} = $CNF_LOGDIR;
 816
 817 push @EXPORT_OK, qw($CNF_INDEXDIR);
 818 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_INDEXDIR);
 819
 820 $_confparm_key_VALUES{"CNF_INDEXDIR"} = $CNF_INDEXDIR;
 821
 822 push @EXPORT_OK, qw($CNF_TAPETYPE);
 823 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPETYPE);
 824
 825 $_confparm_key_VALUES{"CNF_TAPETYPE"} = $CNF_TAPETYPE;
 826
 827 push @EXPORT_OK, qw($CNF_DUMPCYCLE);
 828 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DUMPCYCLE);
 829
 830 $_confparm_key_VALUES{"CNF_DUMPCYCLE"} = $CNF_DUMPCYCLE;
 831
 832 push @EXPORT_OK, qw($CNF_RUNSPERCYCLE);
 833 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_RUNSPERCYCLE);
 834
 835 $_confparm_key_VALUES{"CNF_RUNSPERCYCLE"} = $CNF_RUNSPERCYCLE;
 836
 837 push @EXPORT_OK, qw($CNF_TAPECYCLE);
 838 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPECYCLE);
 839
 840 $_confparm_key_VALUES{"CNF_TAPECYCLE"} = $CNF_TAPECYCLE;
 841
 842 push @EXPORT_OK, qw($CNF_NETUSAGE);
 843 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_NETUSAGE);
 844
 845 $_confparm_key_VALUES{"CNF_NETUSAGE"} = $CNF_NETUSAGE;
 846
 847 push @EXPORT_OK, qw($CNF_INPARALLEL);
 848 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_INPARALLEL);
 849
 850 $_confparm_key_VALUES{"CNF_INPARALLEL"} = $CNF_INPARALLEL;
 851
 852 push @EXPORT_OK, qw($CNF_DUMPORDER);
 853 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DUMPORDER);
 854
 855 $_confparm_key_VALUES{"CNF_DUMPORDER"} = $CNF_DUMPORDER;
 856
 857 push @EXPORT_OK, qw($CNF_BUMPPERCENT);
 858 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_BUMPPERCENT);
 859
 860 $_confparm_key_VALUES{"CNF_BUMPPERCENT"} = $CNF_BUMPPERCENT;
 861
 862 push @EXPORT_OK, qw($CNF_BUMPSIZE);
 863 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_BUMPSIZE);
 864
 865 $_confparm_key_VALUES{"CNF_BUMPSIZE"} = $CNF_BUMPSIZE;
 866
 867 push @EXPORT_OK, qw($CNF_BUMPMULT);
 868 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_BUMPMULT);
 869
 870 $_confparm_key_VALUES{"CNF_BUMPMULT"} = $CNF_BUMPMULT;
 871
 872 push @EXPORT_OK, qw($CNF_BUMPDAYS);
 873 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_BUMPDAYS);
 874
 875 $_confparm_key_VALUES{"CNF_BUMPDAYS"} = $CNF_BUMPDAYS;
 876
 877 push @EXPORT_OK, qw($CNF_TPCHANGER);
 878 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TPCHANGER);
 879
 880 $_confparm_key_VALUES{"CNF_TPCHANGER"} = $CNF_TPCHANGER;
 881
 882 push @EXPORT_OK, qw($CNF_RUNTAPES);
 883 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_RUNTAPES);
 884
 885 $_confparm_key_VALUES{"CNF_RUNTAPES"} = $CNF_RUNTAPES;
 886
 887 push @EXPORT_OK, qw($CNF_MAXDUMPS);
 888 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_MAXDUMPS);
 889
 890 $_confparm_key_VALUES{"CNF_MAXDUMPS"} = $CNF_MAXDUMPS;
 891
 892 push @EXPORT_OK, qw($CNF_ETIMEOUT);
 893 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_ETIMEOUT);
 894
 895 $_confparm_key_VALUES{"CNF_ETIMEOUT"} = $CNF_ETIMEOUT;
 896
 897 push @EXPORT_OK, qw($CNF_DTIMEOUT);
 898 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DTIMEOUT);
 899
 900 $_confparm_key_VALUES{"CNF_DTIMEOUT"} = $CNF_DTIMEOUT;
 901
 902 push @EXPORT_OK, qw($CNF_CTIMEOUT);
 903 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CTIMEOUT);
 904
 905 $_confparm_key_VALUES{"CNF_CTIMEOUT"} = $CNF_CTIMEOUT;
 906
 907 push @EXPORT_OK, qw($CNF_TAPEBUFS);
 908 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPEBUFS);
 909
 910 $_confparm_key_VALUES{"CNF_TAPEBUFS"} = $CNF_TAPEBUFS;
 911
 912 push @EXPORT_OK, qw($CNF_DEVICE_OUTPUT_BUFFER_SIZE);
 913 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEVICE_OUTPUT_BUFFER_SIZE);
 914
 915 $_confparm_key_VALUES{"CNF_DEVICE_OUTPUT_BUFFER_SIZE"} = $CNF_DEVICE_OUTPUT_BUFFER_SIZE;
 916
 917 push @EXPORT_OK, qw($CNF_PRINTER);
 918 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_PRINTER);
 919
 920 $_confparm_key_VALUES{"CNF_PRINTER"} = $CNF_PRINTER;
 921
 922 push @EXPORT_OK, qw($CNF_AUTOFLUSH);
 923 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AUTOFLUSH);
 924
 925 $_confparm_key_VALUES{"CNF_AUTOFLUSH"} = $CNF_AUTOFLUSH;
 926
 927 push @EXPORT_OK, qw($CNF_RESERVE);
 928 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_RESERVE);
 929
 930 $_confparm_key_VALUES{"CNF_RESERVE"} = $CNF_RESERVE;
 931
 932 push @EXPORT_OK, qw($CNF_MAXDUMPSIZE);
 933 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_MAXDUMPSIZE);
 934
 935 $_confparm_key_VALUES{"CNF_MAXDUMPSIZE"} = $CNF_MAXDUMPSIZE;
 936
 937 push @EXPORT_OK, qw($CNF_COLUMNSPEC);
 938 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_COLUMNSPEC);
 939
 940 $_confparm_key_VALUES{"CNF_COLUMNSPEC"} = $CNF_COLUMNSPEC;
 941
 942 push @EXPORT_OK, qw($CNF_AMRECOVER_DO_FSF);
 943 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AMRECOVER_DO_FSF);
 944
 945 $_confparm_key_VALUES{"CNF_AMRECOVER_DO_FSF"} = $CNF_AMRECOVER_DO_FSF;
 946
 947 push @EXPORT_OK, qw($CNF_AMRECOVER_CHECK_LABEL);
 948 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AMRECOVER_CHECK_LABEL);
 949
 950 $_confparm_key_VALUES{"CNF_AMRECOVER_CHECK_LABEL"} = $CNF_AMRECOVER_CHECK_LABEL;
 951
 952 push @EXPORT_OK, qw($CNF_AMRECOVER_CHANGER);
 953 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_AMRECOVER_CHANGER);
 954
 955 $_confparm_key_VALUES{"CNF_AMRECOVER_CHANGER"} = $CNF_AMRECOVER_CHANGER;
 956
 957 push @EXPORT_OK, qw($CNF_TAPERALGO);
 958 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPERALGO);
 959
 960 $_confparm_key_VALUES{"CNF_TAPERALGO"} = $CNF_TAPERALGO;
 961
 962 push @EXPORT_OK, qw($CNF_FLUSH_THRESHOLD_DUMPED);
 963 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_FLUSH_THRESHOLD_DUMPED);
 964
 965 $_confparm_key_VALUES{"CNF_FLUSH_THRESHOLD_DUMPED"} = $CNF_FLUSH_THRESHOLD_DUMPED;
 966
 967 push @EXPORT_OK, qw($CNF_FLUSH_THRESHOLD_SCHEDULED);
 968 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_FLUSH_THRESHOLD_SCHEDULED);
 969
 970 $_confparm_key_VALUES{"CNF_FLUSH_THRESHOLD_SCHEDULED"} = $CNF_FLUSH_THRESHOLD_SCHEDULED;
 971
 972 push @EXPORT_OK, qw($CNF_TAPERFLUSH);
 973 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_TAPERFLUSH);
 974
 975 $_confparm_key_VALUES{"CNF_TAPERFLUSH"} = $CNF_TAPERFLUSH;
 976
 977 push @EXPORT_OK, qw($CNF_DISPLAYUNIT);
 978 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DISPLAYUNIT);
 979
 980 $_confparm_key_VALUES{"CNF_DISPLAYUNIT"} = $CNF_DISPLAYUNIT;
 981
 982 push @EXPORT_OK, qw($CNF_KRB5KEYTAB);
 983 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_KRB5KEYTAB);
 984
 985 $_confparm_key_VALUES{"CNF_KRB5KEYTAB"} = $CNF_KRB5KEYTAB;
 986
 987 push @EXPORT_OK, qw($CNF_KRB5PRINCIPAL);
 988 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_KRB5PRINCIPAL);
 989
 990 $_confparm_key_VALUES{"CNF_KRB5PRINCIPAL"} = $CNF_KRB5PRINCIPAL;
 991
 992 push @EXPORT_OK, qw($CNF_LABEL_NEW_TAPES);
 993 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_LABEL_NEW_TAPES);
 994
 995 $_confparm_key_VALUES{"CNF_LABEL_NEW_TAPES"} = $CNF_LABEL_NEW_TAPES;
 996
 997 push @EXPORT_OK, qw($CNF_USETIMESTAMPS);
 998 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_USETIMESTAMPS);
 999
1000 $_confparm_key_VALUES{"CNF_USETIMESTAMPS"} = $CNF_USETIMESTAMPS;
1001
1002 push @EXPORT_OK, qw($CNF_REP_TRIES);
1003 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_REP_TRIES);
1004
1005 $_confparm_key_VALUES{"CNF_REP_TRIES"} = $CNF_REP_TRIES;
1006
1007 push @EXPORT_OK, qw($CNF_CONNECT_TRIES);
1008 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_CONNECT_TRIES);
1009
1010 $_confparm_key_VALUES{"CNF_CONNECT_TRIES"} = $CNF_CONNECT_TRIES;
1011
1012 push @EXPORT_OK, qw($CNF_REQ_TRIES);
1013 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_REQ_TRIES);
1014
1015 $_confparm_key_VALUES{"CNF_REQ_TRIES"} = $CNF_REQ_TRIES;
1016
1017 push @EXPORT_OK, qw($CNF_DEBUG_AMANDAD);
1018 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_AMANDAD);
1019
1020 $_confparm_key_VALUES{"CNF_DEBUG_AMANDAD"} = $CNF_DEBUG_AMANDAD;
1021
1022 push @EXPORT_OK, qw($CNF_DEBUG_RECOVERY);
1023 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_RECOVERY);
1024
1025 $_confparm_key_VALUES{"CNF_DEBUG_RECOVERY"} = $CNF_DEBUG_RECOVERY;
1026
1027 push @EXPORT_OK, qw($CNF_DEBUG_AMIDXTAPED);
1028 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_AMIDXTAPED);
1029
1030 $_confparm_key_VALUES{"CNF_DEBUG_AMIDXTAPED"} = $CNF_DEBUG_AMIDXTAPED;
1031
1032 push @EXPORT_OK, qw($CNF_DEBUG_AMINDEXD);
1033 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_AMINDEXD);
1034
1035 $_confparm_key_VALUES{"CNF_DEBUG_AMINDEXD"} = $CNF_DEBUG_AMINDEXD;
1036
1037 push @EXPORT_OK, qw($CNF_DEBUG_AMRECOVER);
1038 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_AMRECOVER);
1039
1040 $_confparm_key_VALUES{"CNF_DEBUG_AMRECOVER"} = $CNF_DEBUG_AMRECOVER;
1041
1042 push @EXPORT_OK, qw($CNF_DEBUG_AUTH);
1043 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_AUTH);
1044
1045 $_confparm_key_VALUES{"CNF_DEBUG_AUTH"} = $CNF_DEBUG_AUTH;
1046
1047 push @EXPORT_OK, qw($CNF_DEBUG_EVENT);
1048 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_EVENT);
1049
1050 $_confparm_key_VALUES{"CNF_DEBUG_EVENT"} = $CNF_DEBUG_EVENT;
1051
1052 push @EXPORT_OK, qw($CNF_DEBUG_HOLDING);
1053 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_HOLDING);
1054
1055 $_confparm_key_VALUES{"CNF_DEBUG_HOLDING"} = $CNF_DEBUG_HOLDING;
1056
1057 push @EXPORT_OK, qw($CNF_DEBUG_PROTOCOL);
1058 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_PROTOCOL);
1059
1060 $_confparm_key_VALUES{"CNF_DEBUG_PROTOCOL"} = $CNF_DEBUG_PROTOCOL;
1061
1062 push @EXPORT_OK, qw($CNF_DEBUG_PLANNER);
1063 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_PLANNER);
1064
1065 $_confparm_key_VALUES{"CNF_DEBUG_PLANNER"} = $CNF_DEBUG_PLANNER;
1066
1067 push @EXPORT_OK, qw($CNF_DEBUG_DRIVER);
1068 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_DRIVER);
1069
1070 $_confparm_key_VALUES{"CNF_DEBUG_DRIVER"} = $CNF_DEBUG_DRIVER;
1071
1072 push @EXPORT_OK, qw($CNF_DEBUG_DUMPER);
1073 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_DUMPER);
1074
1075 $_confparm_key_VALUES{"CNF_DEBUG_DUMPER"} = $CNF_DEBUG_DUMPER;
1076
1077 push @EXPORT_OK, qw($CNF_DEBUG_CHUNKER);
1078 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_CHUNKER);
1079
1080 $_confparm_key_VALUES{"CNF_DEBUG_CHUNKER"} = $CNF_DEBUG_CHUNKER;
1081
1082 push @EXPORT_OK, qw($CNF_DEBUG_TAPER);
1083 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_TAPER);
1084
1085 $_confparm_key_VALUES{"CNF_DEBUG_TAPER"} = $CNF_DEBUG_TAPER;
1086
1087 push @EXPORT_OK, qw($CNF_DEBUG_SELFCHECK);
1088 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_SELFCHECK);
1089
1090 $_confparm_key_VALUES{"CNF_DEBUG_SELFCHECK"} = $CNF_DEBUG_SELFCHECK;
1091
1092 push @EXPORT_OK, qw($CNF_DEBUG_SENDSIZE);
1093 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_SENDSIZE);
1094
1095 $_confparm_key_VALUES{"CNF_DEBUG_SENDSIZE"} = $CNF_DEBUG_SENDSIZE;
1096
1097 push @EXPORT_OK, qw($CNF_DEBUG_SENDBACKUP);
1098 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_DEBUG_SENDBACKUP);
1099
1100 $_confparm_key_VALUES{"CNF_DEBUG_SENDBACKUP"} = $CNF_DEBUG_SENDBACKUP;
1101
1102 push @EXPORT_OK, qw($CNF_RESERVED_UDP_PORT);
1103 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_RESERVED_UDP_PORT);
1104
1105 $_confparm_key_VALUES{"CNF_RESERVED_UDP_PORT"} = $CNF_RESERVED_UDP_PORT;
1106
1107 push @EXPORT_OK, qw($CNF_RESERVED_TCP_PORT);
1108 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_RESERVED_TCP_PORT);
1109
1110 $_confparm_key_VALUES{"CNF_RESERVED_TCP_PORT"} = $CNF_RESERVED_TCP_PORT;
1111
1112 push @EXPORT_OK, qw($CNF_UNRESERVED_TCP_PORT);
1113 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_UNRESERVED_TCP_PORT);
1114
1115 $_confparm_key_VALUES{"CNF_UNRESERVED_TCP_PORT"} = $CNF_UNRESERVED_TCP_PORT;
1116
1117 push @EXPORT_OK, qw($CNF_HOLDINGDISK);
1118 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_HOLDINGDISK);
1119
1120 $_confparm_key_VALUES{"CNF_HOLDINGDISK"} = $CNF_HOLDINGDISK;
1121
1122 push @EXPORT_OK, qw($CNF_SEND_AMREPORT_ON);
1123 push @{$EXPORT_TAGS{"confparm_key"}}, qw($CNF_SEND_AMREPORT_ON);
1124
1125 $_confparm_key_VALUES{"CNF_SEND_AMREPORT_ON"} = $CNF_SEND_AMREPORT_ON;
1126
1127 #copy symbols in confparm_key to getconf
1128 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"confparm_key"}};
1129
1130 push @EXPORT_OK, qw(tapetype_key_to_string);
1131 push @{$EXPORT_TAGS{"tapetype_key"}}, qw(tapetype_key_to_string);
1132
1133 my %_tapetype_key_VALUES;
1134 #Convert an enum value to a single string
1135 sub tapetype_key_to_string {
1136     my ($enumval) = @_;
1137
1138     for my $k (keys %_tapetype_key_VALUES) {
1139         my $v = $_tapetype_key_VALUES{$k};
1140
1141         #is this a matching flag?
1142         if ($enumval == $v) {
1143             return $k;
1144         }
1145     }
1146
1147 #default, just return the number
1148     return $enumval;
1149 }
1150
1151 push @EXPORT_OK, qw($TAPETYPE_COMMENT);
1152 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_COMMENT);
1153
1154 $_tapetype_key_VALUES{"TAPETYPE_COMMENT"} = $TAPETYPE_COMMENT;
1155
1156 push @EXPORT_OK, qw($TAPETYPE_LBL_TEMPL);
1157 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_LBL_TEMPL);
1158
1159 $_tapetype_key_VALUES{"TAPETYPE_LBL_TEMPL"} = $TAPETYPE_LBL_TEMPL;
1160
1161 push @EXPORT_OK, qw($TAPETYPE_BLOCKSIZE);
1162 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_BLOCKSIZE);
1163
1164 $_tapetype_key_VALUES{"TAPETYPE_BLOCKSIZE"} = $TAPETYPE_BLOCKSIZE;
1165
1166 push @EXPORT_OK, qw($TAPETYPE_READBLOCKSIZE);
1167 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_READBLOCKSIZE);
1168
1169 $_tapetype_key_VALUES{"TAPETYPE_READBLOCKSIZE"} = $TAPETYPE_READBLOCKSIZE;
1170
1171 push @EXPORT_OK, qw($TAPETYPE_LENGTH);
1172 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_LENGTH);
1173
1174 $_tapetype_key_VALUES{"TAPETYPE_LENGTH"} = $TAPETYPE_LENGTH;
1175
1176 push @EXPORT_OK, qw($TAPETYPE_FILEMARK);
1177 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_FILEMARK);
1178
1179 $_tapetype_key_VALUES{"TAPETYPE_FILEMARK"} = $TAPETYPE_FILEMARK;
1180
1181 push @EXPORT_OK, qw($TAPETYPE_SPEED);
1182 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_SPEED);
1183
1184 $_tapetype_key_VALUES{"TAPETYPE_SPEED"} = $TAPETYPE_SPEED;
1185
1186 push @EXPORT_OK, qw($TAPETYPE_FILE_PAD);
1187 push @{$EXPORT_TAGS{"tapetype_key"}}, qw($TAPETYPE_FILE_PAD);
1188
1189 $_tapetype_key_VALUES{"TAPETYPE_FILE_PAD"} = $TAPETYPE_FILE_PAD;
1190
1191 #copy symbols in tapetype_key to getconf
1192 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"tapetype_key"}};
1193
1194 push @EXPORT_OK, qw(dumptype_key_to_string);
1195 push @{$EXPORT_TAGS{"dumptype_key"}}, qw(dumptype_key_to_string);
1196
1197 my %_dumptype_key_VALUES;
1198 #Convert an enum value to a single string
1199 sub dumptype_key_to_string {
1200     my ($enumval) = @_;
1201
1202     for my $k (keys %_dumptype_key_VALUES) {
1203         my $v = $_dumptype_key_VALUES{$k};
1204
1205         #is this a matching flag?
1206         if ($enumval == $v) {
1207             return $k;
1208         }
1209     }
1210
1211 #default, just return the number
1212     return $enumval;
1213 }
1214
1215 push @EXPORT_OK, qw($DUMPTYPE_COMMENT);
1216 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_COMMENT);
1217
1218 $_dumptype_key_VALUES{"DUMPTYPE_COMMENT"} = $DUMPTYPE_COMMENT;
1219
1220 push @EXPORT_OK, qw($DUMPTYPE_PROGRAM);
1221 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_PROGRAM);
1222
1223 $_dumptype_key_VALUES{"DUMPTYPE_PROGRAM"} = $DUMPTYPE_PROGRAM;
1224
1225 push @EXPORT_OK, qw($DUMPTYPE_SRVCOMPPROG);
1226 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SRVCOMPPROG);
1227
1228 $_dumptype_key_VALUES{"DUMPTYPE_SRVCOMPPROG"} = $DUMPTYPE_SRVCOMPPROG;
1229
1230 push @EXPORT_OK, qw($DUMPTYPE_CLNTCOMPPROG);
1231 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_CLNTCOMPPROG);
1232
1233 $_dumptype_key_VALUES{"DUMPTYPE_CLNTCOMPPROG"} = $DUMPTYPE_CLNTCOMPPROG;
1234
1235 push @EXPORT_OK, qw($DUMPTYPE_SRV_ENCRYPT);
1236 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SRV_ENCRYPT);
1237
1238 $_dumptype_key_VALUES{"DUMPTYPE_SRV_ENCRYPT"} = $DUMPTYPE_SRV_ENCRYPT;
1239
1240 push @EXPORT_OK, qw($DUMPTYPE_CLNT_ENCRYPT);
1241 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_CLNT_ENCRYPT);
1242
1243 $_dumptype_key_VALUES{"DUMPTYPE_CLNT_ENCRYPT"} = $DUMPTYPE_CLNT_ENCRYPT;
1244
1245 push @EXPORT_OK, qw($DUMPTYPE_AMANDAD_PATH);
1246 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_AMANDAD_PATH);
1247
1248 $_dumptype_key_VALUES{"DUMPTYPE_AMANDAD_PATH"} = $DUMPTYPE_AMANDAD_PATH;
1249
1250 push @EXPORT_OK, qw($DUMPTYPE_CLIENT_USERNAME);
1251 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_CLIENT_USERNAME);
1252
1253 $_dumptype_key_VALUES{"DUMPTYPE_CLIENT_USERNAME"} = $DUMPTYPE_CLIENT_USERNAME;
1254
1255 push @EXPORT_OK, qw($DUMPTYPE_CLIENT_PORT);
1256 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_CLIENT_PORT);
1257
1258 $_dumptype_key_VALUES{"DUMPTYPE_CLIENT_PORT"} = $DUMPTYPE_CLIENT_PORT;
1259
1260 push @EXPORT_OK, qw($DUMPTYPE_SSH_KEYS);
1261 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SSH_KEYS);
1262
1263 $_dumptype_key_VALUES{"DUMPTYPE_SSH_KEYS"} = $DUMPTYPE_SSH_KEYS;
1264
1265 push @EXPORT_OK, qw($DUMPTYPE_AUTH);
1266 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_AUTH);
1267
1268 $_dumptype_key_VALUES{"DUMPTYPE_AUTH"} = $DUMPTYPE_AUTH;
1269
1270 push @EXPORT_OK, qw($DUMPTYPE_EXCLUDE);
1271 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_EXCLUDE);
1272
1273 $_dumptype_key_VALUES{"DUMPTYPE_EXCLUDE"} = $DUMPTYPE_EXCLUDE;
1274
1275 push @EXPORT_OK, qw($DUMPTYPE_INCLUDE);
1276 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_INCLUDE);
1277
1278 $_dumptype_key_VALUES{"DUMPTYPE_INCLUDE"} = $DUMPTYPE_INCLUDE;
1279
1280 push @EXPORT_OK, qw($DUMPTYPE_PRIORITY);
1281 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_PRIORITY);
1282
1283 $_dumptype_key_VALUES{"DUMPTYPE_PRIORITY"} = $DUMPTYPE_PRIORITY;
1284
1285 push @EXPORT_OK, qw($DUMPTYPE_DUMPCYCLE);
1286 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_DUMPCYCLE);
1287
1288 $_dumptype_key_VALUES{"DUMPTYPE_DUMPCYCLE"} = $DUMPTYPE_DUMPCYCLE;
1289
1290 push @EXPORT_OK, qw($DUMPTYPE_MAXDUMPS);
1291 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_MAXDUMPS);
1292
1293 $_dumptype_key_VALUES{"DUMPTYPE_MAXDUMPS"} = $DUMPTYPE_MAXDUMPS;
1294
1295 push @EXPORT_OK, qw($DUMPTYPE_MAXPROMOTEDAY);
1296 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_MAXPROMOTEDAY);
1297
1298 $_dumptype_key_VALUES{"DUMPTYPE_MAXPROMOTEDAY"} = $DUMPTYPE_MAXPROMOTEDAY;
1299
1300 push @EXPORT_OK, qw($DUMPTYPE_BUMPPERCENT);
1301 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_BUMPPERCENT);
1302
1303 $_dumptype_key_VALUES{"DUMPTYPE_BUMPPERCENT"} = $DUMPTYPE_BUMPPERCENT;
1304
1305 push @EXPORT_OK, qw($DUMPTYPE_BUMPSIZE);
1306 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_BUMPSIZE);
1307
1308 $_dumptype_key_VALUES{"DUMPTYPE_BUMPSIZE"} = $DUMPTYPE_BUMPSIZE;
1309
1310 push @EXPORT_OK, qw($DUMPTYPE_BUMPDAYS);
1311 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_BUMPDAYS);
1312
1313 $_dumptype_key_VALUES{"DUMPTYPE_BUMPDAYS"} = $DUMPTYPE_BUMPDAYS;
1314
1315 push @EXPORT_OK, qw($DUMPTYPE_BUMPMULT);
1316 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_BUMPMULT);
1317
1318 $_dumptype_key_VALUES{"DUMPTYPE_BUMPMULT"} = $DUMPTYPE_BUMPMULT;
1319
1320 push @EXPORT_OK, qw($DUMPTYPE_STARTTIME);
1321 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_STARTTIME);
1322
1323 $_dumptype_key_VALUES{"DUMPTYPE_STARTTIME"} = $DUMPTYPE_STARTTIME;
1324
1325 push @EXPORT_OK, qw($DUMPTYPE_STRATEGY);
1326 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_STRATEGY);
1327
1328 $_dumptype_key_VALUES{"DUMPTYPE_STRATEGY"} = $DUMPTYPE_STRATEGY;
1329
1330 push @EXPORT_OK, qw($DUMPTYPE_ESTIMATELIST);
1331 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_ESTIMATELIST);
1332
1333 $_dumptype_key_VALUES{"DUMPTYPE_ESTIMATELIST"} = $DUMPTYPE_ESTIMATELIST;
1334
1335 push @EXPORT_OK, qw($DUMPTYPE_COMPRESS);
1336 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_COMPRESS);
1337
1338 $_dumptype_key_VALUES{"DUMPTYPE_COMPRESS"} = $DUMPTYPE_COMPRESS;
1339
1340 push @EXPORT_OK, qw($DUMPTYPE_ENCRYPT);
1341 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_ENCRYPT);
1342
1343 $_dumptype_key_VALUES{"DUMPTYPE_ENCRYPT"} = $DUMPTYPE_ENCRYPT;
1344
1345 push @EXPORT_OK, qw($DUMPTYPE_SRV_DECRYPT_OPT);
1346 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SRV_DECRYPT_OPT);
1347
1348 $_dumptype_key_VALUES{"DUMPTYPE_SRV_DECRYPT_OPT"} = $DUMPTYPE_SRV_DECRYPT_OPT;
1349
1350 push @EXPORT_OK, qw($DUMPTYPE_CLNT_DECRYPT_OPT);
1351 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_CLNT_DECRYPT_OPT);
1352
1353 $_dumptype_key_VALUES{"DUMPTYPE_CLNT_DECRYPT_OPT"} = $DUMPTYPE_CLNT_DECRYPT_OPT;
1354
1355 push @EXPORT_OK, qw($DUMPTYPE_COMPRATE);
1356 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_COMPRATE);
1357
1358 $_dumptype_key_VALUES{"DUMPTYPE_COMPRATE"} = $DUMPTYPE_COMPRATE;
1359
1360 push @EXPORT_OK, qw($DUMPTYPE_TAPE_SPLITSIZE);
1361 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_TAPE_SPLITSIZE);
1362
1363 $_dumptype_key_VALUES{"DUMPTYPE_TAPE_SPLITSIZE"} = $DUMPTYPE_TAPE_SPLITSIZE;
1364
1365 push @EXPORT_OK, qw($DUMPTYPE_FALLBACK_SPLITSIZE);
1366 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_FALLBACK_SPLITSIZE);
1367
1368 $_dumptype_key_VALUES{"DUMPTYPE_FALLBACK_SPLITSIZE"} = $DUMPTYPE_FALLBACK_SPLITSIZE;
1369
1370 push @EXPORT_OK, qw($DUMPTYPE_SPLIT_DISKBUFFER);
1371 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SPLIT_DISKBUFFER);
1372
1373 $_dumptype_key_VALUES{"DUMPTYPE_SPLIT_DISKBUFFER"} = $DUMPTYPE_SPLIT_DISKBUFFER;
1374
1375 push @EXPORT_OK, qw($DUMPTYPE_RECORD);
1376 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_RECORD);
1377
1378 $_dumptype_key_VALUES{"DUMPTYPE_RECORD"} = $DUMPTYPE_RECORD;
1379
1380 push @EXPORT_OK, qw($DUMPTYPE_SKIP_INCR);
1381 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SKIP_INCR);
1382
1383 $_dumptype_key_VALUES{"DUMPTYPE_SKIP_INCR"} = $DUMPTYPE_SKIP_INCR;
1384
1385 push @EXPORT_OK, qw($DUMPTYPE_SKIP_FULL);
1386 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SKIP_FULL);
1387
1388 $_dumptype_key_VALUES{"DUMPTYPE_SKIP_FULL"} = $DUMPTYPE_SKIP_FULL;
1389
1390 push @EXPORT_OK, qw($DUMPTYPE_HOLDINGDISK);
1391 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_HOLDINGDISK);
1392
1393 $_dumptype_key_VALUES{"DUMPTYPE_HOLDINGDISK"} = $DUMPTYPE_HOLDINGDISK;
1394
1395 push @EXPORT_OK, qw($DUMPTYPE_KENCRYPT);
1396 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_KENCRYPT);
1397
1398 $_dumptype_key_VALUES{"DUMPTYPE_KENCRYPT"} = $DUMPTYPE_KENCRYPT;
1399
1400 push @EXPORT_OK, qw($DUMPTYPE_IGNORE);
1401 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_IGNORE);
1402
1403 $_dumptype_key_VALUES{"DUMPTYPE_IGNORE"} = $DUMPTYPE_IGNORE;
1404
1405 push @EXPORT_OK, qw($DUMPTYPE_INDEX);
1406 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_INDEX);
1407
1408 $_dumptype_key_VALUES{"DUMPTYPE_INDEX"} = $DUMPTYPE_INDEX;
1409
1410 push @EXPORT_OK, qw($DUMPTYPE_APPLICATION);
1411 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_APPLICATION);
1412
1413 $_dumptype_key_VALUES{"DUMPTYPE_APPLICATION"} = $DUMPTYPE_APPLICATION;
1414
1415 push @EXPORT_OK, qw($DUMPTYPE_SCRIPTLIST);
1416 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_SCRIPTLIST);
1417
1418 $_dumptype_key_VALUES{"DUMPTYPE_SCRIPTLIST"} = $DUMPTYPE_SCRIPTLIST;
1419
1420 push @EXPORT_OK, qw($DUMPTYPE_PROPERTY);
1421 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_PROPERTY);
1422
1423 $_dumptype_key_VALUES{"DUMPTYPE_PROPERTY"} = $DUMPTYPE_PROPERTY;
1424
1425 push @EXPORT_OK, qw($DUMPTYPE_DATA_PATH);
1426 push @{$EXPORT_TAGS{"dumptype_key"}}, qw($DUMPTYPE_DATA_PATH);
1427
1428 $_dumptype_key_VALUES{"DUMPTYPE_DATA_PATH"} = $DUMPTYPE_DATA_PATH;
1429
1430 #copy symbols in dumptype_key to getconf
1431 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"dumptype_key"}};
1432
1433 push @EXPORT_OK, qw(interface_key_to_string);
1434 push @{$EXPORT_TAGS{"interface_key"}}, qw(interface_key_to_string);
1435
1436 my %_interface_key_VALUES;
1437 #Convert an enum value to a single string
1438 sub interface_key_to_string {
1439     my ($enumval) = @_;
1440
1441     for my $k (keys %_interface_key_VALUES) {
1442         my $v = $_interface_key_VALUES{$k};
1443
1444         #is this a matching flag?
1445         if ($enumval == $v) {
1446             return $k;
1447         }
1448     }
1449
1450 #default, just return the number
1451     return $enumval;
1452 }
1453
1454 push @EXPORT_OK, qw($INTER_COMMENT);
1455 push @{$EXPORT_TAGS{"interface_key"}}, qw($INTER_COMMENT);
1456
1457 $_interface_key_VALUES{"INTER_COMMENT"} = $INTER_COMMENT;
1458
1459 push @EXPORT_OK, qw($INTER_MAXUSAGE);
1460 push @{$EXPORT_TAGS{"interface_key"}}, qw($INTER_MAXUSAGE);
1461
1462 $_interface_key_VALUES{"INTER_MAXUSAGE"} = $INTER_MAXUSAGE;
1463
1464 #copy symbols in interface_key to getconf
1465 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"interface_key"}};
1466
1467 push @EXPORT_OK, qw(holdingdisk_key_to_string);
1468 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw(holdingdisk_key_to_string);
1469
1470 my %_holdingdisk_key_VALUES;
1471 #Convert an enum value to a single string
1472 sub holdingdisk_key_to_string {
1473     my ($enumval) = @_;
1474
1475     for my $k (keys %_holdingdisk_key_VALUES) {
1476         my $v = $_holdingdisk_key_VALUES{$k};
1477
1478         #is this a matching flag?
1479         if ($enumval == $v) {
1480             return $k;
1481         }
1482     }
1483
1484 #default, just return the number
1485     return $enumval;
1486 }
1487
1488 push @EXPORT_OK, qw($HOLDING_COMMENT);
1489 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw($HOLDING_COMMENT);
1490
1491 $_holdingdisk_key_VALUES{"HOLDING_COMMENT"} = $HOLDING_COMMENT;
1492
1493 push @EXPORT_OK, qw($HOLDING_DISKDIR);
1494 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw($HOLDING_DISKDIR);
1495
1496 $_holdingdisk_key_VALUES{"HOLDING_DISKDIR"} = $HOLDING_DISKDIR;
1497
1498 push @EXPORT_OK, qw($HOLDING_DISKSIZE);
1499 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw($HOLDING_DISKSIZE);
1500
1501 $_holdingdisk_key_VALUES{"HOLDING_DISKSIZE"} = $HOLDING_DISKSIZE;
1502
1503 push @EXPORT_OK, qw($HOLDING_CHUNKSIZE);
1504 push @{$EXPORT_TAGS{"holdingdisk_key"}}, qw($HOLDING_CHUNKSIZE);
1505
1506 $_holdingdisk_key_VALUES{"HOLDING_CHUNKSIZE"} = $HOLDING_CHUNKSIZE;
1507
1508 #copy symbols in holdingdisk_key to getconf
1509 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"holdingdisk_key"}};
1510
1511 push @EXPORT_OK, qw(application_key_to_string);
1512 push @{$EXPORT_TAGS{"application_key"}}, qw(application_key_to_string);
1513
1514 my %_application_key_VALUES;
1515 #Convert an enum value to a single string
1516 sub application_key_to_string {
1517     my ($enumval) = @_;
1518
1519     for my $k (keys %_application_key_VALUES) {
1520         my $v = $_application_key_VALUES{$k};
1521
1522         #is this a matching flag?
1523         if ($enumval == $v) {
1524             return $k;
1525         }
1526     }
1527
1528 #default, just return the number
1529     return $enumval;
1530 }
1531
1532 push @EXPORT_OK, qw($APPLICATION_COMMENT);
1533 push @{$EXPORT_TAGS{"application_key"}}, qw($APPLICATION_COMMENT);
1534
1535 $_application_key_VALUES{"APPLICATION_COMMENT"} = $APPLICATION_COMMENT;
1536
1537 push @EXPORT_OK, qw($APPLICATION_PLUGIN);
1538 push @{$EXPORT_TAGS{"application_key"}}, qw($APPLICATION_PLUGIN);
1539
1540 $_application_key_VALUES{"APPLICATION_PLUGIN"} = $APPLICATION_PLUGIN;
1541
1542 push @EXPORT_OK, qw($APPLICATION_PROPERTY);
1543 push @{$EXPORT_TAGS{"application_key"}}, qw($APPLICATION_PROPERTY);
1544
1545 $_application_key_VALUES{"APPLICATION_PROPERTY"} = $APPLICATION_PROPERTY;
1546
1547 #copy symbols in application_key to getconf
1548 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"application_key"}};
1549
1550 push @EXPORT_OK, qw(pp_script_key_to_string);
1551 push @{$EXPORT_TAGS{"pp_script_key"}}, qw(pp_script_key_to_string);
1552
1553 my %_pp_script_key_VALUES;
1554 #Convert an enum value to a single string
1555 sub pp_script_key_to_string {
1556     my ($enumval) = @_;
1557
1558     for my $k (keys %_pp_script_key_VALUES) {
1559         my $v = $_pp_script_key_VALUES{$k};
1560
1561         #is this a matching flag?
1562         if ($enumval == $v) {
1563             return $k;
1564         }
1565     }
1566
1567 #default, just return the number
1568     return $enumval;
1569 }
1570
1571 push @EXPORT_OK, qw($PP_SCRIPT_COMMENT);
1572 push @{$EXPORT_TAGS{"pp_script_key"}}, qw($PP_SCRIPT_COMMENT);
1573
1574 $_pp_script_key_VALUES{"PP_SCRIPT_COMMENT"} = $PP_SCRIPT_COMMENT;
1575
1576 push @EXPORT_OK, qw($PP_SCRIPT_PLUGIN);
1577 push @{$EXPORT_TAGS{"pp_script_key"}}, qw($PP_SCRIPT_PLUGIN);
1578
1579 $_pp_script_key_VALUES{"PP_SCRIPT_PLUGIN"} = $PP_SCRIPT_PLUGIN;
1580
1581 push @EXPORT_OK, qw($PP_SCRIPT_PROPERTY);
1582 push @{$EXPORT_TAGS{"pp_script_key"}}, qw($PP_SCRIPT_PROPERTY);
1583
1584 $_pp_script_key_VALUES{"PP_SCRIPT_PROPERTY"} = $PP_SCRIPT_PROPERTY;
1585
1586 push @EXPORT_OK, qw($PP_SCRIPT_EXECUTE_ON);
1587 push @{$EXPORT_TAGS{"pp_script_key"}}, qw($PP_SCRIPT_EXECUTE_ON);
1588
1589 $_pp_script_key_VALUES{"PP_SCRIPT_EXECUTE_ON"} = $PP_SCRIPT_EXECUTE_ON;
1590
1591 push @EXPORT_OK, qw($PP_SCRIPT_EXECUTE_WHERE);
1592 push @{$EXPORT_TAGS{"pp_script_key"}}, qw($PP_SCRIPT_EXECUTE_WHERE);
1593
1594 $_pp_script_key_VALUES{"PP_SCRIPT_EXECUTE_WHERE"} = $PP_SCRIPT_EXECUTE_WHERE;
1595
1596 push @EXPORT_OK, qw($PP_SCRIPT_ORDER);
1597 push @{$EXPORT_TAGS{"pp_script_key"}}, qw($PP_SCRIPT_ORDER);
1598
1599 $_pp_script_key_VALUES{"PP_SCRIPT_ORDER"} = $PP_SCRIPT_ORDER;
1600
1601 #copy symbols in pp_script_key to getconf
1602 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"pp_script_key"}};
1603
1604 push @EXPORT_OK, qw(device_config_key_to_string);
1605 push @{$EXPORT_TAGS{"device_config_key"}}, qw(device_config_key_to_string);
1606
1607 my %_device_config_key_VALUES;
1608 #Convert an enum value to a single string
1609 sub device_config_key_to_string {
1610     my ($enumval) = @_;
1611
1612     for my $k (keys %_device_config_key_VALUES) {
1613         my $v = $_device_config_key_VALUES{$k};
1614
1615         #is this a matching flag?
1616         if ($enumval == $v) {
1617             return $k;
1618         }
1619     }
1620
1621 #default, just return the number
1622     return $enumval;
1623 }
1624
1625 push @EXPORT_OK, qw($DEVICE_CONFIG_COMMENT);
1626 push @{$EXPORT_TAGS{"device_config_key"}}, qw($DEVICE_CONFIG_COMMENT);
1627
1628 $_device_config_key_VALUES{"DEVICE_CONFIG_COMMENT"} = $DEVICE_CONFIG_COMMENT;
1629
1630 push @EXPORT_OK, qw($DEVICE_CONFIG_TAPEDEV);
1631 push @{$EXPORT_TAGS{"device_config_key"}}, qw($DEVICE_CONFIG_TAPEDEV);
1632
1633 $_device_config_key_VALUES{"DEVICE_CONFIG_TAPEDEV"} = $DEVICE_CONFIG_TAPEDEV;
1634
1635 push @EXPORT_OK, qw($DEVICE_CONFIG_DEVICE_PROPERTY);
1636 push @{$EXPORT_TAGS{"device_config_key"}}, qw($DEVICE_CONFIG_DEVICE_PROPERTY);
1637
1638 $_device_config_key_VALUES{"DEVICE_CONFIG_DEVICE_PROPERTY"} = $DEVICE_CONFIG_DEVICE_PROPERTY;
1639
1640 #copy symbols in device_config_key to getconf
1641 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"device_config_key"}};
1642
1643 push @EXPORT_OK, qw(changer_config_key_to_string);
1644 push @{$EXPORT_TAGS{"changer_config_key"}}, qw(changer_config_key_to_string);
1645
1646 my %_changer_config_key_VALUES;
1647 #Convert an enum value to a single string
1648 sub changer_config_key_to_string {
1649     my ($enumval) = @_;
1650
1651     for my $k (keys %_changer_config_key_VALUES) {
1652         my $v = $_changer_config_key_VALUES{$k};
1653
1654         #is this a matching flag?
1655         if ($enumval == $v) {
1656             return $k;
1657         }
1658     }
1659
1660 #default, just return the number
1661     return $enumval;
1662 }
1663
1664 push @EXPORT_OK, qw($CHANGER_CONFIG_COMMENT);
1665 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_COMMENT);
1666
1667 $_changer_config_key_VALUES{"CHANGER_CONFIG_COMMENT"} = $CHANGER_CONFIG_COMMENT;
1668
1669 push @EXPORT_OK, qw($CHANGER_CONFIG_TAPEDEV);
1670 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_TAPEDEV);
1671
1672 $_changer_config_key_VALUES{"CHANGER_CONFIG_TAPEDEV"} = $CHANGER_CONFIG_TAPEDEV;
1673
1674 push @EXPORT_OK, qw($CHANGER_CONFIG_TPCHANGER);
1675 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_TPCHANGER);
1676
1677 $_changer_config_key_VALUES{"CHANGER_CONFIG_TPCHANGER"} = $CHANGER_CONFIG_TPCHANGER;
1678
1679 push @EXPORT_OK, qw($CHANGER_CONFIG_CHANGERDEV);
1680 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_CHANGERDEV);
1681
1682 $_changer_config_key_VALUES{"CHANGER_CONFIG_CHANGERDEV"} = $CHANGER_CONFIG_CHANGERDEV;
1683
1684 push @EXPORT_OK, qw($CHANGER_CONFIG_CHANGERFILE);
1685 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_CHANGERFILE);
1686
1687 $_changer_config_key_VALUES{"CHANGER_CONFIG_CHANGERFILE"} = $CHANGER_CONFIG_CHANGERFILE;
1688
1689 push @EXPORT_OK, qw($CHANGER_CONFIG_PROPERTY);
1690 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_PROPERTY);
1691
1692 $_changer_config_key_VALUES{"CHANGER_CONFIG_PROPERTY"} = $CHANGER_CONFIG_PROPERTY;
1693
1694 push @EXPORT_OK, qw($CHANGER_CONFIG_DEVICE_PROPERTY);
1695 push @{$EXPORT_TAGS{"changer_config_key"}}, qw($CHANGER_CONFIG_DEVICE_PROPERTY);
1696
1697 $_changer_config_key_VALUES{"CHANGER_CONFIG_DEVICE_PROPERTY"} = $CHANGER_CONFIG_DEVICE_PROPERTY;
1698
1699 #copy symbols in changer_config_key to getconf
1700 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"changer_config_key"}};
1701
1702 push @EXPORT_OK, qw(dump_holdingdisk_t_to_string);
1703 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw(dump_holdingdisk_t_to_string);
1704
1705 my %_dump_holdingdisk_t_VALUES;
1706 #Convert an enum value to a single string
1707 sub dump_holdingdisk_t_to_string {
1708     my ($enumval) = @_;
1709
1710     for my $k (keys %_dump_holdingdisk_t_VALUES) {
1711         my $v = $_dump_holdingdisk_t_VALUES{$k};
1712
1713         #is this a matching flag?
1714         if ($enumval == $v) {
1715             return $k;
1716         }
1717     }
1718
1719 #default, just return the number
1720     return $enumval;
1721 }
1722
1723 push @EXPORT_OK, qw($HOLD_NEVER);
1724 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw($HOLD_NEVER);
1725
1726 $_dump_holdingdisk_t_VALUES{"HOLD_NEVER"} = $HOLD_NEVER;
1727
1728 push @EXPORT_OK, qw($HOLD_AUTO);
1729 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw($HOLD_AUTO);
1730
1731 $_dump_holdingdisk_t_VALUES{"HOLD_AUTO"} = $HOLD_AUTO;
1732
1733 push @EXPORT_OK, qw($HOLD_REQUIRED);
1734 push @{$EXPORT_TAGS{"dump_holdingdisk_t"}}, qw($HOLD_REQUIRED);
1735
1736 $_dump_holdingdisk_t_VALUES{"HOLD_REQUIRED"} = $HOLD_REQUIRED;
1737
1738 #copy symbols in dump_holdingdisk_t to getconf
1739 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"dump_holdingdisk_t"}};
1740
1741 push @EXPORT_OK, qw(comp_t_to_string);
1742 push @{$EXPORT_TAGS{"comp_t"}}, qw(comp_t_to_string);
1743
1744 my %_comp_t_VALUES;
1745 #Convert an enum value to a single string
1746 sub comp_t_to_string {
1747     my ($enumval) = @_;
1748
1749     for my $k (keys %_comp_t_VALUES) {
1750         my $v = $_comp_t_VALUES{$k};
1751
1752         #is this a matching flag?
1753         if ($enumval == $v) {
1754             return $k;
1755         }
1756     }
1757
1758 #default, just return the number
1759     return $enumval;
1760 }
1761
1762 push @EXPORT_OK, qw($COMP_NONE);
1763 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_NONE);
1764
1765 $_comp_t_VALUES{"COMP_NONE"} = $COMP_NONE;
1766
1767 push @EXPORT_OK, qw($COMP_FAST);
1768 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_FAST);
1769
1770 $_comp_t_VALUES{"COMP_FAST"} = $COMP_FAST;
1771
1772 push @EXPORT_OK, qw($COMP_BEST);
1773 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_BEST);
1774
1775 $_comp_t_VALUES{"COMP_BEST"} = $COMP_BEST;
1776
1777 push @EXPORT_OK, qw($COMP_CUST);
1778 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_CUST);
1779
1780 $_comp_t_VALUES{"COMP_CUST"} = $COMP_CUST;
1781
1782 push @EXPORT_OK, qw($COMP_SERVER_FAST);
1783 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_SERVER_FAST);
1784
1785 $_comp_t_VALUES{"COMP_SERVER_FAST"} = $COMP_SERVER_FAST;
1786
1787 push @EXPORT_OK, qw($COMP_SERVER_BEST);
1788 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_SERVER_BEST);
1789
1790 $_comp_t_VALUES{"COMP_SERVER_BEST"} = $COMP_SERVER_BEST;
1791
1792 push @EXPORT_OK, qw($COMP_SERVER_CUST);
1793 push @{$EXPORT_TAGS{"comp_t"}}, qw($COMP_SERVER_CUST);
1794
1795 $_comp_t_VALUES{"COMP_SERVER_CUST"} = $COMP_SERVER_CUST;
1796
1797 #copy symbols in comp_t to getconf
1798 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"comp_t"}};
1799
1800 push @EXPORT_OK, qw(encrypt_t_to_string);
1801 push @{$EXPORT_TAGS{"encrypt_t"}}, qw(encrypt_t_to_string);
1802
1803 my %_encrypt_t_VALUES;
1804 #Convert an enum value to a single string
1805 sub encrypt_t_to_string {
1806     my ($enumval) = @_;
1807
1808     for my $k (keys %_encrypt_t_VALUES) {
1809         my $v = $_encrypt_t_VALUES{$k};
1810
1811         #is this a matching flag?
1812         if ($enumval == $v) {
1813             return $k;
1814         }
1815     }
1816
1817 #default, just return the number
1818     return $enumval;
1819 }
1820
1821 push @EXPORT_OK, qw($ENCRYPT_NONE);
1822 push @{$EXPORT_TAGS{"encrypt_t"}}, qw($ENCRYPT_NONE);
1823
1824 $_encrypt_t_VALUES{"ENCRYPT_NONE"} = $ENCRYPT_NONE;
1825
1826 push @EXPORT_OK, qw($ENCRYPT_CUST);
1827 push @{$EXPORT_TAGS{"encrypt_t"}}, qw($ENCRYPT_CUST);
1828
1829 $_encrypt_t_VALUES{"ENCRYPT_CUST"} = $ENCRYPT_CUST;
1830
1831 push @EXPORT_OK, qw($ENCRYPT_SERV_CUST);
1832 push @{$EXPORT_TAGS{"encrypt_t"}}, qw($ENCRYPT_SERV_CUST);
1833
1834 $_encrypt_t_VALUES{"ENCRYPT_SERV_CUST"} = $ENCRYPT_SERV_CUST;
1835
1836 #copy symbols in encrypt_t to getconf
1837 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"encrypt_t"}};
1838
1839 push @EXPORT_OK, qw(strategy_t_to_string);
1840 push @{$EXPORT_TAGS{"strategy_t"}}, qw(strategy_t_to_string);
1841
1842 my %_strategy_t_VALUES;
1843 #Convert an enum value to a single string
1844 sub strategy_t_to_string {
1845     my ($enumval) = @_;
1846
1847     for my $k (keys %_strategy_t_VALUES) {
1848         my $v = $_strategy_t_VALUES{$k};
1849
1850         #is this a matching flag?
1851         if ($enumval == $v) {
1852             return $k;
1853         }
1854     }
1855
1856 #default, just return the number
1857     return $enumval;
1858 }
1859
1860 push @EXPORT_OK, qw($DS_SKIP);
1861 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_SKIP);
1862
1863 $_strategy_t_VALUES{"DS_SKIP"} = $DS_SKIP;
1864
1865 push @EXPORT_OK, qw($DS_STANDARD);
1866 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_STANDARD);
1867
1868 $_strategy_t_VALUES{"DS_STANDARD"} = $DS_STANDARD;
1869
1870 push @EXPORT_OK, qw($DS_NOFULL);
1871 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_NOFULL);
1872
1873 $_strategy_t_VALUES{"DS_NOFULL"} = $DS_NOFULL;
1874
1875 push @EXPORT_OK, qw($DS_NOINC);
1876 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_NOINC);
1877
1878 $_strategy_t_VALUES{"DS_NOINC"} = $DS_NOINC;
1879
1880 push @EXPORT_OK, qw($DS_4);
1881 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_4);
1882
1883 $_strategy_t_VALUES{"DS_4"} = $DS_4;
1884
1885 push @EXPORT_OK, qw($DS_5);
1886 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_5);
1887
1888 $_strategy_t_VALUES{"DS_5"} = $DS_5;
1889
1890 push @EXPORT_OK, qw($DS_HANOI);
1891 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_HANOI);
1892
1893 $_strategy_t_VALUES{"DS_HANOI"} = $DS_HANOI;
1894
1895 push @EXPORT_OK, qw($DS_INCRONLY);
1896 push @{$EXPORT_TAGS{"strategy_t"}}, qw($DS_INCRONLY);
1897
1898 $_strategy_t_VALUES{"DS_INCRONLY"} = $DS_INCRONLY;
1899
1900 #copy symbols in strategy_t to getconf
1901 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"strategy_t"}};
1902
1903 push @EXPORT_OK, qw(estimate_t_to_string);
1904 push @{$EXPORT_TAGS{"estimate_t"}}, qw(estimate_t_to_string);
1905
1906 my %_estimate_t_VALUES;
1907 #Convert an enum value to a single string
1908 sub estimate_t_to_string {
1909     my ($enumval) = @_;
1910
1911     for my $k (keys %_estimate_t_VALUES) {
1912         my $v = $_estimate_t_VALUES{$k};
1913
1914         #is this a matching flag?
1915         if ($enumval == $v) {
1916             return $k;
1917         }
1918     }
1919
1920 #default, just return the number
1921     return $enumval;
1922 }
1923
1924 push @EXPORT_OK, qw($ES_CLIENT);
1925 push @{$EXPORT_TAGS{"estimate_t"}}, qw($ES_CLIENT);
1926
1927 $_estimate_t_VALUES{"ES_CLIENT"} = $ES_CLIENT;
1928
1929 push @EXPORT_OK, qw($ES_SERVER);
1930 push @{$EXPORT_TAGS{"estimate_t"}}, qw($ES_SERVER);
1931
1932 $_estimate_t_VALUES{"ES_SERVER"} = $ES_SERVER;
1933
1934 push @EXPORT_OK, qw($ES_CALCSIZE);
1935 push @{$EXPORT_TAGS{"estimate_t"}}, qw($ES_CALCSIZE);
1936
1937 $_estimate_t_VALUES{"ES_CALCSIZE"} = $ES_CALCSIZE;
1938
1939 #copy symbols in estimate_t to getconf
1940 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"estimate_t"}};
1941
1942 push @EXPORT_OK, qw(autolabel_enum_t_to_string);
1943 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw(autolabel_enum_t_to_string);
1944
1945 my %_autolabel_enum_t_VALUES;
1946 #Convert an enum value to a single string
1947 sub autolabel_enum_t_to_string {
1948     my ($enumval) = @_;
1949
1950     for my $k (keys %_autolabel_enum_t_VALUES) {
1951         my $v = $_autolabel_enum_t_VALUES{$k};
1952
1953         #is this a matching flag?
1954         if ($enumval == $v) {
1955             return $k;
1956         }
1957     }
1958
1959 #default, just return the number
1960     return $enumval;
1961 }
1962
1963 push @EXPORT_OK, qw($AL_OTHER_CONFIG);
1964 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_OTHER_CONFIG);
1965
1966 $_autolabel_enum_t_VALUES{"AL_OTHER_CONFIG"} = $AL_OTHER_CONFIG;
1967
1968 push @EXPORT_OK, qw($AL_NON_AMANDA);
1969 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_NON_AMANDA);
1970
1971 $_autolabel_enum_t_VALUES{"AL_NON_AMANDA"} = $AL_NON_AMANDA;
1972
1973 push @EXPORT_OK, qw($AL_VOLUME_ERROR);
1974 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_VOLUME_ERROR);
1975
1976 $_autolabel_enum_t_VALUES{"AL_VOLUME_ERROR"} = $AL_VOLUME_ERROR;
1977
1978 push @EXPORT_OK, qw($AL_EMPTY);
1979 push @{$EXPORT_TAGS{"autolabel_enum_t"}}, qw($AL_EMPTY);
1980
1981 $_autolabel_enum_t_VALUES{"AL_EMPTY"} = $AL_EMPTY;
1982
1983 #copy symbols in autolabel_enum_t to getconf
1984 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"autolabel_enum_t"}};
1985
1986 push @EXPORT_OK, qw(taperalgo_t_to_string);
1987 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw(taperalgo_t_to_string);
1988
1989 my %_taperalgo_t_VALUES;
1990 #Convert an enum value to a single string
1991 sub taperalgo_t_to_string {
1992     my ($enumval) = @_;
1993
1994     for my $k (keys %_taperalgo_t_VALUES) {
1995         my $v = $_taperalgo_t_VALUES{$k};
1996
1997         #is this a matching flag?
1998         if ($enumval == $v) {
1999             return $k;
2000         }
2001     }
2002
2003 #default, just return the number
2004     return $enumval;
2005 }
2006
2007 push @EXPORT_OK, qw($ALGO_FIRST);
2008 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_FIRST);
2009
2010 $_taperalgo_t_VALUES{"ALGO_FIRST"} = $ALGO_FIRST;
2011
2012 push @EXPORT_OK, qw($ALGO_FIRSTFIT);
2013 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_FIRSTFIT);
2014
2015 $_taperalgo_t_VALUES{"ALGO_FIRSTFIT"} = $ALGO_FIRSTFIT;
2016
2017 push @EXPORT_OK, qw($ALGO_LARGEST);
2018 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_LARGEST);
2019
2020 $_taperalgo_t_VALUES{"ALGO_LARGEST"} = $ALGO_LARGEST;
2021
2022 push @EXPORT_OK, qw($ALGO_LARGESTFIT);
2023 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_LARGESTFIT);
2024
2025 $_taperalgo_t_VALUES{"ALGO_LARGESTFIT"} = $ALGO_LARGESTFIT;
2026
2027 push @EXPORT_OK, qw($ALGO_SMALLEST);
2028 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_SMALLEST);
2029
2030 $_taperalgo_t_VALUES{"ALGO_SMALLEST"} = $ALGO_SMALLEST;
2031
2032 push @EXPORT_OK, qw($ALGO_LAST);
2033 push @{$EXPORT_TAGS{"taperalgo_t"}}, qw($ALGO_LAST);
2034
2035 $_taperalgo_t_VALUES{"ALGO_LAST"} = $ALGO_LAST;
2036
2037 #copy symbols in taperalgo_t to getconf
2038 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"taperalgo_t"}};
2039
2040 push @EXPORT_OK, qw(execute_on_t_to_string);
2041 push @{$EXPORT_TAGS{"execute_on_t"}}, qw(execute_on_t_to_string);
2042
2043 my %_execute_on_t_VALUES;
2044 #Convert an enum value to a single string
2045 sub execute_on_t_to_string {
2046     my ($enumval) = @_;
2047
2048     for my $k (keys %_execute_on_t_VALUES) {
2049         my $v = $_execute_on_t_VALUES{$k};
2050
2051         #is this a matching flag?
2052         if ($enumval == $v) {
2053             return $k;
2054         }
2055     }
2056
2057 #default, just return the number
2058     return $enumval;
2059 }
2060
2061 push @EXPORT_OK, qw($EXECUTE_ON_PRE_DLE_AMCHECK);
2062 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_DLE_AMCHECK);
2063
2064 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_DLE_AMCHECK"} = $EXECUTE_ON_PRE_DLE_AMCHECK;
2065
2066 push @EXPORT_OK, qw($EXECUTE_ON_PRE_HOST_AMCHECK);
2067 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_HOST_AMCHECK);
2068
2069 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_HOST_AMCHECK"} = $EXECUTE_ON_PRE_HOST_AMCHECK;
2070
2071 push @EXPORT_OK, qw($EXECUTE_ON_POST_DLE_AMCHECK);
2072 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_DLE_AMCHECK);
2073
2074 $_execute_on_t_VALUES{"EXECUTE_ON_POST_DLE_AMCHECK"} = $EXECUTE_ON_POST_DLE_AMCHECK;
2075
2076 push @EXPORT_OK, qw($EXECUTE_ON_POST_HOST_AMCHECK);
2077 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_HOST_AMCHECK);
2078
2079 $_execute_on_t_VALUES{"EXECUTE_ON_POST_HOST_AMCHECK"} = $EXECUTE_ON_POST_HOST_AMCHECK;
2080
2081 push @EXPORT_OK, qw($EXECUTE_ON_PRE_DLE_ESTIMATE);
2082 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_DLE_ESTIMATE);
2083
2084 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_DLE_ESTIMATE"} = $EXECUTE_ON_PRE_DLE_ESTIMATE;
2085
2086 push @EXPORT_OK, qw($EXECUTE_ON_PRE_HOST_ESTIMATE);
2087 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_HOST_ESTIMATE);
2088
2089 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_HOST_ESTIMATE"} = $EXECUTE_ON_PRE_HOST_ESTIMATE;
2090
2091 push @EXPORT_OK, qw($EXECUTE_ON_POST_DLE_ESTIMATE);
2092 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_DLE_ESTIMATE);
2093
2094 $_execute_on_t_VALUES{"EXECUTE_ON_POST_DLE_ESTIMATE"} = $EXECUTE_ON_POST_DLE_ESTIMATE;
2095
2096 push @EXPORT_OK, qw($EXECUTE_ON_POST_HOST_ESTIMATE);
2097 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_HOST_ESTIMATE);
2098
2099 $_execute_on_t_VALUES{"EXECUTE_ON_POST_HOST_ESTIMATE"} = $EXECUTE_ON_POST_HOST_ESTIMATE;
2100
2101 push @EXPORT_OK, qw($EXECUTE_ON_PRE_DLE_BACKUP);
2102 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_DLE_BACKUP);
2103
2104 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_DLE_BACKUP"} = $EXECUTE_ON_PRE_DLE_BACKUP;
2105
2106 push @EXPORT_OK, qw($EXECUTE_ON_PRE_HOST_BACKUP);
2107 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_PRE_HOST_BACKUP);
2108
2109 $_execute_on_t_VALUES{"EXECUTE_ON_PRE_HOST_BACKUP"} = $EXECUTE_ON_PRE_HOST_BACKUP;
2110
2111 push @EXPORT_OK, qw($EXECUTE_ON_POST_DLE_BACKUP);
2112 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_DLE_BACKUP);
2113
2114 $_execute_on_t_VALUES{"EXECUTE_ON_POST_DLE_BACKUP"} = $EXECUTE_ON_POST_DLE_BACKUP;
2115
2116 push @EXPORT_OK, qw($EXECUTE_ON_POST_HOST_BACKUP);
2117 push @{$EXPORT_TAGS{"execute_on_t"}}, qw($EXECUTE_ON_POST_HOST_BACKUP);
2118
2119 $_execute_on_t_VALUES{"EXECUTE_ON_POST_HOST_BACKUP"} = $EXECUTE_ON_POST_HOST_BACKUP;
2120
2121 #copy symbols in execute_on_t to getconf
2122 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"execute_on_t"}};
2123
2124 push @EXPORT_OK, qw(send_amreport_on_t_to_string);
2125 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw(send_amreport_on_t_to_string);
2126
2127 my %_send_amreport_on_t_VALUES;
2128 #Convert an enum value to a single string
2129 sub send_amreport_on_t_to_string {
2130     my ($enumval) = @_;
2131
2132     for my $k (keys %_send_amreport_on_t_VALUES) {
2133         my $v = $_send_amreport_on_t_VALUES{$k};
2134
2135         #is this a matching flag?
2136         if ($enumval == $v) {
2137             return $k;
2138         }
2139     }
2140
2141 #default, just return the number
2142     return $enumval;
2143 }
2144
2145 push @EXPORT_OK, qw($SEND_AMREPORT_ALL);
2146 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_ALL);
2147
2148 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_ALL"} = $SEND_AMREPORT_ALL;
2149
2150 push @EXPORT_OK, qw($SEND_AMREPORT_STRANGE);
2151 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_STRANGE);
2152
2153 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_STRANGE"} = $SEND_AMREPORT_STRANGE;
2154
2155 push @EXPORT_OK, qw($SEND_AMREPORT_ERROR);
2156 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_ERROR);
2157
2158 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_ERROR"} = $SEND_AMREPORT_ERROR;
2159
2160 push @EXPORT_OK, qw($SEND_AMREPORT_NEVER);
2161 push @{$EXPORT_TAGS{"send_amreport_on_t"}}, qw($SEND_AMREPORT_NEVER);
2162
2163 $_send_amreport_on_t_VALUES{"SEND_AMREPORT_NEVER"} = $SEND_AMREPORT_NEVER;
2164
2165 #copy symbols in send_amreport_on_t to getconf
2166 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"send_amreport_on_t"}};
2167
2168 push @EXPORT_OK, qw(data_path_t_to_string);
2169 push @{$EXPORT_TAGS{"data_path_t"}}, qw(data_path_t_to_string);
2170
2171 my %_data_path_t_VALUES;
2172 #Convert an enum value to a single string
2173 sub data_path_t_to_string {
2174     my ($enumval) = @_;
2175
2176     for my $k (keys %_data_path_t_VALUES) {
2177         my $v = $_data_path_t_VALUES{$k};
2178
2179         #is this a matching flag?
2180         if ($enumval == $v) {
2181             return $k;
2182         }
2183     }
2184
2185 #default, just return the number
2186     return $enumval;
2187 }
2188
2189 push @EXPORT_OK, qw($DATA_PATH_AMANDA);
2190 push @{$EXPORT_TAGS{"data_path_t"}}, qw($DATA_PATH_AMANDA);
2191
2192 $_data_path_t_VALUES{"DATA_PATH_AMANDA"} = $DATA_PATH_AMANDA;
2193
2194 push @EXPORT_OK, qw($DATA_PATH_DIRECTTCP);
2195 push @{$EXPORT_TAGS{"data_path_t"}}, qw($DATA_PATH_DIRECTTCP);
2196
2197 $_data_path_t_VALUES{"DATA_PATH_DIRECTTCP"} = $DATA_PATH_DIRECTTCP;
2198
2199 #copy symbols in data_path_t to getconf
2200 push @{$EXPORT_TAGS{"getconf"}},  @{$EXPORT_TAGS{"data_path_t"}};
2201
2202 push @EXPORT_OK, qw(getconf getconf_seen getconf_linenum
2203     getconf_byname getconf_byname_strs
2204     getconf_list);
2205 push @{$EXPORT_TAGS{"getconf"}}, qw(getconf getconf_seen getconf_linenum
2206     getconf_byname getconf_byname_strs
2207     getconf_list);
2208
2209 push @EXPORT_OK, qw(lookup_tapetype tapetype_getconf tapetype_name
2210     tapetype_seen tapetype_seen);
2211 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_tapetype tapetype_getconf tapetype_name
2212     tapetype_seen tapetype_seen);
2213
2214 push @EXPORT_OK, qw(lookup_dumptype dumptype_getconf dumptype_name
2215     dumptype_seen dumptype_seen);
2216 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_dumptype dumptype_getconf dumptype_name
2217     dumptype_seen dumptype_seen);
2218
2219 push @EXPORT_OK, qw(lookup_interface interface_getconf interface_name
2220     interface_seen interface_seen);
2221 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_interface interface_getconf interface_name
2222     interface_seen interface_seen);
2223
2224 push @EXPORT_OK, qw(lookup_holdingdisk holdingdisk_getconf holdingdisk_name
2225     getconf_holdingdisks
2226     holdingdisk_seen holdingdisk_seen);
2227 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_holdingdisk holdingdisk_getconf holdingdisk_name
2228     getconf_holdingdisks
2229     holdingdisk_seen holdingdisk_seen);
2230
2231 push @EXPORT_OK, qw(lookup_application application_getconf application_name
2232     application_seen application_seen);
2233 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_application application_getconf application_name
2234     application_seen application_seen);
2235
2236 push @EXPORT_OK, qw(lookup_pp_script pp_script_getconf pp_script_name
2237     pp_script_seen pp_script_seen);
2238 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_pp_script pp_script_getconf pp_script_name
2239     pp_script_seen pp_script_seen);
2240
2241 push @EXPORT_OK, qw(lookup_device_config device_config_getconf device_config_name
2242     device_config_seen device_config_seen);
2243 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_device_config device_config_getconf device_config_name
2244     device_config_seen device_config_seen);
2245
2246 push @EXPORT_OK, qw(lookup_changer_config changer_config_getconf changer_config_name
2247     changer_config_seen changer_config_seen);
2248 push @{$EXPORT_TAGS{"getconf"}}, qw(lookup_changer_config changer_config_getconf changer_config_name
2249     changer_config_seen changer_config_seen);
2250
2251 # only those keys with a value of '1' should be shown; the
2252 # others are deprecated
2253 our %subsection_names = (
2254     "tapetype" => 1,
2255     "dumptype" => 1,
2256     "interface" => 1,
2257     "holdingdisk" => 1,
2258     "application" => 1,
2259     "script" => 1,
2260     "application-tool" => 0,
2261     "script-tool" => 0,
2262     "device" => 1,
2263     "changer" => 1,
2264 );
2265
2266 push @EXPORT_OK, qw(%subsection_names);
2267 push @{$EXPORT_TAGS{"getconf"}}, qw(%subsection_names);
2268
2269 push @EXPORT_OK, qw(getconf_unit_divisor
2270
2271     $debug_amandad $debug_recovery $debug_amidxtaped $debug_amindexd $debug_amrecover
2272     $debug_auth $debug_event $debug_holding $debug_protocol
2273     $debug_planner $debug_driver $debug_dumper $debug_chunker
2274     $debug_taper $debug_selfcheck $debug_sendsize $debug_sendbackup);
2275 push @{$EXPORT_TAGS{"getconf"}}, qw(getconf_unit_divisor
2276
2277     $debug_amandad $debug_recovery $debug_amidxtaped $debug_amindexd $debug_amrecover
2278     $debug_auth $debug_event $debug_holding $debug_protocol
2279     $debug_planner $debug_driver $debug_dumper $debug_chunker
2280     $debug_taper $debug_selfcheck $debug_sendsize $debug_sendbackup);
2281
2282 push @EXPORT_OK, qw(cfgerr_level_t_to_string);
2283 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw(cfgerr_level_t_to_string);
2284
2285 my %_cfgerr_level_t_VALUES;
2286 #Convert an enum value to a single string
2287 sub cfgerr_level_t_to_string {
2288     my ($enumval) = @_;
2289
2290     for my $k (keys %_cfgerr_level_t_VALUES) {
2291         my $v = $_cfgerr_level_t_VALUES{$k};
2292
2293         #is this a matching flag?
2294         if ($enumval == $v) {
2295             return $k;
2296         }
2297     }
2298
2299 #default, just return the number
2300     return $enumval;
2301 }
2302
2303 push @EXPORT_OK, qw($CFGERR_OK);
2304 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw($CFGERR_OK);
2305
2306 $_cfgerr_level_t_VALUES{"CFGERR_OK"} = $CFGERR_OK;
2307
2308 push @EXPORT_OK, qw($CFGERR_WARNINGS);
2309 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw($CFGERR_WARNINGS);
2310
2311 $_cfgerr_level_t_VALUES{"CFGERR_WARNINGS"} = $CFGERR_WARNINGS;
2312
2313 push @EXPORT_OK, qw($CFGERR_ERRORS);
2314 push @{$EXPORT_TAGS{"cfgerr_level_t"}}, qw($CFGERR_ERRORS);
2315
2316 $_cfgerr_level_t_VALUES{"CFGERR_ERRORS"} = $CFGERR_ERRORS;
2317
2318 #copy symbols in cfgerr_level_t to init
2319 push @{$EXPORT_TAGS{"init"}},  @{$EXPORT_TAGS{"cfgerr_level_t"}};
2320
2321 push @EXPORT_OK, qw(config_init_flags_to_strings);
2322 push @{$EXPORT_TAGS{"config_init_flags"}}, qw(config_init_flags_to_strings);
2323
2324 my %_config_init_flags_VALUES;
2325 #Convert a flag value to a list of names for flags that are set.
2326 sub config_init_flags_to_strings {
2327     my ($flags) = @_;
2328     my @result = ();
2329
2330     for my $k (keys %_config_init_flags_VALUES) {
2331         my $v = $_config_init_flags_VALUES{$k};
2332
2333         #is this a matching flag?
2334         if (($v == 0 && $flags == 0) || ($v != 0 && ($flags & $v) == $v)) {
2335             push @result, $k;
2336         }
2337     }
2338
2339 #by default, just return the number as a 1-element list
2340     if (!@result) {
2341         return ($flags);
2342     }
2343
2344     return @result;
2345 }
2346
2347 push @EXPORT_OK, qw($CONFIG_INIT_EXPLICIT_NAME);
2348 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_EXPLICIT_NAME);
2349
2350 $_config_init_flags_VALUES{"CONFIG_INIT_EXPLICIT_NAME"} = $CONFIG_INIT_EXPLICIT_NAME;
2351
2352 push @EXPORT_OK, qw($CONFIG_INIT_USE_CWD);
2353 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_USE_CWD);
2354
2355 $_config_init_flags_VALUES{"CONFIG_INIT_USE_CWD"} = $CONFIG_INIT_USE_CWD;
2356
2357 push @EXPORT_OK, qw($CONFIG_INIT_CLIENT);
2358 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_CLIENT);
2359
2360 $_config_init_flags_VALUES{"CONFIG_INIT_CLIENT"} = $CONFIG_INIT_CLIENT;
2361
2362 push @EXPORT_OK, qw($CONFIG_INIT_OVERLAY);
2363 push @{$EXPORT_TAGS{"config_init_flags"}}, qw($CONFIG_INIT_OVERLAY);
2364
2365 $_config_init_flags_VALUES{"CONFIG_INIT_OVERLAY"} = $CONFIG_INIT_OVERLAY;
2366
2367 #copy symbols in config_init_flags to init
2368 push @{$EXPORT_TAGS{"init"}},  @{$EXPORT_TAGS{"config_init_flags"}};
2369
2370 push @EXPORT_OK, qw(config_init config_uninit get_config_options
2371     get_config_name get_config_dir get_config_filename
2372     config_print_errors config_clear_errors config_errors
2373     new_config_overrides free_config_overrides add_config_override
2374     add_config_override_opt set_config_overrides);
2375 push @{$EXPORT_TAGS{"init"}}, qw(config_init config_uninit get_config_options
2376     get_config_name get_config_dir get_config_filename
2377     config_print_errors config_clear_errors config_errors
2378     new_config_overrides free_config_overrides add_config_override
2379     add_config_override_opt set_config_overrides);
2380
2381 push @EXPORT_OK, qw(dump_configuration config_dir_relative taperalgo2str find_multiplier);
2382
2383
2384 sub string_to_boolean {
2385     my ($str) = @_;
2386     my $ret = C_string_to_boolean($str);
2387     return undef unless $ret >= 0;
2388     return $ret;
2389 }
2390
2391
2392 push @EXPORT_OK, qw(string_to_boolean);
2393 1;