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