/*

 * Amanda, The Advanced Maryland Automatic Network Disk Archiver

 * Copyright (c) 1991-2000 University of Maryland at College Park

 * Copyright (c) 2007-2012 Zmanda, Inc.  All Rights Reserved.

 * Copyright (c) 2013-2016 Carbonite, Inc.  All Rights Reserved.

 * All Rights Reserved.

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of U.M. not be used in advertising or

 * publicity pertaining to distribution of the software without specific,

 * written prior permission.  U.M. makes no representations about the

 * suitability of this software for any purpose.  It is provided "as is"

 * without express or implied warranty.

 *

 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.

 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 *

 * Author: James da Silva, Systems Design and Analysis Group

 *                         Computer Science Department

 *                         University of Maryland at College Park

 */

/*

 * $Id: conffile.h,v 1.72 2006/07/26 15:17:37 martinea Exp $

 *

 * interface for config file reading code

 */

#ifndef CONFFILE_H

#define CONFFILE_H

#include "amanda.h"

#include "amutil.h"

/* Getting Configuration Values

 * ============================

 *

 * Amanda configurations consist of a number of "global" parameters, as well as

 * named subsections of several types.  The global parameters are fetched with

 * the getconf_CONFTYPE functions, keyed by a confparam_t constant (with prefix

 * CNF_).  The subsection parameters are fetched with SUBSEC_get_PARAM()

 * macros, e.g., tapetype_get_blocksize(ttyp), where the argument comes from

 * lookup_SUBSEC(), in this case lookup_tapetype(name).

 *

 * Types

 * =====

 *

 * This module juggles two kinds of types: C types and conftypes.  Conftypes include

 * everything from integers through property lists, and are specific to the needs of

 * the configuration system.  Each conftype has a corresponding C type, which is of course

 * necessary to actually use the data.

 *

 * The val_t__CONFTYPE macros represent the canonical correspondance of conftypes to C

 * types, but in general the relationship is obvious: ints, strings, reals, and so forth

 * are represented directly.  Enumerated conftypes are represented by the corresponding

 * C enum type.  The 'rate' conftype is represented as a 2-element array of doubles, and

 * the 'intrange' conftype is represented as a 2-element array of ints.  exincludes are

 * a exinclude_t *, and a proplist is represented as a GHashTable *.

 *

 * Memory

 * ======

 * Note that, unless specified, all memory in this module is managed by the module

 * itself; return strings should not be freed by the caller.

 *

 * Error Handling

 * ==============

 * All errors and warnings generated by this module are available from get_config_errors().

 * It is up to the caller to route these messages to the user.  The function

 * config_print_errors() will print the errors to stderr, as a convenience.

 */

/*

 * Generic values

 *

 * This module uses a generic val_t type to hold values of various types -- it's basically

 * a union with type information and a 'seen' flag.  In a way, it's a very simple equivalent

 * to Glib's GValue.  It's worth considering rewriting this with GValue, but for the moment,

 * this works and it's here.

 */

/* A "seen" struct.  Rather than allocate strings all over the place, this

 * string is in the "parsed_filenames" GSList and will be freed when that

 * GSList is freed.  This struct should be opaque to other modules. */

typedef struct seen_s {

    char *block;

    char *filename;

    int linenum;

} seen_t;

/* boolean and no_yes_all */

typedef enum {

    VALUE_NO,

    VALUE_YES,

    VALUE_ALL

} no_yes_all_t;

/* priority types */

typedef enum {

    PRIORITY_LOW,               /* Always direct to tape  */

    PRIORITY_MEDIUM,            /* If possible            */

    PRIORITY_HIGH               /* Always to holding disk */

} priority_t;

/* holdingdisk types */

typedef enum {

    HOLD_NEVER,                 /* Always direct to tape  */

    HOLD_AUTO,                  /* If possible            */

    HOLD_REQUIRED               /* Always to holding disk */

} dump_holdingdisk_t;

/* Compression types */

typedef enum {

    COMP_NONE,          /* No compression */

    COMP_FAST,          /* Fast compression on client */

    COMP_BEST,          /* Best compression on client */

    COMP_CUST,          /* Custom compression on client */

    COMP_SERVER_FAST,   /* Fast compression on server */

    COMP_SERVER_BEST,   /* Best compression on server */

    COMP_SERVER_CUST    /* Custom compression on server */

} comp_t;

/* Encryption types */

typedef enum {

    ENCRYPT_NONE,               /* No encryption */

    ENCRYPT_CUST,               /* Custom encryption on client */

    ENCRYPT_SERV_CUST           /* Custom encryption on server */

} encrypt_t;

