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

   1 /*
   2  * Copyright (c) 2007, 2008, 2009, 2010 Zmanda, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 as published
   6  * by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16  *
  17  * Contact information: Zmanda Inc., 465 S. Mathilda Ave., Suite 300
  18  * Sunnyvale, CA 94085, USA, or: http://www.zmanda.com
  19  */
  20
  21 %module "Amanda::Config"
  22 %include "amglue/amglue.swg"
  23 %include "exception.i"
  24
  25 %include "Amanda/Config.pod"
  26
  27 %{
  28 #include "conffile.h"
  29 %}
  30
  31 /*
  32  * Documentation Macro
  33  */
  34
  35 %define constant_pod(DESCRIPTION, FORALL_FN)
  36 %perlcode %{
  37
  38 use Amanda::Config::FoldingHash;
  39
  40 =pod
  41
  42 DESCRIPTION: amglue_constants_list(FORALL_FN)
  43
  44 =cut
  45 %}
  46 %enddef
  47
  48 /*
  49  * Parameter access
  50 */
  51
  52 /* All of the CNF_ flags from conffile.h */
  53
  54 #define FOR_ALL_CONFPARM_KEY(APPLY)\
  55 APPLY(CNF_ORG)\
  56 APPLY(CNF_CONF)\
  57 APPLY(CNF_AMDUMP_SERVER)\
  58 APPLY(CNF_INDEX_SERVER)\
  59 APPLY(CNF_TAPE_SERVER)\
  60 APPLY(CNF_AUTH)\
  61 APPLY(CNF_SSH_KEYS)\
  62 APPLY(CNF_AMANDAD_PATH)\
  63 APPLY(CNF_CLIENT_USERNAME)\
  64 APPLY(CNF_CLIENT_PORT)\
  65 APPLY(CNF_GNUTAR_LIST_DIR)\
  66 APPLY(CNF_AMANDATES)\
  67 APPLY(CNF_MAILER)\
  68 APPLY(CNF_MAILTO)\
  69 APPLY(CNF_DUMPUSER)\
  70 APPLY(CNF_TAPEDEV)\
  71 APPLY(CNF_DEVICE_PROPERTY)\
  72 APPLY(CNF_PROPERTY)\
  73 APPLY(CNF_CHANGERDEV)\
  74 APPLY(CNF_CHANGERFILE)\
  75 APPLY(CNF_LABELSTR)\
  76 APPLY(CNF_AUTOLABEL)\
  77 APPLY(CNF_META_AUTOLABEL)\
  78 APPLY(CNF_TAPELIST)\
  79 APPLY(CNF_DISKFILE)\
  80 APPLY(CNF_INFOFILE)\
  81 APPLY(CNF_LOGDIR)\
  82 APPLY(CNF_INDEXDIR)\
  83 APPLY(CNF_TAPETYPE)\
  84 APPLY(CNF_DUMPCYCLE)\
  85 APPLY(CNF_RUNSPERCYCLE)\
  86 APPLY(CNF_TAPECYCLE)\
  87 APPLY(CNF_NETUSAGE)\
  88 APPLY(CNF_INPARALLEL)\
  89 APPLY(CNF_DUMPORDER)\
  90 APPLY(CNF_BUMPPERCENT)\
  91 APPLY(CNF_BUMPSIZE)\
  92 APPLY(CNF_BUMPMULT)\
  93 APPLY(CNF_BUMPDAYS)\
  94 APPLY(CNF_TPCHANGER)\
  95 APPLY(CNF_RUNTAPES)\
  96 APPLY(CNF_MAXDUMPS)\
  97 APPLY(CNF_ETIMEOUT)\
  98 APPLY(CNF_DTIMEOUT)\
  99 APPLY(CNF_CTIMEOUT)\
 100 APPLY(CNF_DEVICE_OUTPUT_BUFFER_SIZE)\
 101 APPLY(CNF_PRINTER)\
 102 APPLY(CNF_AUTOFLUSH)\
 103 APPLY(CNF_RESERVE)\
 104 APPLY(CNF_MAXDUMPSIZE)\
 105 APPLY(CNF_COLUMNSPEC)\
 106 APPLY(CNF_AMRECOVER_DO_FSF)\
 107 APPLY(CNF_AMRECOVER_CHECK_LABEL)\
 108 APPLY(CNF_AMRECOVER_CHANGER)\
 109 APPLY(CNF_TAPERALGO)\
 110 APPLY(CNF_FLUSH_THRESHOLD_DUMPED)\
 111 APPLY(CNF_FLUSH_THRESHOLD_SCHEDULED)\
 112 APPLY(CNF_TAPERFLUSH)\
 113 APPLY(CNF_DISPLAYUNIT)\
 114 APPLY(CNF_KRB5KEYTAB)\
 115 APPLY(CNF_KRB5PRINCIPAL)\
 116 APPLY(CNF_LABEL_NEW_TAPES)\
 117 APPLY(CNF_USETIMESTAMPS)\
 118 APPLY(CNF_REP_TRIES)\
 119 APPLY(CNF_CONNECT_TRIES)\
 120 APPLY(CNF_REQ_TRIES)\
 121 APPLY(CNF_DEBUG_AMANDAD)\
 122 APPLY(CNF_DEBUG_RECOVERY)\
 123 APPLY(CNF_DEBUG_AMIDXTAPED)\
 124 APPLY(CNF_DEBUG_AMINDEXD)\
 125 APPLY(CNF_DEBUG_AMRECOVER)\
 126 APPLY(CNF_DEBUG_AUTH)\
 127 APPLY(CNF_DEBUG_EVENT)\
 128 APPLY(CNF_DEBUG_HOLDING)\
 129 APPLY(CNF_DEBUG_PROTOCOL)\
 130 APPLY(CNF_DEBUG_PLANNER)\
 131 APPLY(CNF_DEBUG_DRIVER)\
 132 APPLY(CNF_DEBUG_DUMPER)\
 133 APPLY(CNF_DEBUG_CHUNKER)\
 134 APPLY(CNF_DEBUG_TAPER)\
 135 APPLY(CNF_DEBUG_SELFCHECK)\
 136 APPLY(CNF_DEBUG_SENDSIZE)\
 137 APPLY(CNF_DEBUG_SENDBACKUP)\
 138 APPLY(CNF_RESERVED_UDP_PORT)\
 139 APPLY(CNF_RESERVED_TCP_PORT)\
 140 APPLY(CNF_UNRESERVED_TCP_PORT)\
 141 APPLY(CNF_HOLDINGDISK)\
 142 APPLY(CNF_SEND_AMREPORT_ON)\
 143 APPLY(CNF_TAPER_PARALLEL_WRITE)\
 144 APPLY(CNF_RECOVERY_LIMIT) \
 145 APPLY(CNF_INTERACTIVITY) \
 146 APPLY(CNF_TAPERSCAN)
 147
 148 amglue_add_enum_tag_fns(confparm_key);
 149 amglue_add_constants(FOR_ALL_CONFPARM_KEY, confparm_key);
 150 amglue_copy_to_tag(confparm_key, getconf);
 151 constant_pod(Global Parameters, FOR_ALL_CONFPARM_KEY)
 152
 153 #define FOR_ALL_TAPETYPE_KEY(APPLY)\
 154 APPLY(TAPETYPE_COMMENT)\
 155 APPLY(TAPETYPE_LBL_TEMPL)\
 156 APPLY(TAPETYPE_BLOCKSIZE)\
 157 APPLY(TAPETYPE_READBLOCKSIZE)\
 158 APPLY(TAPETYPE_LENGTH)\
 159 APPLY(TAPETYPE_FILEMARK)\
 160 APPLY(TAPETYPE_SPEED)\
 161 APPLY(TAPETYPE_PART_SIZE)\
 162 APPLY(TAPETYPE_PART_CACHE_TYPE)\
 163 APPLY(TAPETYPE_PART_CACHE_DIR)\
 164 APPLY(TAPETYPE_PART_CACHE_MAX_SIZE)
 165
 166 amglue_add_enum_tag_fns(tapetype_key);
 167 amglue_add_constants(FOR_ALL_TAPETYPE_KEY, tapetype_key);
 168 amglue_copy_to_tag(tapetype_key, getconf);
 169 constant_pod(Tapetype Parameters, FOR_ALL_TAPETYPE_KEY)
 170
 171 #define FOR_ALL_DUMPTYPE_KEY(APPLY)\
 172 APPLY(DUMPTYPE_COMMENT)\
 173 APPLY(DUMPTYPE_PROGRAM)\
 174 APPLY(DUMPTYPE_SRVCOMPPROG)\
 175 APPLY(DUMPTYPE_CLNTCOMPPROG)\
 176 APPLY(DUMPTYPE_SRV_ENCRYPT)\
 177 APPLY(DUMPTYPE_CLNT_ENCRYPT)\
 178 APPLY(DUMPTYPE_AMANDAD_PATH)\
 179 APPLY(DUMPTYPE_CLIENT_USERNAME)\
 180 APPLY(DUMPTYPE_CLIENT_PORT)\
 181 APPLY(DUMPTYPE_SSH_KEYS)\
 182 APPLY(DUMPTYPE_AUTH)\
 183 APPLY(DUMPTYPE_EXCLUDE)\
 184 APPLY(DUMPTYPE_INCLUDE)\
 185 APPLY(DUMPTYPE_PRIORITY)\
 186 APPLY(DUMPTYPE_DUMPCYCLE)\
 187 APPLY(DUMPTYPE_MAXDUMPS)\
 188 APPLY(DUMPTYPE_MAXPROMOTEDAY)\
 189 APPLY(DUMPTYPE_BUMPPERCENT)\
 190 APPLY(DUMPTYPE_BUMPSIZE)\
 191 APPLY(DUMPTYPE_BUMPDAYS)\
 192 APPLY(DUMPTYPE_BUMPMULT)\
 193 APPLY(DUMPTYPE_STARTTIME)\
 194 APPLY(DUMPTYPE_STRATEGY)\
 195 APPLY(DUMPTYPE_ESTIMATELIST)\
 196 APPLY(DUMPTYPE_COMPRESS)\
 197 APPLY(DUMPTYPE_ENCRYPT)\
 198 APPLY(DUMPTYPE_SRV_DECRYPT_OPT)\
 199 APPLY(DUMPTYPE_CLNT_DECRYPT_OPT)\
 200 APPLY(DUMPTYPE_COMPRATE)\
 201 APPLY(DUMPTYPE_TAPE_SPLITSIZE)\
 202 APPLY(DUMPTYPE_FALLBACK_SPLITSIZE)\
 203 APPLY(DUMPTYPE_SPLIT_DISKBUFFER)\
 204 APPLY(DUMPTYPE_RECORD)\
 205 APPLY(DUMPTYPE_SKIP_INCR)\
 206 APPLY(DUMPTYPE_SKIP_FULL)\
 207 APPLY(DUMPTYPE_HOLDINGDISK)\
 208 APPLY(DUMPTYPE_KENCRYPT)\
 209 APPLY(DUMPTYPE_IGNORE)\
 210 APPLY(DUMPTYPE_INDEX)\
 211 APPLY(DUMPTYPE_APPLICATION)\
 212 APPLY(DUMPTYPE_SCRIPTLIST)\
 213 APPLY(DUMPTYPE_PROPERTY)\
 214 APPLY(DUMPTYPE_DATA_PATH)\
 215 APPLY(DUMPTYPE_ALLOW_SPLIT)\
 216 APPLY(DUMPTYPE_RECOVERY_LIMIT) \
 217 APPLY(DUMPTYPE_DUMP_LIMIT)
 218
 219 amglue_add_enum_tag_fns(dumptype_key);
 220 amglue_add_constants(FOR_ALL_DUMPTYPE_KEY, dumptype_key);
 221 amglue_copy_to_tag(dumptype_key, getconf);
 222 constant_pod(Dumptype Parameters, FOR_ALL_DUMPTYPE_KEY)
 223
 224 #define FOR_ALL_INTERFACE_KEY(APPLY)\
 225 APPLY(INTER_COMMENT)\
 226 APPLY(INTER_MAXUSAGE)
 227
 228 amglue_add_enum_tag_fns(interface_key);
 229 amglue_add_constants(FOR_ALL_INTERFACE_KEY, interface_key);
 230 amglue_copy_to_tag(interface_key, getconf);
 231 constant_pod(Dumptype Parameters, FOR_ALL_INTERFACE_KEY)
 232
 233 #define FOR_ALL_HOLDINGDISK_KEY(APPLY)\
 234 APPLY(HOLDING_COMMENT)\
 235 APPLY(HOLDING_DISKDIR)\
 236 APPLY(HOLDING_DISKSIZE)\
 237 APPLY(HOLDING_CHUNKSIZE)
 238
 239 amglue_add_enum_tag_fns(holdingdisk_key);
 240 amglue_add_constants(FOR_ALL_HOLDINGDISK_KEY, holdingdisk_key);
 241 amglue_copy_to_tag(holdingdisk_key, getconf);
 242 constant_pod(Holdingdisk Parameters, FOR_ALL_HOLDINGDISK_KEY)
 243
 244 #define FOR_ALL_APPLICATION_KEY(APPLY)\
 245 APPLY(APPLICATION_COMMENT)\
 246 APPLY(APPLICATION_PLUGIN)\
 247 APPLY(APPLICATION_PROPERTY) \
 248 APPLY(APPLICATION_CLIENT_NAME)
 249
 250 amglue_add_enum_tag_fns(application_key);
 251 amglue_add_constants(FOR_ALL_APPLICATION_KEY, application_key);
 252 amglue_copy_to_tag(application_key, getconf);
 253 constant_pod(Application Parameters, FOR_ALL_APPLICATION_KEY)
 254
 255 #define FOR_ALL_PP_SCRIPT_KEY(APPLY)\
 256 APPLY(PP_SCRIPT_COMMENT)\
 257 APPLY(PP_SCRIPT_PLUGIN)\
 258 APPLY(PP_SCRIPT_PROPERTY)\
 259 APPLY(PP_SCRIPT_EXECUTE_ON)\
 260 APPLY(PP_SCRIPT_EXECUTE_WHERE)\
 261 APPLY(PP_SCRIPT_ORDER)\
 262 APPLY(PP_SCRIPT_SINGLE_EXECUTION)\
 263 APPLY(PP_SCRIPT_CLIENT_NAME)
 264
 265 amglue_add_enum_tag_fns(pp_script_key);
 266 amglue_add_constants(FOR_ALL_PP_SCRIPT_KEY, pp_script_key);
 267 amglue_copy_to_tag(pp_script_key, getconf);
 268 constant_pod(Pre/Post-Script Parameters, FOR_ALL_PP_SCRIPT_KEY)
 269
 270 #define FOR_ALL_DEVICE_CONFIG_KEY(APPLY)\
 271 APPLY(DEVICE_CONFIG_COMMENT)\
 272 APPLY(DEVICE_CONFIG_TAPEDEV)\
 273 APPLY(DEVICE_CONFIG_DEVICE_PROPERTY)
 274
 275 amglue_add_enum_tag_fns(device_config_key);
 276 amglue_add_constants(FOR_ALL_DEVICE_CONFIG_KEY, device_config_key);
 277 amglue_copy_to_tag(device_config_key, getconf);
 278 constant_pod(Pre/Post-Script Parameters, FOR_ALL_DEVICE_CONFIG_KEY)
 279
 280 #define FOR_ALL_CHANGER_CONFIG_KEY(APPLY)\
 281 APPLY(CHANGER_CONFIG_COMMENT)\
 282 APPLY(CHANGER_CONFIG_TAPEDEV)\
 283 APPLY(CHANGER_CONFIG_TPCHANGER)\
 284 APPLY(CHANGER_CONFIG_CHANGERDEV)\
 285 APPLY(CHANGER_CONFIG_CHANGERFILE)\
 286 APPLY(CHANGER_CONFIG_PROPERTY)\
 287 APPLY(CHANGER_CONFIG_DEVICE_PROPERTY)
 288
 289 amglue_add_enum_tag_fns(changer_config_key);
 290 amglue_add_constants(FOR_ALL_CHANGER_CONFIG_KEY, changer_config_key);
 291 amglue_copy_to_tag(changer_config_key, getconf);
 292 constant_pod(Pre/Post-Script Parameters, FOR_ALL_CHANGER_CONFIG_KEY)
 293
 294 #define FOR_ALL_INTERACTIVITY_KEY(APPLY)\
 295 APPLY(INTERACTIVITY_COMMENT)\
 296 APPLY(INTERACTIVITY_PLUGIN)\
 297 APPLY(INTERACTIVITY_PROPERTY)
 298
 299 amglue_add_enum_tag_fns(interactivity_key);
 300 amglue_add_constants(FOR_ALL_INTERACTIVITY_KEY, interactivity_key);
 301 amglue_copy_to_tag(interactivity_key, getconf);
 302 constant_pod(Interactivity Parameters, FOR_ALL_INTERACTIVITY_KEY)
 303
 304 #define FOR_ALL_TAPERSCAN_KEY(APPLY)\
 305 APPLY(TAPERSCAN_COMMENT)\
 306 APPLY(TAPERSCAN_PLUGIN)\
 307 APPLY(TAPERSCAN_PROPERTY)
 308
 309 amglue_add_enum_tag_fns(taperscan_key);
 310 amglue_add_constants(FOR_ALL_TAPERSCAN_KEY, taperscan_key);
 311 amglue_copy_to_tag(taperscan_key, getconf);
 312 constant_pod(Taperscan Parameters, FOR_ALL_TAPERSCAN_KEY)
 313
 314 /*
 315  * Various enumerated conftypes
 316  */
 317
 318 amglue_add_enum_tag_fns(dump_holdingdisk_t);
 319 amglue_add_constant(HOLD_NEVER, dump_holdingdisk_t);
 320 amglue_add_constant(HOLD_AUTO, dump_holdingdisk_t);
 321 amglue_add_constant(HOLD_REQUIRED, dump_holdingdisk_t);
 322 amglue_copy_to_tag(dump_holdingdisk_t, getconf);
 323
 324 amglue_add_enum_tag_fns(comp_t);
 325 amglue_add_constant(COMP_NONE, comp_t);
 326 amglue_add_constant(COMP_FAST, comp_t);
 327 amglue_add_constant(COMP_BEST, comp_t);
 328 amglue_add_constant(COMP_CUST, comp_t);
 329 amglue_add_constant(COMP_SERVER_FAST, comp_t);
 330 amglue_add_constant(COMP_SERVER_BEST, comp_t);
 331 amglue_add_constant(COMP_SERVER_CUST, comp_t);
 332 amglue_copy_to_tag(comp_t, getconf);
 333
 334 amglue_add_enum_tag_fns(encrypt_t);
 335 amglue_add_constant(ENCRYPT_NONE, encrypt_t);
 336 amglue_add_constant(ENCRYPT_CUST, encrypt_t);
 337 amglue_add_constant(ENCRYPT_SERV_CUST, encrypt_t);
 338 amglue_copy_to_tag(encrypt_t, getconf);
 339
 340 amglue_add_enum_tag_fns(strategy_t);
 341 amglue_add_constant(DS_SKIP, strategy_t);
 342 amglue_add_constant(DS_STANDARD, strategy_t);
 343 amglue_add_constant(DS_NOFULL, strategy_t);
 344 amglue_add_constant(DS_NOINC, strategy_t);
 345 amglue_add_constant(DS_4, strategy_t);
 346 amglue_add_constant(DS_5, strategy_t);
 347 amglue_add_constant(DS_HANOI, strategy_t);
 348 amglue_add_constant(DS_INCRONLY, strategy_t);
 349 amglue_copy_to_tag(strategy_t, getconf);
 350
 351 amglue_add_enum_tag_fns(estimate_t);
 352 amglue_add_constant(ES_CLIENT, estimate_t);
 353 amglue_add_constant(ES_SERVER, estimate_t);
 354 amglue_add_constant(ES_CALCSIZE, estimate_t);
 355 amglue_copy_to_tag(estimate_t, getconf);
 356
 357 amglue_add_enum_tag_fns(autolabel_enum_t);
 358 amglue_add_constant(AL_OTHER_CONFIG, autolabel_enum_t);
 359 amglue_add_constant(AL_NON_AMANDA, autolabel_enum_t);
 360 amglue_add_constant(AL_VOLUME_ERROR, autolabel_enum_t);
 361 amglue_add_constant(AL_EMPTY, autolabel_enum_t);
 362 amglue_copy_to_tag(autolabel_enum_t, getconf);
 363
 364 amglue_add_enum_tag_fns(taperalgo_t);
 365 amglue_add_constant(ALGO_FIRST, taperalgo_t);
 366 amglue_add_constant(ALGO_FIRSTFIT, taperalgo_t);
 367 amglue_add_constant(ALGO_LARGEST, taperalgo_t);
 368 amglue_add_constant(ALGO_LARGESTFIT, taperalgo_t);
 369 amglue_add_constant(ALGO_SMALLEST, taperalgo_t);
 370 amglue_add_constant(ALGO_LAST, taperalgo_t);
 371 amglue_copy_to_tag(taperalgo_t, getconf);
 372
 373 amglue_add_enum_tag_fns(execute_on_t);
 374 amglue_add_constant(EXECUTE_ON_PRE_AMCHECK, execute_on_t);
 375 amglue_add_constant(EXECUTE_ON_PRE_DLE_AMCHECK, execute_on_t);
 376 amglue_add_constant(EXECUTE_ON_PRE_HOST_AMCHECK, execute_on_t);
 377 amglue_add_constant(EXECUTE_ON_POST_AMCHECK, execute_on_t);
 378 amglue_add_constant(EXECUTE_ON_POST_DLE_AMCHECK, execute_on_t);
 379 amglue_add_constant(EXECUTE_ON_POST_HOST_AMCHECK, execute_on_t);
 380 amglue_add_constant(EXECUTE_ON_PRE_ESTIMATE, execute_on_t);
 381 amglue_add_constant(EXECUTE_ON_PRE_DLE_ESTIMATE, execute_on_t);
 382 amglue_add_constant(EXECUTE_ON_PRE_HOST_ESTIMATE, execute_on_t);
 383 amglue_add_constant(EXECUTE_ON_POST_ESTIMATE, execute_on_t);
 384 amglue_add_constant(EXECUTE_ON_POST_DLE_ESTIMATE, execute_on_t);
 385 amglue_add_constant(EXECUTE_ON_POST_HOST_ESTIMATE, execute_on_t);
 386 amglue_add_constant(EXECUTE_ON_PRE_BACKUP, execute_on_t);
 387 amglue_add_constant(EXECUTE_ON_PRE_DLE_BACKUP, execute_on_t);
 388 amglue_add_constant(EXECUTE_ON_PRE_HOST_BACKUP, execute_on_t);
 389 amglue_add_constant(EXECUTE_ON_POST_BACKUP, execute_on_t);
 390 amglue_add_constant(EXECUTE_ON_POST_DLE_BACKUP, execute_on_t);
 391 amglue_add_constant(EXECUTE_ON_POST_HOST_BACKUP, execute_on_t);
 392 amglue_copy_to_tag(execute_on_t, getconf);
 393
 394 amglue_add_enum_tag_fns(send_amreport_on_t);
 395 amglue_add_constant(SEND_AMREPORT_ALL, send_amreport_on_t);
 396 amglue_add_constant(SEND_AMREPORT_STRANGE, send_amreport_on_t);
 397 amglue_add_constant(SEND_AMREPORT_ERROR, send_amreport_on_t);
 398 amglue_add_constant(SEND_AMREPORT_NEVER, send_amreport_on_t);
 399 amglue_copy_to_tag(send_amreport_on_t, getconf);
 400
 401 amglue_add_enum_tag_fns(data_path_t);
 402 amglue_add_constant(DATA_PATH_AMANDA, data_path_t);
 403 amglue_add_constant(DATA_PATH_DIRECTTCP, data_path_t);
 404 amglue_copy_to_tag(data_path_t, getconf);
 405
 406 amglue_add_enum_tag_fns(part_cache_type_t);
 407 amglue_add_constant(PART_CACHE_TYPE_NONE, part_cache_type_t);
 408 amglue_add_constant(PART_CACHE_TYPE_DISK, part_cache_type_t);
 409 amglue_add_constant(PART_CACHE_TYPE_MEMORY, part_cache_type_t);
 410 amglue_copy_to_tag(part_cache_type_t, getconf);
 411
 412 /*
 413  * val_t typemaps
 414  */
 415
 416 /* Typemap to convert a val_t to an SV, using a static function since it's huge.  This converts:
 417  *  - CONFTYPE_SIZE, CONFTYPE_INT, CONFTYPE_INT64, CONFTYPE_NO_YES_ALL,
 418  *    CONFTYPE_BOOLEAN -> IV
 419  *  - CONFTYPE_REAL -> NV
 420  *  - CONFTYPE_STR, CONFTYPE_IDENT -> PV
 421  *  - CONFTYPE_APPLICATION -> PV
 422  *  - CONFTYPE_TIME -> IV (epoch timestamp)
 423  *  - CONFTYPE_COMPRESS, CONFTYPE_ENCRYPT, CONFTYPE_ESTIMATELIST, CONFTYPE_STRATEGY,
 424  *    CONFTYPE_TAPERALGO, CONFTYPE_PRIORITY, CONFTYPE_HOLDING, CONFTYPE_EXECUTE_ON,
 425  *    CONFTYPE_EXECUTE_WHERE, CONFTYPE_SEND_AMREPORT_ON,
 426  *    CONFTYPE_DATA_PATH, CONFTYPE_PART_CACHE_TYPE -> IV (enums)
 427  *  - CONFTYPE_RATE -> list of two NVs
 428  *  - CONFTYPE_INTRANGE -> list of two IVs
 429  *  - CONFTYPE_EXINCLUDE -> hashref with keys 'list' (listref), 'file' (listref),
 430  *    and 'optional' (int)
 431  *  - CONFTYPE_PROPLIST -> hashref of hashref with keys 'append' (IV), 'priority' (IV),
 432  *                                                      'values' (listref)
 433  *  - CONFTYPE_HOST_LIMIT -> listref of match expressions;
 434  *           "SAMEHOST-SAMEHOST-SAMEHOST" in list is taken to mean 'same-host'
 435  *           "SERVER-SERVER-SERVER" in list is taken to mean 'server'
 436  */
 437
 438 %perlcode %{
 439 $LIMIT_SAMEHOST="SAMEHOST-SAMEHOST-SAMEHOST";
 440 $LIMIT_SERVER="SERVER-SERVER-SERVER";
 441 %}
 442
 443 %{
 444 static int
 445 val_t_to_sv(val_t *val, SV **results) {
 446     if (!val) {
 447         results[0] = &PL_sv_undef;
 448         return 1;
 449     } else {
 450         switch (val->type) {
 451             case CONFTYPE_RATE: {
 452                 results[0] = sv_newmortal();
 453                 sv_setnv(results[0], val_t__rate(val)[0]);
 454
 455                 results[1] = sv_newmortal();
 456                 sv_setnv(results[1], val_t__rate(val)[1]);
 457                 return 2;
 458             }
 459
 460             case CONFTYPE_INTRANGE: {
 461                 results[0] = sv_newmortal();
 462                 sv_setiv(results[0], val_t__intrange(val)[0]);
 463
 464                 results[1] = sv_newmortal();
 465                 sv_setiv(results[1], val_t__intrange(val)[1]);
 466                 return 2;
 467             }
 468
 469             case CONFTYPE_EXINCLUDE: {
 470                 /* exincludes are represented in perl as {
 471                  *      'list' : [ 'list1', 'list2', ..],
 472                  *      'file' : [ 'file1', 'file2', ..],
 473                  *      'optional' : 1,
 474                  * }
 475                  */
 476                 exinclude_t *ei = &val_t__exinclude(val);
 477                 AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
 478                 AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
 479                 SV *optional = sv_newmortal();
 480                 HV *hv;
 481                 sle_t *iter;
 482
 483                 /* first set up each of the hash values */
 484
 485                 if (ei->sl_list) {
 486                     for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
 487                         av_push(list_entries, newSVpv(iter->name, 0));
 488                     }
 489                 }
 490
 491                 if(ei->sl_file) {
 492                     for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
 493                         av_push(file_entries, newSVpv(iter->name, 0));
 494                     }
 495                 }
 496
 497                 sv_setiv(optional, ei->optional);
 498
 499                 /* now build the hash */
 500                 hv = (HV *)sv_2mortal((SV *)newHV());
 501
 502                 hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
 503                 hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
 504                 hv_store(hv, "optional", 8, optional, 0);
 505                 SvREFCNT_inc(optional);
 506
 507                 results[0] = sv_2mortal(newRV((SV *)hv));
 508                 return 1;
 509             }
 510
 511             case CONFTYPE_PROPLIST:
 512                 results[0] = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(val)));
 513                 return 1;
 514
 515             case CONFTYPE_SIZE:
 516                 results[0] = sv_2mortal(amglue_newSVi64(val_t__size(val)));
 517                 return 1;
 518
 519             case CONFTYPE_INT64:
 520                 results[0] = sv_2mortal(amglue_newSVi64(val_t__int64(val)));
 521                 return 1;
 522
 523             case CONFTYPE_BOOLEAN:          /* all same as INT.. */
 524             case CONFTYPE_NO_YES_ALL:
 525             case CONFTYPE_COMPRESS:
 526             case CONFTYPE_ENCRYPT:
 527             case CONFTYPE_STRATEGY:
 528             case CONFTYPE_TAPERALGO:
 529             case CONFTYPE_PRIORITY:
 530             case CONFTYPE_HOLDING:
 531             case CONFTYPE_EXECUTE_ON:
 532             case CONFTYPE_EXECUTE_WHERE:
 533             case CONFTYPE_SEND_AMREPORT_ON:
 534             case CONFTYPE_DATA_PATH:
 535             case CONFTYPE_PART_CACHE_TYPE:
 536             case CONFTYPE_INT:
 537                 results[0] = sv_2mortal(amglue_newSVi64(val_t__int(val)));
 538                 return 1;
 539
 540            case CONFTYPE_ESTIMATELIST: {
 541                 AV *elist = newAV();
 542                 estimatelist_t el;
 543                 for (el=val_t__estimatelist(val); el != NULL; el = el->next) {
 544                     av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
 545                 }
 546                 results[0] = sv_2mortal(newRV_noinc((SV *)elist));
 547                 return 1;
 548             }
 549
 550             case CONFTYPE_TIME:
 551                 results[0] = sv_2mortal(amglue_newSVi64(val_t__time(val)));
 552                 return 1;
 553
 554             case CONFTYPE_REAL:
 555                 results[0] = sv_newmortal();
 556                 sv_setnv(results[0], val_t__real(val));
 557                 return 1;
 558
 559             case CONFTYPE_IDENT:            /* same as STRING */
 560             case CONFTYPE_STR:
 561             case CONFTYPE_APPLICATION:
 562                 results[0] = sv_newmortal();
 563                 sv_setpv(results[0], val_t__str(val));
 564                 return 1;
 565
 566             case CONFTYPE_IDENTLIST: {
 567                 AV *ilist = newAV();
 568
 569                 identlist_t il;
 570                 for (il=val_t__identlist(val); il != NULL; il = il->next) {
 571                     av_push(ilist, newSVpv((char *)il->data, 0));
 572                 }
 573
 574                 results[0] = sv_2mortal(newRV_noinc((SV *)ilist));
 575                 return 1;
 576             }
 577
 578             case CONFTYPE_HOST_LIMIT: {
 579                 AV *av;
 580                 GSList *iter;
 581                 host_limit_t *rl = &val_t__host_limit(val);
 582
 583                 av = newAV();
 584                 if (rl->same_host)
 585                     av_push(av, newSVpv("SAMEHOST-SAMEHOST-SAMEHOST", 0));
 586                 if (rl->server)
 587                     av_push(av, newSVpv("SERVER-SERVER-SERVER", 0));
 588                 for (iter=rl->match_pats; iter != NULL; iter = iter->next) {
 589                     av_push(av, newSVpv((char *)iter->data, 0));
 590                 }
 591
 592                 results[0] = sv_2mortal(newRV_noinc((SV *)av));
 593                 return 1;
 594             }
 595
 596             case CONFTYPE_AUTOLABEL: {
 597                 autolabel_t *autolabel = &val_t__autolabel(val);
 598                 HV *hv;
 599
 600                 /* now build the hash */
 601                 hv = (HV *)sv_2mortal((SV *)newHV());
 602                 hv_store(hv, "template", 8,
 603                         (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
 604                         0);
 605                 hv_store(hv, "other_config", 12,
 606                         (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
 607                         0);
 608                 hv_store(hv, "non_amanda", 10,
 609                         (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
 610                         0);
 611                 hv_store(hv, "volume_error", 12,
 612                         (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
 613                         0);
 614                 hv_store(hv, "empty", 5,
 615                         (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
 616                         0);
 617
 618                 results[0] = sv_2mortal(newRV((SV *)hv));
 619                 return 1;
 620             }
 621
 622             /* No match yet -> not one of the "complex" types */
 623             default:
 624                 SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
 625                 break;
 626         }
 627     }
 628
 629     return 0;
 630
 631 fail:
 632     SWIG_croak_null();
 633 }
 634 %}
 635
 636 %typemap (out) val_t * {
 637     SV *results[3], **iter;
 638     int nresults;
 639
 640     /* save the stack, since val_t_to_sv may invoke arbitrary Perl code */
 641     SP += argvi; PUTBACK;
 642     nresults = val_t_to_sv($1, results);
 643     SPAGAIN; SP -= argvi;
 644
 645     /* add val_t_to_sv's results to the stack */
 646     for (iter = results; nresults; iter++, nresults--) {
 647         $result = *iter;
 648         argvi++;
 649     }
 650 }
 651
 652 /* Typemap for the return value of getconf_list; this assumes that
 653  * the GSList contains strings, and that it should be freed; both
 654  * are true for getconf_list.
 655  */
 656 %typemap (out) GSList * {
 657     GSList *it = $1;
 658
 659     while (it) {
 660         $result = sv_2mortal(newSVpv(it->data, 0));
 661         argvi++;
 662         it = it->next;
 663     }
 664
 665     g_slist_free($1);
 666 }
 667
 668 /* typedef and typemap for getconf_byname_strs, which is like getconf_byname,
 669  * but converts the result with val_t_dispaly_strs
 670  */
 671 %typemap (out) val_t_strs {
 672     char **it = $1;
 673
 674     while (it && *it) {
 675         $result = sv_2mortal(newSVpv(*it, 0));
 676         argvi++;
 677         it++;
 678     }
 679     g_strfreev($1);
 680 }
 681
 682 data_path_t data_path_from_string(char *data);
 683
 684 val_t *getconf(confparm_key key);
 685 gboolean getconf_seen(confparm_key key);
 686 int getconf_linenum(confparm_key key);
 687 val_t *getconf_byname(char *key);
 688 GSList *getconf_list(char *listname);
 689 %inline %{
 690 typedef char **val_t_strs;
 691 val_t_strs getconf_byname_strs(char *key, int str_needs_quotes) {
 692     val_t *val = getconf_byname(key);
 693     if (!val) return NULL;
 694     return val_t_display_strs(val, str_needs_quotes);
 695 }
 696 %}
 697
 698 amglue_export_tag(getconf,
 699     getconf getconf_seen getconf_linenum
 700     getconf_byname getconf_byname_strs
 701     getconf_list
 702 );
 703
 704 tapetype_t *lookup_tapetype(char *identifier);
 705 val_t *tapetype_getconf(tapetype_t *ttyp, tapetype_key key);
 706 char *tapetype_name(tapetype_t *ttyp);
 707 gboolean tapetype_seen(tapetype_t *ttyp, tapetype_key key);
 708 amglue_export_tag(getconf,
 709     lookup_tapetype tapetype_getconf tapetype_name
 710     tapetype_seen tapetype_seen
 711 );
 712
 713 dumptype_t *lookup_dumptype(char *identifier);
 714 val_t *dumptype_getconf(dumptype_t *dtyp, dumptype_key key);
 715 char *dumptype_name(dumptype_t *dtyp);
 716 gboolean dumptype_seen(dumptype_t *dtyp, dumptype_key key);
 717 amglue_export_tag(getconf,
 718     lookup_dumptype dumptype_getconf dumptype_name
 719     dumptype_seen dumptype_seen
 720 );
 721
 722 interface_t *lookup_interface(char *identifier);
 723 val_t *interface_getconf(interface_t *iface, interface_key key);
 724 char *interface_name(interface_t *iface);
 725 gboolean interface_seen(interface_t *iface, interface_key key);
 726 amglue_export_tag(getconf,
 727     lookup_interface interface_getconf interface_name
 728     interface_seen interface_seen
 729 );
 730
 731 holdingdisk_t *lookup_holdingdisk(char *identifier);
 732 GSList *getconf_holdingdisks(void);
 733 val_t *holdingdisk_getconf(holdingdisk_t *hdisk, holdingdisk_key key);
 734 char *holdingdisk_name(holdingdisk_t *hdisk);
 735 gboolean holdingdisk_seen(holdingdisk_t *hdisk, holdingdisk_key key);
 736 amglue_export_tag(getconf,
 737     lookup_holdingdisk holdingdisk_getconf holdingdisk_name
 738     getconf_holdingdisks
 739     holdingdisk_seen holdingdisk_seen
 740 );
 741
 742 application_t *lookup_application(char *identifier);
 743 val_t *application_getconf(application_t *app, application_key key);
 744 char *application_name(application_t *app);
 745 gboolean application_seen(application_t *app, application_key key);
 746 amglue_export_tag(getconf,
 747     lookup_application application_getconf application_name
 748     application_seen application_seen
 749 );
 750
 751 pp_script_t *lookup_pp_script(char *identifier);
 752 val_t *pp_script_getconf(pp_script_t *pps, pp_script_key key);
 753 char *pp_script_name(pp_script_t *pps);
 754 gboolean pp_script_seen(pp_script_t *app, pp_script_key key);
 755 amglue_export_tag(getconf,
 756     lookup_pp_script pp_script_getconf pp_script_name
 757     pp_script_seen pp_script_seen
 758 );
 759
 760 device_config_t *lookup_device_config(char *identifier);
 761 val_t *device_config_getconf(device_config_t *pps, device_config_key key);
 762 char *device_config_name(device_config_t *pps);
 763 gboolean device_config_seen(device_config_t *app, device_config_key key);
 764 amglue_export_tag(getconf,
 765     lookup_device_config device_config_getconf device_config_name
 766     device_config_seen device_config_seen
 767 );
 768
 769 changer_config_t *lookup_changer_config(char *identifier);
 770 val_t *changer_config_getconf(changer_config_t *pps, changer_config_key key);
 771 char *changer_config_name(changer_config_t *pps);
 772 gboolean changer_config_seen(changer_config_t *app, changer_config_key key);
 773 amglue_export_tag(getconf,
 774     lookup_changer_config changer_config_getconf changer_config_name
 775     changer_config_seen changer_config_seen
 776 );
 777
 778 interactivity_t *lookup_interactivity(char *identifier);
 779 val_t *interactivity_getconf(interactivity_t *app, interactivity_key key);
 780 char *interactivity_name(interactivity_t *app);
 781 gboolean interactivity_seen(interactivity_t *app, interactivity_key key);
 782 amglue_export_tag(getconf,
 783     lookup_interactivity interactivity_getconf interactivity_name
 784     interactivity_seen interactivity_seen
 785 );
 786
 787 taperscan_t *lookup_taperscan(char *identifier);
 788 val_t *taperscan_getconf(taperscan_t *app, taperscan_key key);
 789 char *taperscan_name(taperscan_t *app);
 790 gboolean taperscan_seen(taperscan_t *app, taperscan_key key);
 791 amglue_export_tag(getconf,
 792     lookup_taperscan taperscan_getconf taperscan_name
 793     taperscan_seen taperscan_seen
 794 );
 795
 796 %perlcode %{
 797 # only those keys with a value of '1' should be shown; the
 798 # others are deprecated
 799 our %subsection_names = (
 800     "tapetype" => 1,
 801     "dumptype" => 1,
 802     "interface" => 1,
 803     "holdingdisk" => 1,
 804     "application" => 1,
 805     "script" => 1,
 806     "application-tool" => 0,
 807     "script-tool" => 0,
 808     "device" => 1,
 809     "changer" => 1,
 810 );
 811 %}
 812 amglue_export_tag(getconf, %subsection_names);
 813
 814 long int getconf_unit_divisor(void);
 815
 816 extern int debug_amandad;
 817 extern int debug_recovery;
 818 extern int debug_amidxtaped;
 819 extern int debug_amindexd;
 820 extern int debug_amrecover;
 821 extern int debug_auth;
 822 extern int debug_event;
 823 extern int debug_holding;
 824 extern int debug_protocol;
 825 extern int debug_planner;
 826 extern int debug_driver;
 827 extern int debug_dumper;
 828 extern int debug_chunker;
 829 extern int debug_taper;
 830 extern int debug_selfcheck;
 831 extern int debug_sendsize;
 832 extern int debug_sendbackup;
 833 amglue_export_tag(getconf,
 834     getconf_unit_divisor
 835
 836     $debug_amandad $debug_recovery $debug_amidxtaped $debug_amindexd $debug_amrecover
 837     $debug_auth $debug_event $debug_holding $debug_protocol
 838     $debug_planner $debug_driver $debug_dumper $debug_chunker
 839     $debug_taper $debug_selfcheck $debug_sendsize $debug_sendbackup
 840 );
 841
 842 /*
 843  * Initialization
 844  */
 845
 846 amglue_add_enum_tag_fns(cfgerr_level_t);
 847 amglue_add_constant(CFGERR_OK, cfgerr_level_t);
 848 amglue_add_constant(CFGERR_WARNINGS, cfgerr_level_t);
 849 amglue_add_constant(CFGERR_ERRORS, cfgerr_level_t);
 850 amglue_copy_to_tag(cfgerr_level_t, init);
 851
 852 amglue_add_flag_tag_fns(config_init_flags);
 853 amglue_add_constant(CONFIG_INIT_EXPLICIT_NAME, config_init_flags);
 854 amglue_add_constant(CONFIG_INIT_USE_CWD, config_init_flags);
 855 amglue_add_constant(CONFIG_INIT_CLIENT, config_init_flags);
 856 amglue_add_constant(CONFIG_INIT_OVERLAY, config_init_flags);
 857 amglue_copy_to_tag(config_init_flags, init);
 858
 859 cfgerr_level_t config_init(config_init_flags flags,
 860                      char *arg_config_name);
 861 void config_uninit(void);
 862 char **get_config_options(int first);
 863 char *get_config_name(void);
 864 char *get_config_dir(void);
 865 char *get_config_filename(void);
 866
 867 void config_print_errors(void);
 868 void config_clear_errors(void);
 869
 870 /* Typemap for config_errors' result parameter; this is a GSList of strings
 871  * which should *not* be freed. */
 872 %typemap(in, numinputs=0) GSList **ERRLIST (GSList *templist) {
 873    templist = NULL;
 874    $1 = &templist;
 875 }
 876
 877 %typemap (argout) GSList **ERRLIST {
 878     GSList *it = *$1;
 879
 880     while (it) {
 881         $result = sv_2mortal(newSVpv(it->data, 0));
 882         argvi++;
 883         it = it->next;
 884     }
 885 }
 886 cfgerr_level_t config_errors(GSList **ERRLIST);
 887
 888
 889 config_overrides_t *new_config_overrides(int size_estimate);
 890 void free_config_overrides(config_overrides_t *co);
 891 void add_config_override(config_overrides_t *co,
 892                          char *key,
 893                          char *value);
 894 void add_config_override_opt(config_overrides_t *co,
 895                               char *optarg);
 896 void set_config_overrides(config_overrides_t *co);
 897
 898 amglue_export_tag(init,
 899     config_init config_uninit get_config_options
 900     get_config_name get_config_dir get_config_filename
 901     config_print_errors config_clear_errors config_errors
 902     new_config_overrides free_config_overrides add_config_override
 903     add_config_override_opt set_config_overrides
 904 );
 905
 906 /*
 907  * Miscellaneous
 908  */
 909
 910 void dump_configuration(void);
 911 %newobject config_dir_relative;
 912 char *config_dir_relative(char *filename);
 913 char *taperalgo2str(taperalgo_t taperalgo);
 914 gint64 find_multiplier(char * casestr);
 915
 916 amglue_export_ok(
 917     dump_configuration config_dir_relative taperalgo2str find_multiplier
 918 );
 919
 920 %rename(C_string_to_boolean) string_to_boolean;
 921 int string_to_boolean(const char *str);
 922 %perlcode %{
 923
 924 sub string_to_boolean {
 925     my ($str) = @_;
 926     my $ret = C_string_to_boolean($str);
 927     return undef unless $ret >= 0;
 928     return $ret;
 929 }
 930
 931 %}
 932
 933 amglue_export_ok(string_to_boolean);
 934
 935 gchar * amandaify_property_name(const gchar *name);
 936 amglue_export_ok(amandaify_property_name);