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