/* Estimate strategies */

typedef enum {

    ES_CLIENT,          /* client estimate */

    ES_SERVER,          /* server estimate */

    ES_CALCSIZE,        /* calcsize estimate */

    ES_ES               /* sentinel */

} estimate_t;

/* A GSlist where each element is a element_t */

typedef GSList *estimatelist_t;

typedef enum {

    AL_OTHER_CONFIG = 1<<0,

    AL_NON_AMANDA   = 1<<1,

    AL_VOLUME_ERROR = 1<<2,

    AL_EMPTY        = 1<<3,

} autolabel_enum_t;

typedef int autolabel_set_t;

typedef struct autolabel_s {

    char            *template;

    autolabel_set_t  autolabel;

} autolabel_t;

typedef struct labelstr_s {

    char     *template;

    gboolean  match_autolabel;

} labelstr_s;

/* Dump strategies */

typedef enum {

    DS_SKIP,        /* Don't do any dumps at all */

    DS_STANDARD,    /* Standard (0 1 1 1 1 2 2 2 ...) */

    DS_NOFULL,      /* No full's (1 1 1 ...) */

    DS_NOINC,       /* No inc's (0 0 0 ...) */

    DS_4,           /* ? (0 1 2 3 4 5 6 7 8 9 10 11 ...) */

    DS_5,           /* ? (0 1 1 1 1 1 1 1 1 1 1 1 ...) */

    DS_HANOI,       /* Tower of Hanoi (? ? ? ? ? ...) */

    DS_INCRONLY,    /* Forced fulls (0 1 1 2 2 FORCE0 1 1 ...) */

    DS_DS /* sentinel */

} strategy_t;

typedef enum {

    ALGO_FIRST,

    ALGO_FIRSTFIT,

    ALGO_LARGEST,

    ALGO_LARGESTFIT,

    ALGO_SMALLEST,

    ALGO_SMALLESTFIT,	/* for internal use */

    ALGO_LAST,

    ALGO_LASTFIT,	/* for internal use */

    ALGO_ALGO /* sentinel */

} taperalgo_t;

/* execute_on types */

#define EXECUTE_ON_PRE_AMCHECK         (1 << 0)

#define EXECUTE_ON_PRE_DLE_AMCHECK     (1 << 1)

#define EXECUTE_ON_PRE_HOST_AMCHECK    (1 << 2)

#define EXECUTE_ON_POST_AMCHECK        (1 << 3)

#define EXECUTE_ON_POST_DLE_AMCHECK    (1 << 4)

#define EXECUTE_ON_POST_HOST_AMCHECK   (1 << 5)

#define EXECUTE_ON_PRE_ESTIMATE        (1 << 6)

#define EXECUTE_ON_PRE_DLE_ESTIMATE    (1 << 7)

#define EXECUTE_ON_PRE_HOST_ESTIMATE   (1 << 8)

#define EXECUTE_ON_POST_ESTIMATE       (1 << 9)

#define EXECUTE_ON_POST_DLE_ESTIMATE   (1 << 10)

#define EXECUTE_ON_POST_HOST_ESTIMATE  (1 << 11)

#define EXECUTE_ON_PRE_BACKUP          (1 << 12)

#define EXECUTE_ON_PRE_DLE_BACKUP      (1 << 13)

#define EXECUTE_ON_PRE_HOST_BACKUP     (1 << 14)

#define EXECUTE_ON_POST_BACKUP         (1 << 15)

#define EXECUTE_ON_POST_DLE_BACKUP     (1 << 16)

#define EXECUTE_ON_POST_HOST_BACKUP    (1 << 17)

#define EXECUTE_ON_PRE_RECOVER         (1 << 18)

#define EXECUTE_ON_POST_RECOVER        (1 << 19)

#define EXECUTE_ON_PRE_LEVEL_RECOVER   (1 << 20)

#define EXECUTE_ON_POST_LEVEL_RECOVER  (1 << 21)

#define EXECUTE_ON_INTER_LEVEL_RECOVER (1 << 22)

typedef int execute_on_t;

typedef enum {

    EXECUTE_WHERE_CLIENT,

    EXECUTE_WHERE_SERVER,

} execute_where_t;

typedef enum {

    SEND_AMREPORT_ALL,

    SEND_AMREPORT_STRANGE,

    SEND_AMREPORT_ERROR,

    SEND_AMREPORT_NEVER

} send_amreport_t;

typedef enum {

    DATA_PATH_AMANDA    = 1<<0,

    DATA_PATH_DIRECTTCP = 1<<1,

} data_path_t;

typedef struct exinclude_s {

    am_sl_t *sl_list;

    am_sl_t *sl_file;

    int  optional;

} exinclude_t;

