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

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