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