typedef struct {

    int append;

    int visible;

    int priority;

    GSList* values;

    seen_t seen;

} property_t;

typedef GHashTable* proplist_t;

/* A GSlist where each element is a 'char*' */

typedef GSList* identlist_t;

typedef enum {

    TAG_NAME,

    TAG_ALL,

    TAG_OTHER

} dumptype_tag_t;

typedef enum {

    LEVEL_ALL,

    LEVEL_FULL,

    LEVEL_INCR

} level_type_t;

typedef struct {

    dumptype_tag_t  tag_type;

    char           *tag;

    level_type_t    level;

} dump_selection_t;

typedef GSList* dump_selection_list_t;

typedef struct {

    char *storage;

    int  days;

} vault_el_t;

typedef GSList* vault_list_t;

/* part_cache_types */

typedef enum {

    PART_CACHE_TYPE_NONE,

    PART_CACHE_TYPE_MEMORY,

    PART_CACHE_TYPE_DISK,

} part_cache_type_t;

/* host_limit */

typedef struct {

    gboolean server;

    gboolean same_host;

    GSList *match_pats;

} host_limit_t;

/* Names for the type of value in a val_t.  Mostly for internal use, but useful

 * for wrapping val_t's, too. */

typedef enum {

    CONFTYPE_INT,

    CONFTYPE_INT64,

    CONFTYPE_REAL,

    CONFTYPE_STR,

    CONFTYPE_IDENT,

    CONFTYPE_TIME,

    CONFTYPE_SIZE,

    CONFTYPE_BOOLEAN,

    CONFTYPE_COMPRESS,

    CONFTYPE_ENCRYPT,

    CONFTYPE_HOLDING,

    CONFTYPE_ESTIMATELIST,

    CONFTYPE_STRATEGY,

    CONFTYPE_TAPERALGO,

    CONFTYPE_PRIORITY,

    CONFTYPE_RATE,

    CONFTYPE_INTRANGE,

    CONFTYPE_EXINCLUDE,

    CONFTYPE_PROPLIST,

    CONFTYPE_APPLICATION,

    CONFTYPE_EXECUTE_ON,

    CONFTYPE_EXECUTE_WHERE,

    CONFTYPE_SEND_AMREPORT_ON,

    CONFTYPE_IDENTLIST,

    CONFTYPE_DATA_PATH,

    CONFTYPE_AUTOLABEL,

    CONFTYPE_LABELSTR,

    CONFTYPE_PART_CACHE_TYPE,

    CONFTYPE_HOST_LIMIT,

    CONFTYPE_NO_YES_ALL,

    CONFTYPE_STR_LIST,

    CONFTYPE_DUMP_SELECTION,

    CONFTYPE_VAULT_LIST,

} conftype_t;

typedef enum {

    CONF_UNIT_NONE,

    CONF_UNIT_K,

} confunit_t;

/* This should be considered an opaque type for any other modules.  The complete

 * struct is included here to allow quick access via macros. Access it *only* through

 * those macros. */

typedef struct val_s {

    union {

        int		i;

        gint64		int64;

        double		r;

        char		*s;

        size_t		size;

        time_t		t;

        float		rate[2];

        exinclude_t	exinclude;

        int		intrange[2];

        proplist_t      proplist;

	estimatelist_t  estimatelist;

	identlist_t     identlist;

        autolabel_t     autolabel;

        labelstr_s      labelstr;

	host_limit_t    host_limit;

	dump_selection_list_t   dump_selection;

	vault_list_t    vault_list;

    } v;

    seen_t seen;

    conftype_t type;

    confunit_t unit;

} val_t;

/* Functions to typecheck and extract a particular type of

 * value from a val_t.  All call error() if the type is incorrect,

 * as this is a programming error.  */

int                   val_t_to_int      (val_t *);

gint64                val_t_to_int64    (val_t *);

float                 val_t_to_real     (val_t *);

char                 *val_t_to_str      (val_t *); /* (also converts CONFTYPE_IDENT) */

char                 *val_t_to_ident    (val_t *); /* (also converts CONFTYPE_STR) */

identlist_t           val_t_to_identlist(val_t *);

identlist_t           val_t_to_str_list (val_t *);

time_t                val_t_to_time     (val_t *);

ssize_t               val_t_to_size     (val_t *);

int                   val_t_to_boolean  (val_t *);

int                   val_t_to_no_yes_all(val_t *);

comp_t                val_t_to_compress (val_t *);

encrypt_t             val_t_to_encrypt  (val_t *);

dump_holdingdisk_t    val_t_to_holding  (val_t *);

