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