estimatelist_t        val_t_to_estimatelist (val_t *);

strategy_t            val_t_to_strategy (val_t *);

taperalgo_t           val_t_to_taperalgo(val_t *);

int                   val_t_to_priority (val_t *); /* priority_t or int */

float                *val_t_to_rate     (val_t *); /* array of two floats */

exinclude_t           val_t_to_exinclude(val_t *);

int                  *val_t_to_intrange (val_t *); /* array of two ints */

proplist_t            val_t_to_proplist (val_t *);

char                 *val_t_to_application(val_t *);

execute_on_t          val_t_to_execute_on(val_t *);

execute_where_t       val_t_to_execute_where(val_t *);

send_amreport_t       val_t_to_send_amreport(val_t *);

data_path_t           val_t_to_data_path(val_t *);

autolabel_t          *val_t_to_autolabel(val_t *);

labelstr_s           *val_t_to_labelstr(val_t *);

part_cache_type_t     val_t_to_part_cache_type(val_t *);

host_limit_t         *val_t_to_host_limit(val_t *);

dump_selection_list_t val_t_to_dump_selection(val_t *);

vault_list_t          val_t_to_vault_list(val_t *);

/* Has the given val_t been seen in a configuration file or config overwrite?

 *

 * @param val: val_t* to examine

 * @returns: boolean

 */

#define val_t_seen(val) ((val)->seen.linenum)

/* What is the underlying type of this val_t?

 *

 * @param val: val_t* to examine

 * @returns: conftype_t

 */

#define val_t_type(val) ((val)->type)

/* Macros to convert val_t's to a particular type without the benefit of

 * a typecheck.  Use these only if you really know what you're doing!

 *

 * Implementation note: these macros encode the relationship of conftypes

 * (in the macro name) to the corresponding union field.  The macros work

 * as lvalues, too.

 */

#define val_t__seen(val)            ((val)->seen)

#define val_t__int(val)             ((val)->v.i)

#define val_t__int64(val)           ((val)->v.int64)

#define val_t__real(val)            ((val)->v.r)

#define val_t__str(val)             ((val)->v.s)

#define val_t__ident(val)           ((val)->v.s)

#define val_t__identlist(val)       ((val)->v.identlist)

#define val_t__time(val)            ((val)->v.t)

#define val_t__size(val)            ((val)->v.size)

#define val_t__boolean(val)         ((val)->v.i)

#define val_t__no_yes_all(val)      ((val)->v.i)

#define val_t__compress(val)        ((val)->v.i)

#define val_t__encrypt(val)         ((val)->v.i)

#define val_t__holding(val)         ((val)->v.i)

#define val_t__estimatelist(val)    ((val)->v.estimatelist)

#define val_t__strategy(val)        ((val)->v.i)

#define val_t__taperalgo(val)       ((val)->v.i)

#define val_t__send_amreport(val)   ((val)->v.i)

#define val_t__priority(val)        ((val)->v.i)

#define val_t__rate(val)            ((val)->v.rate)

#define val_t__exinclude(val)       ((val)->v.exinclude)

#define val_t__intrange(val)        ((val)->v.intrange)

#define val_t__proplist(val)        ((val)->v.proplist)

#define val_t__application(val)     ((val)->v.application)

#define val_t__execute_on(val)      ((val)->v.i)

#define val_t__execute_where(val)   ((val)->v.i)

#define val_t__data_path(val)       ((val)->v.i)

#define val_t__autolabel(val)       (&((val)->v.autolabel))

#define val_t__labelstr(val)        (&((val)->v.labelstr))

#define val_t__part_cache_type(val) ((val)->v.i)

#define val_t__host_limit(val)      ((val)->v.host_limit)

#define val_t__dump_selection(val)  ((val)->v.dump_selection)

#define val_t__vault_list(val)      ((val)->v.vault_list)

/*

 * Parameters

 *

 * Programs get val_t's by giving the index of the parameters they're interested in.

 * For global parameters, these start with CNF; for subsections, they start with the

 * name of the subsection.

 */

/*

 * Global parameter access

 */

typedef enum {

    CNF_ORG,

    CNF_CONF,

    CNF_INDEX_SERVER,

    CNF_TAPE_SERVER,

    CNF_AMDUMP_SERVER,

    CNF_AUTH,

    CNF_SSH_KEYS,

    CNF_AMANDAD_PATH,

    CNF_CLIENT_USERNAME,

    CNF_CLIENT_PORT,

    CNF_GNUTAR_LIST_DIR,

    CNF_AMANDATES,

    CNF_MAILTO,

    CNF_DUMPUSER,

    CNF_TAPEDEV,

    CNF_DEVICE_PROPERTY,

    CNF_PROPERTY,

    CNF_INTERACTIVITY,

    CNF_APPLICATION,

    CNF_APPLICATION_TOOL,

    CNF_EXECUTE_ON,

    CNF_PP_SCRIPT,

    CNF_PP_SCRIPT_TOOL,

    CNF_PLUGIN,

    CNF_CHANGERDEV,

    CNF_CHANGERFILE,

    CNF_LABELSTR,

    CNF_TAPELIST,

    CNF_DISKFILE,

    CNF_INFOFILE,

    CNF_LOGDIR,

    CNF_INDEXDIR,

    CNF_TAPETYPE,

    CNF_DUMPCYCLE,

    CNF_RUNSPERCYCLE,

    CNF_TAPECYCLE,

    CNF_NETUSAGE,

    CNF_INPARALLEL,

    CNF_DUMPORDER,

    CNF_BUMPPERCENT,

    CNF_BUMPSIZE,

    CNF_BUMPMULT,

    CNF_BUMPDAYS,

    CNF_TPCHANGER,

    CNF_RUNTAPES,

    CNF_MAXDUMPS,

    CNF_ETIMEOUT,

    CNF_DTIMEOUT,

    CNF_CTIMEOUT,

    CNF_DEVICE_OUTPUT_BUFFER_SIZE,

    CNF_PRINTER,

    CNF_MAILER,

    CNF_AUTOFLUSH,

    CNF_RESERVE,

    CNF_MAXDUMPSIZE,

    CNF_COLUMNSPEC,

    CNF_AMRECOVER_DO_FSF,

    CNF_AMRECOVER_CHECK_LABEL,

    CNF_AMRECOVER_CHANGER,

    CNF_TAPERALGO,

    CNF_SEND_AMREPORT_ON,

    CNF_FLUSH_THRESHOLD_DUMPED,

    CNF_FLUSH_THRESHOLD_SCHEDULED,

    CNF_TAPERFLUSH,

    CNF_DISPLAYUNIT,

    CNF_KRB5KEYTAB,

    CNF_KRB5PRINCIPAL,

    CNF_LABEL_NEW_TAPES,

    CNF_USETIMESTAMPS,

    CNF_REP_TRIES,

    CNF_CONNECT_TRIES,

    CNF_REQ_TRIES,

    CNF_DEBUG_AMANDAD,

    CNF_DEBUG_RECOVERY,

    CNF_DEBUG_AMIDXTAPED,

    CNF_DEBUG_AMINDEXD,

    CNF_DEBUG_AMRECOVER,

    CNF_DEBUG_AUTH,

    CNF_DEBUG_EVENT,

    CNF_DEBUG_HOLDING,

    CNF_DEBUG_PROTOCOL,

    CNF_DEBUG_PLANNER,

    CNF_DEBUG_DRIVER,

    CNF_DEBUG_DUMPER,

    CNF_DEBUG_CHUNKER,

    CNF_DEBUG_TAPER,

    CNF_DEBUG_SELFCHECK,

    CNF_DEBUG_SENDSIZE,

    CNF_DEBUG_SENDBACKUP,

    CNF_RESERVED_UDP_PORT,

    CNF_RESERVED_TCP_PORT,

    CNF_UNRESERVED_TCP_PORT,

    CNF_HOLDINGDISK,

    CNF_AUTOLABEL,

    CNF_META_AUTOLABEL,

    CNF_DEBUG_DAYS,

    CNF_TAPER_PARALLEL_WRITE,

    CNF_RECOVERY_LIMIT,

    CNF_TAPERSCAN,

    CNF_MAX_DLE_BY_VOLUME,

    CNF_EJECT_VOLUME,

    CNF_TMPDIR,

    CNF_REPORT_USE_MEDIA,

    CNF_REPORT_NEXT_MEDIA,

    CNF_REPORT_FORMAT,

    CNF_ACTIVE_STORAGE,

    CNF_STORAGE,

    CNF_VAULT_STORAGE,

    CNF_CMDFILE,

    CNF_COMPRESS_INDEX,

    CNF_SORT_INDEX,

    CNF_REST_API_PORT,

    CNF_REST_SSL_CERT,

    CNF_REST_SSL_KEY,

    CNF_SSL_FINGERPRINT_FILE,

    CNF_SSL_CERT_FILE,

    CNF_SSL_KEY_FILE,

    CNF_SSL_CA_CERT_FILE,

    CNF_SSL_CIPHER_LIST,

    CNF_SSL_CHECK_HOST,

    CNF_SSL_CHECK_CERTIFICATE_HOST,

    CNF_SSL_DIR,

    CNF_SSL_CHECK_FINGERPRINT,

    CNF_HOSTNAME,

    CNF_CNF /* sentinel */

} confparm_key;

/* Given a confparm_key, return a pointer to the corresponding val_t.

 *

 * @param key: confparm_key

 * @returns: pointer to value

 */

val_t *getconf(confparm_key key);

/* (convenience macro) has this global parameter been seen?

 *

 * @param key: confparm_key

 * @returns: boolean

 */

#define getconf_seen(key)       (val_t_seen(getconf((key))))

#define getconf_linenum(key)       (val_t_seen(getconf((key))))

/* (convenience macros)

 * Fetch a global parameter of a specific type.  Note that these

 * convenience macros have a different form from those for the

 * subsections: here you specify a type and a key, while for the

 * subsections you specify only a key.  The difference is historical.

 *

 * @param key: confparm_key

 * @returns: various

 */

#define getconf_int(key)          (val_t_to_int(getconf((key))))

#define getconf_int64(key)        (val_t_to_int64(getconf((key))))

#define getconf_real(key)         (val_t_to_real(getconf((key))))

#define getconf_str(key)	  (val_t_to_str(getconf((key))))

#define getconf_ident(key)        (val_t_to_ident(getconf((key))))

#define getconf_identlist(key)    (val_t_to_identlist(getconf((key))))

#define getconf_time(key)         (val_t_to_time(getconf((key))))

#define getconf_size(key)         (val_t_to_size(getconf((key))))

#define getconf_boolean(key)      (val_t_to_boolean(getconf((key))))

#define getconf_no_yes_all(key)   (val_t_to_no_yes_all(getconf((key))))

#define getconf_compress(key)     (val_t_to_compress(getconf((key))))

#define getconf_encrypt(key)      (val_t_to_encrypt(getconf((key))))

#define getconf_holding(key)      (val_t_to_holding(getconf((key))))

#define getconf_estimatelist(key) (val_t_to_estimatelist(getconf((key))))

#define getconf_strategy(key)     (val_t_to_strategy(getconf((key))))

#define getconf_taperalgo(key)    (val_t_to_taperalgo(getconf((key))))

#define getconf_priority(key)     (val_t_to_priority(getconf((key))))

#define getconf_rate(key)         (val_t_to_rate(getconf((key))))

#define getconf_exinclude(key)    (val_t_to_exinclude(getconf((key))))

#define getconf_intrange(key)     (val_t_to_intrange(getconf((key))))

#define getconf_proplist(key)     (val_t_to_proplist(getconf((key))))

#define getconf_send_amreport(key) (val_t_to_send_amreport(getconf((key))))

#define getconf_autolabel(key)    (val_t_to_autolabel(getconf((key))))

#define getconf_labelstr(key)     (val_t_to_labelstr(getconf((key))))

#define getconf_part_cache_type(key) (val_t_to_part_cache_type(getconf((key))))

#define getconf_recovery_limit(key) (val_t_to_host_limit(getconf((key))))

/* Get a list of names for subsections of the given type

 *

 * @param listname: the desired type of subsection

 * @returns: list of subsection names; caller is responsible for freeing

 * this list, but not the strings it points to, using g_slist_free().

 */

GSList *getconf_list(char *listname);

/* Get a configuration value by name, supporting the TYPE:SUBSEC:KEYWORD.

 * Returns NULL if the configuration value doesnt exist.

 */

val_t *getconf_byname(char *key);

char *confparm_key_to_name(int parm);

/*

 * Derived values

 *

 * Values which aren't directly specified by the configuration, but which

 * are derived from it.

 */

/* Return a divisor which will convert a value in units of kilo-whatevers

 * to the user's selected display unit.

 *

 * @returns: long integer divisor

 */

long int getconf_unit_divisor(void);

extern char *prepend_prefix;

/* If any of these globals are true, the corresponding component will

 * send verbose debugging output to the debug file.  The options are

 * set during config_init, but can be modified at will after that if 

 * desired.  */

extern int debug_amandad;

extern int debug_recovery;

extern int debug_amidxtaped;

extern int debug_amindexd;

extern int debug_amrecover;

extern int debug_auth;

extern int debug_event;

extern int debug_holding;

extern int debug_protocol;

extern int debug_planner;

extern int debug_driver;

extern int debug_dumper;

extern int debug_chunker;

extern int debug_taper;

extern int debug_selfcheck;

extern int debug_sendsize;

extern int debug_sendbackup;

/*

 * Tapetype parameter access

 */

typedef enum {

    TAPETYPE_COMMENT,

    TAPETYPE_LBL_TEMPL,

    TAPETYPE_BLOCKSIZE,

    TAPETYPE_READBLOCKSIZE,

    TAPETYPE_LENGTH,

    TAPETYPE_FILEMARK,

    TAPETYPE_SPEED,

    TAPETYPE_PART_SIZE,

    TAPETYPE_PART_CACHE_TYPE,

    TAPETYPE_PART_CACHE_DIR,

    TAPETYPE_PART_CACHE_MAX_SIZE,

    TAPETYPE_TAPETYPE /* sentinel */

} tapetype_key;

/* opaque object */

typedef struct tapetype_s tapetype_t;

/* Given the name of the tapetype, return a tapetype object.  Returns NULL

 * if no matching tapetype exists.  Note that the match is case-insensitive.

 *

 * @param identifier: name of the desired tapetype

 * @returns: object or NULL

 */

tapetype_t *lookup_tapetype(char *identifier);

/* Given a tapetype and a key, return a pointer to the corresponding val_t.

 *

 * @param ttyp: the tapetype to examine

 * @param key: tapetype_key (one of the TAPETYPE_* constants)

 * @returns: pointer to value

 */

val_t *tapetype_getconf(tapetype_t *ttyp, tapetype_key key);

/* Get the name of this tapetype.

 *

 * @param ttyp: the tapetype to examine

 * @returns: name of the tapetype

 */

char *tapetype_name(tapetype_t *ttyp);

char *tapetype_key_to_name(int parm);

/* (convenience macro) has this parameter been seen in this tapetype?  This

 * applies to the specific parameter *within* the tapetype.

 *

 * @param key: tapetype_key

 * @returns: boolean

 */

#define tapetype_seen(ttyp, key)       (val_t_seen(tapetype_getconf((ttyp), (key))))

/* (convenience macros)

 * fetch a particular parameter; caller must know the correct type.

 *

 * @param ttyp: the tapetype to examine

 * @returns: various

 */

#define tapetype_get_comment(ttyp)             (val_t_to_str(tapetype_getconf((ttyp), TAPETYPE_COMMENT)))

#define tapetype_get_lbl_templ(ttyp)           (val_t_to_str(tapetype_getconf((ttyp), TAPETYPE_LBL_TEMPL)))

#define tapetype_get_blocksize(ttyp)           (val_t_to_size(tapetype_getconf((ttyp), TAPETYPE_BLOCKSIZE)))

#define tapetype_get_readblocksize(ttyp)       (val_t_to_size(tapetype_getconf((ttyp), TAPETYPE_READBLOCKSIZE)))

#define tapetype_get_length(ttyp)              (val_t_to_int64(tapetype_getconf((ttyp), TAPETYPE_LENGTH)))

#define tapetype_get_filemark(ttyp)            (val_t_to_int64(tapetype_getconf((ttyp), TAPETYPE_FILEMARK)))

#define tapetype_get_speed(ttyp)               (val_t_to_int(tapetype_getconf((ttyp), TAPETYPE_SPEED)))

#define tapetype_get_part_size(ttyp)           (val_t_to_int64(tapetype_getconf((ttyp), TAPETYPE_PART_SIZE)))

#define tapetype_get_part_cache_type(ttyp)     (val_t_to_part_cache_type(tapetype_getconf((ttyp), TAPETYPE_PART_CACHE_TYPE)))

#define tapetype_get_part_cache_dir(ttyp)      (val_t_to_str(tapetype_getconf((ttyp), TAPETYPE_PART_CACHE_DIR)))

#define tapetype_get_part_cache_max_size(ttyp) (val_t_to_int64(tapetype_getconf((ttyp), TAPETYPE_PART_CACHE_MAX_SIZE)))

/*

 * Dumptype parameter access

 *

 * Note that some parameters are generic to the host

 */

typedef enum {

    DUMPTYPE_COMMENT,

    DUMPTYPE_PROGRAM,

    DUMPTYPE_SRVCOMPPROG,

    DUMPTYPE_CLNTCOMPPROG,

    DUMPTYPE_SRV_ENCRYPT,

    DUMPTYPE_CLNT_ENCRYPT,

    DUMPTYPE_AMANDAD_PATH,		/* host parameter */

    DUMPTYPE_CLIENT_USERNAME,		/* host parameter */

    DUMPTYPE_SSH_KEYS,			/* host parameter */

    DUMPTYPE_AUTH,			/* host parameter */

    DUMPTYPE_EXCLUDE,

    DUMPTYPE_INCLUDE,

    DUMPTYPE_PRIORITY,

    DUMPTYPE_DUMPCYCLE,

    DUMPTYPE_MAXDUMPS,		        /* host parameter */

    DUMPTYPE_MAXPROMOTEDAY,

    DUMPTYPE_BUMPPERCENT,

    DUMPTYPE_BUMPSIZE,

    DUMPTYPE_BUMPDAYS,

    DUMPTYPE_BUMPMULT,

    DUMPTYPE_STARTTIME,

    DUMPTYPE_STRATEGY,

    DUMPTYPE_ESTIMATELIST,

    DUMPTYPE_COMPRESS,

    DUMPTYPE_ENCRYPT,

    DUMPTYPE_SRV_DECRYPT_OPT,

    DUMPTYPE_CLNT_DECRYPT_OPT,

    DUMPTYPE_COMPRATE,

    DUMPTYPE_TAPE_SPLITSIZE,

    DUMPTYPE_FALLBACK_SPLITSIZE,

    DUMPTYPE_SPLIT_DISKBUFFER,

    DUMPTYPE_RECORD,

    DUMPTYPE_SKIP_INCR,

    DUMPTYPE_SKIP_FULL,

    DUMPTYPE_HOLDINGDISK,

    DUMPTYPE_KENCRYPT,

    DUMPTYPE_IGNORE,

    DUMPTYPE_INDEX,

    DUMPTYPE_APPLICATION,

    DUMPTYPE_SCRIPTLIST,

    DUMPTYPE_PROPERTY,

    DUMPTYPE_CLIENT_PORT,

    DUMPTYPE_DATA_PATH,

    DUMPTYPE_ALLOW_SPLIT,

    DUMPTYPE_RECOVERY_LIMIT,

    DUMPTYPE_DUMP_LIMIT,

    DUMPTYPE_MAX_WARNINGS,

    DUMPTYPE_RETRY_DUMP,

    DUMPTYPE_TAG,

    DUMPTYPE_SSL_FINGERPRINT_FILE,

    DUMPTYPE_SSL_CERT_FILE,

    DUMPTYPE_SSL_KEY_FILE,

    DUMPTYPE_SSL_CA_CERT_FILE,

    DUMPTYPE_SSL_CIPHER_LIST,

    DUMPTYPE_SSL_CHECK_HOST,

    DUMPTYPE_SSL_CHECK_CERTIFICATE_HOST,

    DUMPTYPE_SSL_CHECK_FINGERPRINT,

    DUMPTYPE_DUMPTYPE /* sentinel */

} dumptype_key;

/* opaque object */

typedef struct dumptype_s dumptype_t;

/* Given the name of the dumptype, return a dumptype object.  Returns NULL

 * if no matching dumptype exists.  Note that the match is case-insensitive.

 *

 * @param identifier: name of the desired dumptype

 * @returns: object or NULL

 */

dumptype_t *lookup_dumptype(char *identifier);

/* Given a dumptype and a key, return a pointer to the corresponding val_t.

 *

 * @param dtyp: the dumptype to examine

 * @param key: dumptype_key (one of the TAPETYPE_* constants)

 * @returns: pointer to value

 */

val_t *dumptype_getconf(dumptype_t *dtyp, dumptype_key key);

/* Get the name of this dumptype.

 *

 * @param dtyp: the dumptype to examine

 * @returns: name of the dumptype

 */

char *dumptype_name(dumptype_t *dtyp);

char *dumptype_key_to_name(int parm);

/* (convenience macro) has this parameter been seen in this dumptype?  This

 * applies to the specific parameter *within* the dumptype.

 *

 * @param key: dumptype_key

 * @returns: boolean

 */

#define dumptype_seen(dtyp, key)       (val_t_seen(dumptype_getconf((dtyp), (key))))

/* (convenience macros)

 * fetch a particular parameter; caller must know the correct type.

 *

 * @param dtyp: the dumptype to examine

 * @returns: various

 */

#define dumptype_get_comment(dtyp)             (val_t_to_str(dumptype_getconf((dtyp), DUMPTYPE_COMMENT)))

#define dumptype_get_program(dtyp)             (val_t_to_str(dumptype_getconf((dtyp), DUMPTYPE_PROGRAM)))

#define dumptype_get_srvcompprog(dtyp)         (val_t_to_str(dumptype_getconf((dtyp), DUMPTYPE_SRVCOMPPROG)))

#define dumptype_get_clntcompprog(dtyp)        (val_t_to_str(dumptype_getconf((dtyp), DUMPTYPE_CLNTCOMPPROG)))

#define dumptype_get_srv_encrypt(dtyp)         (val_t_to_str(dumptype_getconf((dtyp), DUMPTYPE_SRV_ENCRYPT)))