/*
* 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.
* All Rights Reserved.
*
* Permission to use, copy, modify, distribute, and sell this software and its
CONF_CHANGERDEV, CONF_CHANGERFILE, CONF_LABELSTR,
CONF_BUMPPERCENT, CONF_BUMPSIZE, CONF_BUMPDAYS,
CONF_BUMPMULT, CONF_ETIMEOUT, CONF_DTIMEOUT,
- CONF_CTIMEOUT, CONF_TAPEBUFS, CONF_TAPELIST,
- CONF_DEVICE_OUTPUT_BUFFER_SIZE, CONF_RAWTAPEDEV,
+ CONF_CTIMEOUT, CONF_TAPELIST,
+ CONF_DEVICE_OUTPUT_BUFFER_SIZE,
CONF_DISKFILE, CONF_INFOFILE, CONF_LOGDIR,
CONF_LOGFILE, CONF_DISKDIR, CONF_DISKSIZE,
CONF_INDEXDIR, CONF_NETUSAGE, CONF_INPARALLEL,
CONF_TAPERFLUSH,
CONF_FLUSH_THRESHOLD_DUMPED,
CONF_FLUSH_THRESHOLD_SCHEDULED,
- CONF_DEVICE_PROPERTY, CONF_PROPERTY, CONF_PLUGIN,
+ CONF_DEVICE_PROPERTY, CONF_PROPERTY, CONF_PLUGIN,
CONF_APPLICATION, CONF_APPLICATION_TOOL,
- CONF_PP_SCRIPT, CONF_PP_SCRIPT_TOOL,
+ CONF_SCRIPT, CONF_SCRIPT_TOOL,
CONF_EXECUTE_ON, CONF_EXECUTE_WHERE, CONF_SEND_AMREPORT_ON,
- CONF_DEVICE,
+ CONF_DEVICE, CONF_ORDER, CONF_SINGLE_EXECUTION,
+ CONF_DATA_PATH, CONF_AMANDA, CONF_DIRECTTCP,
+ CONF_TAPER_PARALLEL_WRITE, CONF_INTERACTIVITY, CONF_TAPERSCAN,
+ CONF_MAX_DLE_BY_VOLUME, CONF_EJECT_VOLUME, CONF_TMPDIR,
+ CONF_REPORT_USE_MEDIA, CONF_REPORT_NEXT_MEDIA,
/* execute on */
+ CONF_PRE_AMCHECK, CONF_POST_AMCHECK,
CONF_PRE_DLE_AMCHECK, CONF_PRE_HOST_AMCHECK,
CONF_POST_DLE_AMCHECK, CONF_POST_HOST_AMCHECK,
+ CONF_PRE_ESTIMATE, CONF_POST_ESTIMATE,
CONF_PRE_DLE_ESTIMATE, CONF_PRE_HOST_ESTIMATE,
CONF_POST_DLE_ESTIMATE, CONF_POST_HOST_ESTIMATE,
+ CONF_PRE_BACKUP, CONF_POST_BACKUP,
CONF_PRE_DLE_BACKUP, CONF_PRE_HOST_BACKUP,
CONF_POST_DLE_BACKUP, CONF_POST_HOST_BACKUP,
CONF_PRE_RECOVER, CONF_POST_RECOVER,
CONF_SPLIT_DISKBUFFER, CONF_FALLBACK_SPLITSIZE,CONF_SRVCOMPPROG,
CONF_CLNTCOMPPROG, CONF_SRV_ENCRYPT, CONF_CLNT_ENCRYPT,
CONF_SRV_DECRYPT_OPT, CONF_CLNT_DECRYPT_OPT, CONF_AMANDAD_PATH,
- CONF_CLIENT_USERNAME,
+ CONF_CLIENT_USERNAME, CONF_CLIENT_PORT, CONF_ALLOW_SPLIT,
+ CONF_MAX_WARNINGS,
/* tape type */
- /*COMMENT,*/ CONF_BLOCKSIZE, CONF_FILE_PAD,
+ /*COMMENT,*/ CONF_BLOCKSIZE,
CONF_LBL_TEMPL, CONF_FILEMARK, CONF_LENGTH,
CONF_SPEED, CONF_READBLOCKSIZE,
/* client conf */
CONF_CONF, CONF_INDEX_SERVER, CONF_TAPE_SERVER,
CONF_SSH_KEYS, CONF_GNUTAR_LIST_DIR, CONF_AMANDATES,
+ CONF_AMDUMP_SERVER,
/* protocol config */
CONF_REP_TRIES, CONF_CONNECT_TRIES, CONF_REQ_TRIES,
/* debug config */
+ CONF_DEBUG_DAYS,
CONF_DEBUG_AMANDAD, CONF_DEBUG_AMIDXTAPED, CONF_DEBUG_AMINDEXD,
CONF_DEBUG_AMRECOVER, CONF_DEBUG_AUTH, CONF_DEBUG_EVENT,
CONF_DEBUG_HOLDING, CONF_DEBUG_PROTOCOL, CONF_DEBUG_PLANNER,
CONF_DEBUG_DRIVER, CONF_DEBUG_DUMPER, CONF_DEBUG_CHUNKER,
CONF_DEBUG_TAPER, CONF_DEBUG_SELFCHECK, CONF_DEBUG_SENDSIZE,
- CONF_DEBUG_SENDBACKUP,
+ CONF_DEBUG_SENDBACKUP, CONF_DEBUG_RECOVERY,
/* network interface */
/* COMMENT, */ /* USE, */
CONF_SERVER, CONF_CLIENT, CONF_CALCSIZE,
CONF_CUSTOM,
+ /* autolabel */
+ CONF_AUTOLABEL, CONF_ANY_VOLUME, CONF_OTHER_CONFIG,
+ CONF_NON_AMANDA, CONF_VOLUME_ERROR, CONF_EMPTY,
+ CONF_META_AUTOLABEL,
+
+ /* part_cache_type */
+ CONF_PART_SIZE, CONF_PART_CACHE_TYPE, CONF_PART_CACHE_DIR,
+ CONF_PART_CACHE_MAX_SIZE, CONF_DISK, CONF_MEMORY,
+
+ /* host-limit */
+ CONF_RECOVERY_LIMIT, CONF_SAME_HOST, CONF_DUMP_LIMIT,
+
/* holdingdisk */
CONF_NEVER, CONF_AUTO, CONF_REQUIRED,
/* numbers */
CONF_AMINFINITY, CONF_MULT1, CONF_MULT7,
CONF_MULT1K, CONF_MULT1M, CONF_MULT1G,
+ CONF_MULT1T,
/* boolean */
- CONF_ATRUE, CONF_AFALSE
+ CONF_ATRUE, CONF_AFALSE,
+
+ CONF_CLIENT_NAME,
} tok_t;
/* A keyword table entry, mapping the given keyword to the given token.
static char *current_filename = NULL;
static char *current_line = NULL;
static char *current_char = NULL;
+static char *current_block = NULL;
static int current_line_num = 0; /* (technically, managed by the parser) */
/* A static buffer for storing tokens while they are being scanned. */
static char tkbuf[4096];
+/* Return a token formated for output */
+static char *str_keyword(keytab_t *kt);
+
+static char *str_keyword(keytab_t *kt);
/* Look up the name of the given token in the current keytable */
static char *get_token_name(tok_t);
static int conftoken_getc(void);
static int conftoken_ungetc(int c);
-static void copy_proplist(gpointer key_p,
- gpointer value_p,
- gpointer user_data_p);
-static void copy_pp_scriptlist(gpointer data_p,
- gpointer user_data_p);
+static void merge_proplist_foreach_fn(gpointer key_p,
+ gpointer value_p,
+ gpointer user_data_p);
+static void copy_proplist_foreach_fn(gpointer key_p,
+ gpointer value_p,
+ gpointer user_data_p);
/*
* Parser
};
struct holdingdisk_s {
- struct holdingdisk_s *next;
seen_t seen;
char *name;
struct changer_config_s {
struct changer_config_s *next;
- int seen;
+ seen_t seen;
char *name;
val_t value[CHANGER_CONFIG_CHANGER_CONFIG];
};
+struct interactivity_s {
+ struct interactivity_s *next;
+ seen_t seen;
+ char *name;
+
+ val_t value[INTERACTIVITY_INTERACTIVITY];
+};
+
+struct taperscan_s {
+ struct taperscan_s *next;
+ seen_t seen;
+ char *name;
+
+ val_t value[TAPERSCAN_TAPERSCAN];
+};
+
/* The current parser table */
static conf_var_t *parsetable = NULL;
*/
static void read_block(conf_var_t *read_var, val_t *valarray,
char *errormsg, int read_brace,
- void (*copy_function)(void));
+ void (*copy_function)(void),
+ char *type, char *name);
/* For each subsection type, we have a global and four functions:
* - foocur is a temporary struct used to assemble new subsections
* - copy_foo implements inheritance as described in read_block()
*/
static holdingdisk_t hdcur;
-static void get_holdingdisk(void);
+static void get_holdingdisk(int is_define);
static void init_holdingdisk_defaults(void);
static void save_holdingdisk(void);
-/* (holdingdisks don't support inheritance) */
+static void copy_holdingdisk(void);
static dumptype_t dpcur;
static void get_dumptype(void);
static void save_changer_config(void);
static void copy_changer_config(void);
+static interactivity_t ivcur;
+static void get_interactivity(void);
+static void init_interactivity_defaults(void);
+static void save_interactivity(void);
+static void copy_interactivity(void);
+
+static taperscan_t tscur;
+static void get_taperscan(void);
+static void init_taperscan_defaults(void);
+static void save_taperscan(void);
+static void copy_taperscan(void);
+
/* read_functions -- these fit into the read_function slot in a parser
* table entry, and are responsible for calling getconf_token as necessary
* to consume their arguments, and setting their second argument with the
static void read_time(conf_var_t *, val_t *);
static void read_size(conf_var_t *, val_t *);
static void read_bool(conf_var_t *, val_t *);
+static void read_no_yes_all(conf_var_t *, val_t *);
static void read_compress(conf_var_t *, val_t *);
static void read_encrypt(conf_var_t *, val_t *);
static void read_holding(conf_var_t *, val_t *);
-static void read_estimate(conf_var_t *, val_t *);
+static void read_estimatelist(conf_var_t *, val_t *);
static void read_strategy(conf_var_t *, val_t *);
static void read_taperalgo(conf_var_t *, val_t *);
static void read_send_amreport_on(conf_var_t *, val_t *);
+static void read_data_path(conf_var_t *, val_t *);
static void read_priority(conf_var_t *, val_t *);
static void read_rate(conf_var_t *, val_t *);
static void read_exinclude(conf_var_t *, val_t *);
static void read_intrange(conf_var_t *, val_t *);
static void read_dapplication(conf_var_t *, val_t *);
+static void read_dinteractivity(conf_var_t *, val_t *);
+static void read_dtaperscan(conf_var_t *, val_t *);
static void read_dpp_script(conf_var_t *, val_t *);
static void read_property(conf_var_t *, val_t *);
static void read_execute_on(conf_var_t *, val_t *);
static void read_execute_where(conf_var_t *, val_t *);
-
+static void read_holdingdisk(conf_var_t *, val_t *);
+static void read_int_or_str(conf_var_t *, val_t *);
+static void read_autolabel(conf_var_t *, val_t *);
+static void read_part_cache_type(conf_var_t *, val_t *);
+static void read_host_limit(conf_var_t *, val_t *);
+
+static application_t *read_application(char *name, FILE *from, char *fname,
+ int *linenum);
+static pp_script_t *read_pp_script(char *name, FILE *from, char *fname,
+ int *linenum);
+static device_config_t *read_device_config(char *name, FILE *from, char *fname,
+ int *linenum);
+static changer_config_t *read_changer_config(char *name, FILE *from,
+ char *fname, int *linenum);
+static interactivity_t *read_interactivity(char *name, FILE *from,
+ char *fname, int *linenum);
+static taperscan_t *read_taperscan(char *name, FILE *from, char *fname,
+ int *linenum);
/* Functions to get various types of values. These are called by
* read_functions to take care of any variations in the way that these
* values can be written: integers can have units, boolean values can be
* specified with a number of names, etc. They form utility functions
* for the read_functions, below. */
+static gint64 get_multiplier(gint64 val, confunit_t unit);
static time_t get_time(void);
-static int get_int(void);
-static ssize_t get_size(void);
-static gint64 get_int64(void);
+static int get_int(confunit_t unit);
+static ssize_t get_size(confunit_t unit);
+static gint64 get_int64(confunit_t unit);
static int get_bool(void);
+static int get_no_yes_all(void);
/* Check the given 'seen', flagging an error if this value has already
* been seen and allow_overwrites is false. Also marks the value as
* a parser table entry. They call conf_parserror if the value in their
* second argument is invalid. */
static void validate_nonnegative(conf_var_t *, val_t *);
+static void validate_non_zero(conf_var_t *, val_t *);
static void validate_positive(conf_var_t *, val_t *);
static void validate_runspercycle(conf_var_t *, val_t *);
static void validate_bumppercent(conf_var_t *, val_t *);
static void validate_reserved_port_range(conf_var_t *, val_t *);
static void validate_unreserved_port_range(conf_var_t *, val_t *);
static void validate_program(conf_var_t *, val_t *);
+static void validate_dump_limit(conf_var_t *, val_t *);
+static void validate_tmpdir(conf_var_t *, val_t *);
+
+gint compare_pp_script_order(gconstpointer a, gconstpointer b);
/*
* Initialization
* with CONFIG_INIT_CLIENT) */
static gboolean config_client = FALSE;
-/* What config overwrites are applied? */
-static config_overwrites_t *applied_config_overwrites = NULL;
+/* What config overwrites to use? */
+static config_overrides_t *config_overrides = NULL;
/* All global parameters */
static val_t conf_data[CNF_CNF];
/* Linked list of holding disks */
-static holdingdisk_t *holdinglist = NULL;
+static GSList *holdinglist = NULL;
static dumptype_t *dumplist = NULL;
static tapetype_t *tapelist = NULL;
static interface_t *interface_list = NULL;
static pp_script_t *pp_script_list = NULL;
static device_config_t *device_config_list = NULL;
static changer_config_t *changer_config_list = NULL;
+static interactivity_t *interactivity_list = NULL;
+static taperscan_t *taperscan_list = NULL;
/* storage for derived values */
static long int unit_divisor = 1;
int debug_amandad = 0;
+int debug_recovery = 0;
int debug_amidxtaped = 0;
int debug_amindexd = 0;
int debug_amrecover = 0;
*/
static void update_derived_values(gboolean is_client);
+static cfgerr_level_t apply_config_overrides(config_overrides_t *co,
+ char *key_ovr);
+
/* per-type conf_init functions, used as utilities for init_defaults
* and for each subsection's init_foo_defaults.
*
* These set the value's type and seen flags, as well as copying
* the relevant value into the 'v' field.
*/
-static void conf_init_int(val_t *val, int i);
-static void conf_init_int64(val_t *val, gint64 l);
+static void conf_init_int(val_t *val, confunit_t unit, int i);
+static void conf_init_int64(val_t *val, confunit_t unit, gint64 l);
static void conf_init_real(val_t *val, float r);
static void conf_init_str(val_t *val, char *s);
static void conf_init_ident(val_t *val, char *s);
+static void conf_init_identlist(val_t *val, char *s);
static void conf_init_time(val_t *val, time_t t);
-static void conf_init_size(val_t *val, ssize_t sz);
+static void conf_init_size(val_t *val, confunit_t unit, ssize_t sz);
static void conf_init_bool(val_t *val, int i);
+static void conf_init_no_yes_all(val_t *val, int i);
static void conf_init_compress(val_t *val, comp_t i);
static void conf_init_encrypt(val_t *val, encrypt_t i);
+static void conf_init_data_path(val_t *val, data_path_t i);
static void conf_init_holding(val_t *val, dump_holdingdisk_t i);
-static void conf_init_estimate(val_t *val, estimate_t i);
+static void conf_init_estimatelist(val_t *val, estimate_t i);
static void conf_init_execute_on(val_t *, int);
static void conf_init_execute_where(val_t *, int);
static void conf_init_send_amreport(val_t *val, send_amreport_t i);
static void conf_init_exinclude(val_t *val); /* to empty list */
static void conf_init_intrange(val_t *val, int i1, int i2);
static void conf_init_proplist(val_t *val); /* to empty list */
-static void conf_init_pp_scriptlist(val_t *);
static void conf_init_application(val_t *val);
+static void conf_init_autolabel(val_t *val);
+static void conf_init_part_cache_type(val_t *val, part_cache_type_t i);
+static void conf_init_host_limit(val_t *val);
+static void conf_init_host_limit_server(val_t *val);
/*
* Command-line Handling
*/
-typedef struct config_overwrite_s {
- char *key;
- char *value;
-} config_overwrite_t;
+typedef struct config_override_s {
+ char *key;
+ char *value;
+ gboolean applied;
+} config_override_t;
-struct config_overwrites_s {
+struct config_overrides_s {
int n_allocated;
int n_used;
- config_overwrite_t *ovr;
+ config_override_t *ovr;
};
/*
* val_t Management
*/
+static void merge_val_t(val_t *, val_t *);
static void copy_val_t(val_t *, val_t *);
static void free_val_t(val_t *);
* Utilities
*/
+/* memory handling */
+void free_property_t(gpointer p);
/* Utility functions/structs for val_t_display_strs */
static char *exinclude_display_str(val_t *val, int file);
static void proplist_display_str_foreach_fn(gpointer key_p, gpointer value_p, gpointer user_data_p);
-static void pp_scriptlist_display_str_foreach_fn(gpointer data_p, gpointer user_data_p);
-static void val_t_print_token(FILE *output, char *prefix, char *format, keytab_t *kt, val_t *val);
+static void val_t_print_token(gboolean print_default, gboolean print_source, FILE *output, char *prefix, char *format, keytab_t *kt, val_t *val);
/* Given a key name as used in config overwrites, return a pointer to the corresponding
* conf_var_t in the current parsetable, and the val_t representing that value. This
/* First, the keyword tables for client and server */
keytab_t client_keytab[] = {
{ "CONF", CONF_CONF },
+ { "AMDUMP_SERVER", CONF_AMDUMP_SERVER },
{ "INDEX_SERVER", CONF_INDEX_SERVER },
{ "TAPE_SERVER", CONF_TAPE_SERVER },
{ "TAPEDEV", CONF_TAPEDEV },
{ "AUTH", CONF_AUTH },
{ "SSH_KEYS", CONF_SSH_KEYS },
{ "AMANDAD_PATH", CONF_AMANDAD_PATH },
+ { "CLIENT_NAME", CONF_CLIENT_NAME },
{ "CLIENT_USERNAME", CONF_CLIENT_USERNAME },
+ { "CLIENT_PORT", CONF_CLIENT_PORT },
{ "GNUTAR_LIST_DIR", CONF_GNUTAR_LIST_DIR },
{ "AMANDATES", CONF_AMANDATES },
{ "KRB5KEYTAB", CONF_KRB5KEYTAB },
{ "REP_TRIES", CONF_REP_TRIES },
{ "REQ_TRIES", CONF_REQ_TRIES },
{ "CLIENT", CONF_CLIENT },
+ { "DEBUG_DAYS", CONF_DEBUG_DAYS },
{ "DEBUG_AMANDAD", CONF_DEBUG_AMANDAD },
+ { "DEBUG_RECOVERY", CONF_DEBUG_RECOVERY },
{ "DEBUG_AMIDXTAPED", CONF_DEBUG_AMIDXTAPED },
{ "DEBUG_AMINDEXD", CONF_DEBUG_AMINDEXD },
{ "DEBUG_AMRECOVER", CONF_DEBUG_AMRECOVER },
{ "DEFINE", CONF_DEFINE },
{ "COMMENT", CONF_COMMENT },
{ "MAILER", CONF_MAILER },
- { "SCRIPT", CONF_PP_SCRIPT },
- { "SCRIPT_TOOL", CONF_PP_SCRIPT_TOOL },
+ { "ORDER", CONF_ORDER },
+ { "SCRIPT", CONF_SCRIPT },
+ { "SCRIPT_TOOL", CONF_SCRIPT_TOOL },
{ "PLUGIN", CONF_PLUGIN },
+ { "PRE_AMCHECK", CONF_PRE_AMCHECK },
{ "PRE_DLE_AMCHECK", CONF_PRE_DLE_AMCHECK },
{ "PRE_HOST_AMCHECK", CONF_PRE_HOST_AMCHECK },
+ { "POST_AMCHECK", CONF_POST_AMCHECK },
{ "POST_DLE_AMCHECK", CONF_POST_DLE_AMCHECK },
{ "POST_HOST_AMCHECK", CONF_POST_HOST_AMCHECK },
+ { "PRE_ESTIMATE", CONF_PRE_ESTIMATE },
{ "PRE_DLE_ESTIMATE", CONF_PRE_DLE_ESTIMATE },
{ "PRE_HOST_ESTIMATE", CONF_PRE_HOST_ESTIMATE },
+ { "POST_ESTIMATE", CONF_POST_ESTIMATE },
{ "POST_DLE_ESTIMATE", CONF_POST_DLE_ESTIMATE },
{ "POST_HOST_ESTIMATE", CONF_POST_HOST_ESTIMATE },
+ { "POST_BACKUP", CONF_POST_BACKUP },
{ "POST_DLE_BACKUP", CONF_POST_DLE_BACKUP },
{ "POST_HOST_BACKUP", CONF_POST_HOST_BACKUP },
+ { "PRE_BACKUP", CONF_PRE_BACKUP },
{ "PRE_DLE_BACKUP", CONF_PRE_DLE_BACKUP },
{ "PRE_HOST_BACKUP", CONF_PRE_HOST_BACKUP },
{ "PRE_RECOVER", CONF_PRE_RECOVER },
keytab_t server_keytab[] = {
{ "ALL", CONF_ALL },
+ { "ALLOW_SPLIT", CONF_ALLOW_SPLIT },
+ { "AMANDA", CONF_AMANDA },
{ "AMANDAD_PATH", CONF_AMANDAD_PATH },
{ "AMRECOVER_CHANGER", CONF_AMRECOVER_CHANGER },
{ "AMRECOVER_CHECK_LABEL", CONF_AMRECOVER_CHECK_LABEL },
{ "AMRECOVER_DO_FSF", CONF_AMRECOVER_DO_FSF },
+ { "ANY", CONF_ANY_VOLUME },
{ "APPEND", CONF_APPEND },
{ "AUTH", CONF_AUTH },
{ "AUTO", CONF_AUTO },
{ "AUTOFLUSH", CONF_AUTOFLUSH },
+ { "AUTOLABEL", CONF_AUTOLABEL },
{ "APPLICATION", CONF_APPLICATION },
{ "APPLICATION_TOOL", CONF_APPLICATION_TOOL },
{ "BEST", CONF_BEST },
{ "CLIENT_CUSTOM_COMPRESS", CONF_CLNTCOMPPROG },
{ "CLIENT_DECRYPT_OPTION", CONF_CLNT_DECRYPT_OPT },
{ "CLIENT_ENCRYPT", CONF_CLNT_ENCRYPT },
+ { "CLIENT_NAME", CONF_CLIENT_NAME },
{ "CLIENT_USERNAME", CONF_CLIENT_USERNAME },
{ "COLUMNSPEC", CONF_COLUMNSPEC },
{ "COMMENT", CONF_COMMENT },
{ "CONNECT_TRIES", CONF_CONNECT_TRIES },
{ "CTIMEOUT", CONF_CTIMEOUT },
{ "CUSTOM", CONF_CUSTOM },
+ { "DATA_PATH", CONF_DATA_PATH },
+ { "DEBUG_DAYS" , CONF_DEBUG_DAYS },
{ "DEBUG_AMANDAD" , CONF_DEBUG_AMANDAD },
+ { "DEBUG_RECOVERY" , CONF_DEBUG_RECOVERY },
{ "DEBUG_AMIDXTAPED" , CONF_DEBUG_AMIDXTAPED },
{ "DEBUG_AMINDEXD" , CONF_DEBUG_AMINDEXD },
{ "DEBUG_AMRECOVER" , CONF_DEBUG_AMRECOVER },
{ "DEVICE", CONF_DEVICE },
{ "DEVICE_PROPERTY", CONF_DEVICE_PROPERTY },
{ "DIRECTORY", CONF_DIRECTORY },
+ { "DIRECTTCP", CONF_DIRECTTCP },
+ { "DISK", CONF_DISK },
{ "DISKFILE", CONF_DISKFILE },
{ "DISPLAYUNIT", CONF_DISPLAYUNIT },
{ "DTIMEOUT", CONF_DTIMEOUT },
{ "DUMPORDER", CONF_DUMPORDER },
{ "DUMPTYPE", CONF_DUMPTYPE },
{ "DUMPUSER", CONF_DUMPUSER },
+ { "DUMP_LIMIT", CONF_DUMP_LIMIT },
+ { "EJECT_VOLUME", CONF_EJECT_VOLUME },
+ { "EMPTY", CONF_EMPTY },
{ "ENCRYPT", CONF_ENCRYPT },
{ "ERROR", CONF_ERROR },
{ "ESTIMATE", CONF_ESTIMATE },
{ "FALLBACK_SPLITSIZE", CONF_FALLBACK_SPLITSIZE },
{ "FAST", CONF_FAST },
{ "FILE", CONF_EFILE },
- { "FILE_PAD", CONF_FILE_PAD },
{ "FILEMARK", CONF_FILEMARK },
{ "FIRST", CONF_FIRST },
{ "FIRSTFIT", CONF_FIRSTFIT },
{ "INDEXDIR", CONF_INDEXDIR },
{ "INFOFILE", CONF_INFOFILE },
{ "INPARALLEL", CONF_INPARALLEL },
+ { "INTERACTIVITY", CONF_INTERACTIVITY },
{ "INTERFACE", CONF_INTERFACE },
{ "KENCRYPT", CONF_KENCRYPT },
{ "KRB5KEYTAB", CONF_KRB5KEYTAB },
{ "MAILER", CONF_MAILER },
{ "MAILTO", CONF_MAILTO },
{ "READBLOCKSIZE", CONF_READBLOCKSIZE },
+ { "MAX_DLE_BY_VOLUME", CONF_MAX_DLE_BY_VOLUME },
{ "MAXDUMPS", CONF_MAXDUMPS },
{ "MAXDUMPSIZE", CONF_MAXDUMPSIZE },
{ "MAXPROMOTEDAY", CONF_MAXPROMOTEDAY },
+ { "MAX_WARNINGS", CONF_MAX_WARNINGS },
+ { "MEMORY", CONF_MEMORY },
{ "MEDIUM", CONF_MEDIUM },
+ { "META_AUTOLABEL", CONF_META_AUTOLABEL },
{ "NETUSAGE", CONF_NETUSAGE },
{ "NEVER", CONF_NEVER },
{ "NOFULL", CONF_NOFULL },
{ "NOINC", CONF_NOINC },
{ "NONE", CONF_NONE },
+ { "NON_AMANDA", CONF_NON_AMANDA },
{ "OPTIONAL", CONF_OPTIONAL },
+ { "ORDER", CONF_ORDER },
{ "ORG", CONF_ORG },
+ { "OTHER_CONFIG", CONF_OTHER_CONFIG },
+ { "PART_CACHE_DIR", CONF_PART_CACHE_DIR },
+ { "PART_CACHE_MAX_SIZE", CONF_PART_CACHE_MAX_SIZE },
+ { "PART_CACHE_TYPE", CONF_PART_CACHE_TYPE },
+ { "PART_SIZE", CONF_PART_SIZE },
{ "PLUGIN", CONF_PLUGIN },
+ { "PRE_AMCHECK", CONF_PRE_AMCHECK },
{ "PRE_DLE_AMCHECK", CONF_PRE_DLE_AMCHECK },
{ "PRE_HOST_AMCHECK", CONF_PRE_HOST_AMCHECK },
+ { "POST_AMCHECK", CONF_POST_AMCHECK },
{ "POST_DLE_AMCHECK", CONF_POST_DLE_AMCHECK },
{ "POST_HOST_AMCHECK", CONF_POST_HOST_AMCHECK },
+ { "PRE_ESTIMATE", CONF_PRE_ESTIMATE },
{ "PRE_DLE_ESTIMATE", CONF_PRE_DLE_ESTIMATE },
{ "PRE_HOST_ESTIMATE", CONF_PRE_HOST_ESTIMATE },
+ { "POST_ESTIMATE", CONF_POST_ESTIMATE },
{ "POST_DLE_ESTIMATE", CONF_POST_DLE_ESTIMATE },
{ "POST_HOST_ESTIMATE", CONF_POST_HOST_ESTIMATE },
+ { "POST_BACKUP", CONF_POST_BACKUP },
{ "POST_DLE_BACKUP", CONF_POST_DLE_BACKUP },
{ "POST_HOST_BACKUP", CONF_POST_HOST_BACKUP },
+ { "PRE_BACKUP", CONF_PRE_BACKUP },
{ "PRE_DLE_BACKUP", CONF_PRE_DLE_BACKUP },
{ "PRE_HOST_BACKUP", CONF_PRE_HOST_BACKUP },
{ "PRE_RECOVER", CONF_PRE_RECOVER },
{ "PROGRAM", CONF_PROGRAM },
{ "PROPERTY", CONF_PROPERTY },
{ "RECORD", CONF_RECORD },
+ { "RECOVERY_LIMIT", CONF_RECOVERY_LIMIT },
{ "REP_TRIES", CONF_REP_TRIES },
+ { "REPORT_USE_MEDIA", CONF_REPORT_USE_MEDIA },
+ { "REPORT_NEXT_MEDIA", CONF_REPORT_NEXT_MEDIA },
{ "REQ_TRIES", CONF_REQ_TRIES },
{ "REQUIRED", CONF_REQUIRED },
{ "RESERVE", CONF_RESERVE },
{ "RESERVED_TCP_PORT", CONF_RESERVED_TCP_PORT },
{ "RUNSPERCYCLE", CONF_RUNSPERCYCLE },
{ "RUNTAPES", CONF_RUNTAPES },
- { "SCRIPT", CONF_PP_SCRIPT },
- { "SCRIPT_TOOL", CONF_PP_SCRIPT_TOOL },
+ { "SAME_HOST", CONF_SAME_HOST },
+ { "SCRIPT", CONF_SCRIPT },
+ { "SCRIPT_TOOL", CONF_SCRIPT_TOOL },
{ "SEND_AMREPORT_ON", CONF_SEND_AMREPORT_ON },
+ { "CLIENT_PORT", CONF_CLIENT_PORT },
{ "SERVER", CONF_SERVER },
{ "SERVER_CUSTOM_COMPRESS", CONF_SRVCOMPPROG },
{ "SERVER_DECRYPT_OPTION", CONF_SRV_DECRYPT_OPT },
{ "SKIP", CONF_SKIP },
{ "SKIP_FULL", CONF_SKIP_FULL },
{ "SKIP_INCR", CONF_SKIP_INCR },
+ { "SINGLE_EXECUTION", CONF_SINGLE_EXECUTION },
{ "SMALLEST", CONF_SMALLEST },
{ "SPEED", CONF_SPEED },
{ "SPLIT_DISKBUFFER", CONF_SPLIT_DISKBUFFER },
{ "STARTTIME", CONF_STARTTIME },
{ "STRANGE", CONF_STRANGE },
{ "STRATEGY", CONF_STRATEGY },
- { "TAPEBUFS", CONF_TAPEBUFS },
{ "DEVICE_OUTPUT_BUFFER_SIZE", CONF_DEVICE_OUTPUT_BUFFER_SIZE },
{ "TAPECYCLE", CONF_TAPECYCLE },
{ "TAPEDEV", CONF_TAPEDEV },
- { "RAWTAPEDEV", CONF_RAWTAPEDEV },
{ "TAPELIST", CONF_TAPELIST },
{ "TAPERALGO", CONF_TAPERALGO },
+ { "TAPERSCAN", CONF_TAPERSCAN },
+ { "TAPER_PARALLEL_WRITE", CONF_TAPER_PARALLEL_WRITE },
{ "FLUSH_THRESHOLD_DUMPED", CONF_FLUSH_THRESHOLD_DUMPED },
{ "FLUSH_THRESHOLD_SCHEDULED", CONF_FLUSH_THRESHOLD_SCHEDULED },
{ "TAPERFLUSH", CONF_TAPERFLUSH },
{ "TAPETYPE", CONF_TAPETYPE },
{ "TAPE_SPLITSIZE", CONF_TAPE_SPLITSIZE },
+ { "TMPDIR", CONF_TMPDIR },
{ "TPCHANGER", CONF_TPCHANGER },
{ "UNRESERVED_TCP_PORT", CONF_UNRESERVED_TCP_PORT },
{ "USE", CONF_USE },
{ "USETIMESTAMPS", CONF_USETIMESTAMPS },
+ { "VOLUME_ERROR", CONF_VOLUME_ERROR },
{ NULL, CONF_IDENT },
{ NULL, CONF_UNKNOWN }
};
{ "GIG", CONF_MULT1G },
{ "GIGABYTE", CONF_MULT1G },
{ "GIGABYTES", CONF_MULT1G },
+ { "T", CONF_MULT1T },
+ { "TB", CONF_MULT1T },
+ { "TBPS", CONF_MULT1T },
+ { "TBYTE", CONF_MULT1T },
+ { "TBYTES", CONF_MULT1T },
+ { "TERA", CONF_MULT1T },
+ { "TERABYTE", CONF_MULT1T },
+ { "TERABYTES", CONF_MULT1T },
{ "MPS", CONF_MULT1M },
{ "TAPE", CONF_MULT1 },
{ "TAPES", CONF_MULT1 },
{ NULL, CONF_IDENT }
};
+/* no_yes_all keywords -- all the ways to say "true" and "false" in amanda.conf */
+keytab_t no_yes_all_keytable[] = {
+ { "Y", CONF_ATRUE },
+ { "YES", CONF_ATRUE },
+ { "T", CONF_ATRUE },
+ { "TRUE", CONF_ATRUE },
+ { "ON", CONF_ATRUE },
+ { "N", CONF_AFALSE },
+ { "NO", CONF_AFALSE },
+ { "F", CONF_AFALSE },
+ { "FALSE", CONF_AFALSE },
+ { "OFF", CONF_AFALSE },
+ { "ALL", CONF_ALL },
+ { NULL, CONF_IDENT }
+};
+
/* Now, the parser tables for client and server global parameters, and for
* each of the server subsections */
conf_var_t client_var [] = {
{ CONF_CONF , CONFTYPE_STR , read_str , CNF_CONF , NULL },
+ { CONF_AMDUMP_SERVER , CONFTYPE_STR , read_str , CNF_AMDUMP_SERVER , NULL },
{ CONF_INDEX_SERVER , CONFTYPE_STR , read_str , CNF_INDEX_SERVER , NULL },
{ CONF_TAPE_SERVER , CONFTYPE_STR , read_str , CNF_TAPE_SERVER , NULL },
{ CONF_TAPEDEV , CONFTYPE_STR , read_str , CNF_TAPEDEV , NULL },
{ CONF_SSH_KEYS , CONFTYPE_STR , read_str , CNF_SSH_KEYS , NULL },
{ CONF_AMANDAD_PATH , CONFTYPE_STR , read_str , CNF_AMANDAD_PATH , NULL },
{ CONF_CLIENT_USERNAME , CONFTYPE_STR , read_str , CNF_CLIENT_USERNAME , NULL },
+ { CONF_CLIENT_PORT , CONFTYPE_STR , read_int_or_str, CNF_CLIENT_PORT , NULL },
{ CONF_GNUTAR_LIST_DIR , CONFTYPE_STR , read_str , CNF_GNUTAR_LIST_DIR , NULL },
{ CONF_AMANDATES , CONFTYPE_STR , read_str , CNF_AMANDATES , NULL },
{ CONF_MAILER , CONFTYPE_STR , read_str , CNF_MAILER , NULL },
{ CONF_CONNECT_TRIES , CONFTYPE_INT , read_int , CNF_CONNECT_TRIES , validate_positive },
{ CONF_REP_TRIES , CONFTYPE_INT , read_int , CNF_REP_TRIES , validate_positive },
{ CONF_REQ_TRIES , CONFTYPE_INT , read_int , CNF_REQ_TRIES , validate_positive },
+ { CONF_DEBUG_DAYS , CONFTYPE_INT , read_int , CNF_DEBUG_DAYS , NULL },
{ CONF_DEBUG_AMANDAD , CONFTYPE_INT , read_int , CNF_DEBUG_AMANDAD , validate_debug },
+ { CONF_DEBUG_RECOVERY , CONFTYPE_INT , read_int , CNF_DEBUG_RECOVERY , validate_debug },
{ CONF_DEBUG_AMIDXTAPED , CONFTYPE_INT , read_int , CNF_DEBUG_AMIDXTAPED , validate_debug },
{ CONF_DEBUG_AMINDEXD , CONFTYPE_INT , read_int , CNF_DEBUG_AMINDEXD , validate_debug },
{ CONF_DEBUG_AMRECOVER , CONFTYPE_INT , read_int , CNF_DEBUG_AMRECOVER , validate_debug },
{ CONF_UNRESERVED_TCP_PORT, CONFTYPE_INTRANGE, read_intrange, CNF_UNRESERVED_TCP_PORT, validate_unreserved_port_range },
{ CONF_PROPERTY , CONFTYPE_PROPLIST, read_property, CNF_PROPERTY , NULL },
{ CONF_APPLICATION , CONFTYPE_STR , read_dapplication, DUMPTYPE_APPLICATION, NULL },
- { CONF_PP_SCRIPT , CONFTYPE_STR , read_dpp_script, DUMPTYPE_PP_SCRIPTLIST, NULL },
+ { CONF_SCRIPT , CONFTYPE_STR , read_dpp_script, DUMPTYPE_SCRIPTLIST, NULL },
{ CONF_UNKNOWN , CONFTYPE_INT , NULL , CNF_CNF , NULL }
};
{ CONF_PRINTER , CONFTYPE_STR , read_str , CNF_PRINTER , NULL },
{ CONF_MAILER , CONFTYPE_STR , read_str , CNF_MAILER , NULL },
{ CONF_TAPEDEV , CONFTYPE_STR , read_str , CNF_TAPEDEV , NULL },
- { CONF_RAWTAPEDEV , CONFTYPE_STR , read_str , CNF_RAWTAPEDEV , NULL },
{ CONF_DEVICE_PROPERTY , CONFTYPE_PROPLIST , read_property , CNF_DEVICE_PROPERTY , NULL },
{ CONF_PROPERTY , CONFTYPE_PROPLIST , read_property , CNF_PROPERTY , NULL },
{ CONF_TPCHANGER , CONFTYPE_STR , read_str , CNF_TPCHANGER , NULL },
{ CONF_LOGDIR , CONFTYPE_STR , read_str , CNF_LOGDIR , NULL },
{ CONF_INDEXDIR , CONFTYPE_STR , read_str , CNF_INDEXDIR , NULL },
{ CONF_TAPETYPE , CONFTYPE_IDENT , read_ident , CNF_TAPETYPE , NULL },
+ { CONF_HOLDING , CONFTYPE_IDENTLIST, read_holdingdisk , CNF_HOLDINGDISK , NULL },
{ CONF_DUMPCYCLE , CONFTYPE_INT , read_int , CNF_DUMPCYCLE , validate_nonnegative },
{ CONF_RUNSPERCYCLE , CONFTYPE_INT , read_int , CNF_RUNSPERCYCLE , validate_runspercycle },
{ CONF_RUNTAPES , CONFTYPE_INT , read_int , CNF_RUNTAPES , validate_nonnegative },
{ CONF_INPARALLEL , CONFTYPE_INT , read_int , CNF_INPARALLEL , validate_inparallel },
{ CONF_DUMPORDER , CONFTYPE_STR , read_str , CNF_DUMPORDER , NULL },
{ CONF_MAXDUMPS , CONFTYPE_INT , read_int , CNF_MAXDUMPS , validate_positive },
- { CONF_ETIMEOUT , CONFTYPE_INT , read_int , CNF_ETIMEOUT , NULL },
+ { CONF_MAX_DLE_BY_VOLUME , CONFTYPE_INT , read_int , CNF_MAX_DLE_BY_VOLUME , validate_positive },
+ { CONF_ETIMEOUT , CONFTYPE_INT , read_int , CNF_ETIMEOUT , validate_non_zero },
{ CONF_DTIMEOUT , CONFTYPE_INT , read_int , CNF_DTIMEOUT , validate_positive },
{ CONF_CTIMEOUT , CONFTYPE_INT , read_int , CNF_CTIMEOUT , validate_positive },
- { CONF_TAPEBUFS , CONFTYPE_INT , read_int , CNF_TAPEBUFS , validate_positive },
{ CONF_DEVICE_OUTPUT_BUFFER_SIZE, CONFTYPE_SIZE , read_size , CNF_DEVICE_OUTPUT_BUFFER_SIZE, validate_positive },
{ CONF_COLUMNSPEC , CONFTYPE_STR , read_str , CNF_COLUMNSPEC , NULL },
{ CONF_TAPERALGO , CONFTYPE_TAPERALGO, read_taperalgo , CNF_TAPERALGO , NULL },
+ { CONF_TAPER_PARALLEL_WRITE , CONFTYPE_INT , read_int , CNF_TAPER_PARALLEL_WRITE , NULL },
{ CONF_SEND_AMREPORT_ON , CONFTYPE_SEND_AMREPORT_ON, read_send_amreport_on, CNF_SEND_AMREPORT_ON , NULL },
{ CONF_FLUSH_THRESHOLD_DUMPED, CONFTYPE_INT , read_int , CNF_FLUSH_THRESHOLD_DUMPED, validate_nonnegative },
{ CONF_FLUSH_THRESHOLD_SCHEDULED, CONFTYPE_INT , read_int , CNF_FLUSH_THRESHOLD_SCHEDULED, validate_nonnegative },
{ CONF_TAPERFLUSH , CONFTYPE_INT , read_int , CNF_TAPERFLUSH , validate_nonnegative },
{ CONF_DISPLAYUNIT , CONFTYPE_STR , read_str , CNF_DISPLAYUNIT , validate_displayunit },
- { CONF_AUTOFLUSH , CONFTYPE_BOOLEAN , read_bool , CNF_AUTOFLUSH , NULL },
+ { CONF_AUTOFLUSH , CONFTYPE_NO_YES_ALL,read_no_yes_all , CNF_AUTOFLUSH , NULL },
{ CONF_RESERVE , CONFTYPE_INT , read_int , CNF_RESERVE , validate_reserve },
{ CONF_MAXDUMPSIZE , CONFTYPE_INT64 , read_int64 , CNF_MAXDUMPSIZE , NULL },
{ CONF_KRB5KEYTAB , CONFTYPE_STR , read_str , CNF_KRB5KEYTAB , NULL },
{ CONF_KRB5PRINCIPAL , CONFTYPE_STR , read_str , CNF_KRB5PRINCIPAL , NULL },
{ CONF_LABEL_NEW_TAPES , CONFTYPE_STR , read_str , CNF_LABEL_NEW_TAPES , NULL },
+ { CONF_AUTOLABEL , CONFTYPE_AUTOLABEL, read_autolabel , CNF_AUTOLABEL , NULL },
+ { CONF_META_AUTOLABEL , CONFTYPE_STR , read_str , CNF_META_AUTOLABEL , NULL },
+ { CONF_EJECT_VOLUME , CONFTYPE_BOOLEAN , read_bool , CNF_EJECT_VOLUME , NULL },
+ { CONF_TMPDIR , CONFTYPE_STR , read_str , CNF_TMPDIR , validate_tmpdir },
{ CONF_USETIMESTAMPS , CONFTYPE_BOOLEAN , read_bool , CNF_USETIMESTAMPS , NULL },
{ CONF_AMRECOVER_DO_FSF , CONFTYPE_BOOLEAN , read_bool , CNF_AMRECOVER_DO_FSF , NULL },
{ CONF_AMRECOVER_CHANGER , CONFTYPE_STR , read_str , CNF_AMRECOVER_CHANGER , NULL },
{ CONF_CONNECT_TRIES , CONFTYPE_INT , read_int , CNF_CONNECT_TRIES , validate_positive },
{ CONF_REP_TRIES , CONFTYPE_INT , read_int , CNF_REP_TRIES , validate_positive },
{ CONF_REQ_TRIES , CONFTYPE_INT , read_int , CNF_REQ_TRIES , validate_positive },
+ { CONF_DEBUG_DAYS , CONFTYPE_INT , read_int , CNF_DEBUG_DAYS , NULL },
{ CONF_DEBUG_AMANDAD , CONFTYPE_INT , read_int , CNF_DEBUG_AMANDAD , validate_debug },
+ { CONF_DEBUG_RECOVERY , CONFTYPE_INT , read_int , CNF_DEBUG_RECOVERY , validate_debug },
{ CONF_DEBUG_AMIDXTAPED , CONFTYPE_INT , read_int , CNF_DEBUG_AMIDXTAPED , validate_debug },
{ CONF_DEBUG_AMINDEXD , CONFTYPE_INT , read_int , CNF_DEBUG_AMINDEXD , validate_debug },
{ CONF_DEBUG_AMRECOVER , CONFTYPE_INT , read_int , CNF_DEBUG_AMRECOVER , validate_debug },
{ CONF_RESERVED_UDP_PORT , CONFTYPE_INTRANGE , read_intrange , CNF_RESERVED_UDP_PORT , validate_reserved_port_range },
{ CONF_RESERVED_TCP_PORT , CONFTYPE_INTRANGE , read_intrange , CNF_RESERVED_TCP_PORT , validate_reserved_port_range },
{ CONF_UNRESERVED_TCP_PORT , CONFTYPE_INTRANGE , read_intrange , CNF_UNRESERVED_TCP_PORT , validate_unreserved_port_range },
+ { CONF_RECOVERY_LIMIT , CONFTYPE_HOST_LIMIT, read_host_limit , CNF_RECOVERY_LIMIT , NULL },
+ { CONF_INTERACTIVITY , CONFTYPE_STR , read_dinteractivity, CNF_INTERACTIVITY , NULL },
+ { CONF_TAPERSCAN , CONFTYPE_STR , read_dtaperscan , CNF_TAPERSCAN , NULL },
+ { CONF_REPORT_USE_MEDIA , CONFTYPE_BOOLEAN , read_bool , CNF_REPORT_USE_MEDIA , NULL },
+ { CONF_REPORT_NEXT_MEDIA , CONFTYPE_BOOLEAN , read_bool , CNF_REPORT_NEXT_MEDIA , NULL },
{ CONF_UNKNOWN , CONFTYPE_INT , NULL , CNF_CNF , NULL }
};
conf_var_t tapetype_var [] = {
- { CONF_COMMENT , CONFTYPE_STR , read_str , TAPETYPE_COMMENT , NULL },
- { CONF_LBL_TEMPL , CONFTYPE_STR , read_str , TAPETYPE_LBL_TEMPL , NULL },
- { CONF_BLOCKSIZE , CONFTYPE_SIZE , read_size , TAPETYPE_BLOCKSIZE , validate_blocksize },
- { CONF_READBLOCKSIZE , CONFTYPE_SIZE , read_size , TAPETYPE_READBLOCKSIZE, validate_blocksize },
- { CONF_LENGTH , CONFTYPE_INT64 , read_int64 , TAPETYPE_LENGTH , validate_nonnegative },
- { CONF_FILEMARK , CONFTYPE_INT64 , read_int64 , TAPETYPE_FILEMARK , NULL },
- { CONF_SPEED , CONFTYPE_INT , read_int , TAPETYPE_SPEED , validate_nonnegative },
- { CONF_FILE_PAD , CONFTYPE_BOOLEAN , read_bool , TAPETYPE_FILE_PAD , NULL },
- { CONF_UNKNOWN , CONFTYPE_INT , NULL , TAPETYPE_TAPETYPE , NULL }
+ { CONF_COMMENT , CONFTYPE_STR , read_str , TAPETYPE_COMMENT , NULL },
+ { CONF_LBL_TEMPL , CONFTYPE_STR , read_str , TAPETYPE_LBL_TEMPL , NULL },
+ { CONF_BLOCKSIZE , CONFTYPE_SIZE , read_size , TAPETYPE_BLOCKSIZE , validate_blocksize },
+ { CONF_READBLOCKSIZE , CONFTYPE_SIZE , read_size , TAPETYPE_READBLOCKSIZE , validate_blocksize },
+ { CONF_LENGTH , CONFTYPE_INT64 , read_int64 , TAPETYPE_LENGTH , validate_nonnegative },
+ { CONF_FILEMARK , CONFTYPE_INT64 , read_int64 , TAPETYPE_FILEMARK , NULL },
+ { CONF_SPEED , CONFTYPE_INT , read_int , TAPETYPE_SPEED , validate_nonnegative },
+ { CONF_PART_SIZE , CONFTYPE_INT64 , read_int64 , TAPETYPE_PART_SIZE , validate_nonnegative },
+ { CONF_PART_CACHE_TYPE , CONFTYPE_PART_CACHE_TYPE, read_part_cache_type, TAPETYPE_PART_CACHE_TYPE, NULL },
+ { CONF_PART_CACHE_DIR , CONFTYPE_STR , read_str , TAPETYPE_PART_CACHE_DIR , NULL },
+ { CONF_PART_CACHE_MAX_SIZE , CONFTYPE_INT64 , read_int64 , TAPETYPE_PART_CACHE_MAX_SIZE, validate_nonnegative },
+ { CONF_UNKNOWN , CONFTYPE_INT , NULL , TAPETYPE_TAPETYPE , NULL }
};
conf_var_t dumptype_var [] = {
{ CONF_COMMENT , CONFTYPE_STR , read_str , DUMPTYPE_COMMENT , NULL },
- { CONF_AUTH , CONFTYPE_STR , read_str , DUMPTYPE_SECURITY_DRIVER , NULL },
+ { CONF_AUTH , CONFTYPE_STR , read_str , DUMPTYPE_AUTH , NULL },
{ CONF_BUMPDAYS , CONFTYPE_INT , read_int , DUMPTYPE_BUMPDAYS , NULL },
{ CONF_BUMPMULT , CONFTYPE_REAL , read_real , DUMPTYPE_BUMPMULT , NULL },
{ CONF_BUMPSIZE , CONFTYPE_INT64 , read_int64 , DUMPTYPE_BUMPSIZE , NULL },
{ CONF_STRATEGY , CONFTYPE_INT , read_strategy , DUMPTYPE_STRATEGY , NULL },
{ CONF_TAPE_SPLITSIZE , CONFTYPE_INT64 , read_int64 , DUMPTYPE_TAPE_SPLITSIZE , validate_nonnegative },
{ CONF_SPLIT_DISKBUFFER , CONFTYPE_STR , read_str , DUMPTYPE_SPLIT_DISKBUFFER , NULL },
- { CONF_ESTIMATE , CONFTYPE_INT , read_estimate , DUMPTYPE_ESTIMATE , NULL },
+ { CONF_ESTIMATE , CONFTYPE_ESTIMATELIST, read_estimatelist , DUMPTYPE_ESTIMATELIST , NULL },
{ CONF_SRV_ENCRYPT , CONFTYPE_STR , read_str , DUMPTYPE_SRV_ENCRYPT , NULL },
{ CONF_CLNT_ENCRYPT , CONFTYPE_STR , read_str , DUMPTYPE_CLNT_ENCRYPT , NULL },
{ CONF_AMANDAD_PATH , CONFTYPE_STR , read_str , DUMPTYPE_AMANDAD_PATH , NULL },
{ CONF_CLIENT_USERNAME , CONFTYPE_STR , read_str , DUMPTYPE_CLIENT_USERNAME , NULL },
+ { CONF_CLIENT_PORT , CONFTYPE_STR , read_int_or_str, DUMPTYPE_CLIENT_PORT , NULL },
{ CONF_SSH_KEYS , CONFTYPE_STR , read_str , DUMPTYPE_SSH_KEYS , NULL },
{ CONF_SRVCOMPPROG , CONFTYPE_STR , read_str , DUMPTYPE_SRVCOMPPROG , NULL },
{ CONF_CLNTCOMPPROG , CONFTYPE_STR , read_str , DUMPTYPE_CLNTCOMPPROG , NULL },
{ CONF_SRV_DECRYPT_OPT , CONFTYPE_STR , read_str , DUMPTYPE_SRV_DECRYPT_OPT , NULL },
{ CONF_CLNT_DECRYPT_OPT , CONFTYPE_STR , read_str , DUMPTYPE_CLNT_DECRYPT_OPT , NULL },
{ CONF_APPLICATION , CONFTYPE_STR , read_dapplication, DUMPTYPE_APPLICATION , NULL },
- { CONF_PP_SCRIPT , CONFTYPE_STR , read_dpp_script, DUMPTYPE_PP_SCRIPTLIST , NULL },
+ { CONF_SCRIPT , CONFTYPE_STR , read_dpp_script, DUMPTYPE_SCRIPTLIST , NULL },
+ { CONF_DATA_PATH , CONFTYPE_DATA_PATH, read_data_path, DUMPTYPE_DATA_PATH , NULL },
+ { CONF_ALLOW_SPLIT , CONFTYPE_BOOLEAN , read_bool , DUMPTYPE_ALLOW_SPLIT , NULL },
+ { CONF_MAX_WARNINGS , CONFTYPE_INT , read_int , DUMPTYPE_MAX_WARNINGS , validate_nonnegative },
+ { CONF_RECOVERY_LIMIT , CONFTYPE_HOST_LIMIT, read_host_limit, DUMPTYPE_RECOVERY_LIMIT , NULL },
+ { CONF_DUMP_LIMIT , CONFTYPE_HOST_LIMIT, read_host_limit, DUMPTYPE_DUMP_LIMIT , validate_dump_limit },
{ CONF_UNKNOWN , CONFTYPE_INT , NULL , DUMPTYPE_DUMPTYPE , NULL }
};
{ CONF_COMMENT , CONFTYPE_STR , read_str , APPLICATION_COMMENT , NULL },
{ CONF_PLUGIN , CONFTYPE_STR , read_str , APPLICATION_PLUGIN , NULL },
{ CONF_PROPERTY , CONFTYPE_PROPLIST, read_property, APPLICATION_PROPERTY , NULL },
+ { CONF_CLIENT_NAME, CONFTYPE_STR , read_str , APPLICATION_CLIENT_NAME, NULL },
{ CONF_UNKNOWN , CONFTYPE_INT , NULL , APPLICATION_APPLICATION, NULL }
};
{ CONF_PROPERTY , CONFTYPE_PROPLIST, read_property, PP_SCRIPT_PROPERTY , NULL },
{ CONF_EXECUTE_ON , CONFTYPE_EXECUTE_ON , read_execute_on , PP_SCRIPT_EXECUTE_ON , NULL },
{ CONF_EXECUTE_WHERE, CONFTYPE_EXECUTE_WHERE , read_execute_where , PP_SCRIPT_EXECUTE_WHERE, NULL },
+ { CONF_ORDER , CONFTYPE_INT , read_int , PP_SCRIPT_ORDER , NULL },
+ { CONF_SINGLE_EXECUTION, CONFTYPE_BOOLEAN, read_bool , PP_SCRIPT_SINGLE_EXECUTION, NULL },
+ { CONF_CLIENT_NAME , CONFTYPE_STR , read_str , PP_SCRIPT_CLIENT_NAME , NULL },
{ CONF_UNKNOWN , CONFTYPE_INT , NULL , PP_SCRIPT_PP_SCRIPT , NULL }
};
{ CONF_TPCHANGER , CONFTYPE_STR , read_str , CHANGER_CONFIG_TPCHANGER , NULL },
{ CONF_CHANGERDEV , CONFTYPE_STR , read_str , CHANGER_CONFIG_CHANGERDEV , NULL },
{ CONF_CHANGERFILE , CONFTYPE_STR , read_str , CHANGER_CONFIG_CHANGERFILE , NULL },
+ { CONF_PROPERTY , CONFTYPE_PROPLIST , read_property , CHANGER_CONFIG_PROPERTY , NULL },
+ { CONF_DEVICE_PROPERTY , CONFTYPE_PROPLIST , read_property , CHANGER_CONFIG_DEVICE_PROPERTY, NULL },
{ CONF_UNKNOWN , CONFTYPE_INT , NULL , CHANGER_CONFIG_CHANGER_CONFIG , NULL }
};
+conf_var_t interactivity_var [] = {
+ { CONF_COMMENT , CONFTYPE_STR , read_str , INTERACTIVITY_COMMENT , NULL },
+ { CONF_PLUGIN , CONFTYPE_STR , read_str , INTERACTIVITY_PLUGIN , NULL },
+ { CONF_PROPERTY , CONFTYPE_PROPLIST , read_property , INTERACTIVITY_PROPERTY , NULL },
+ { CONF_UNKNOWN , CONFTYPE_INT , NULL , INTERACTIVITY_INTERACTIVITY , NULL }
+};
+
+conf_var_t taperscan_var [] = {
+ { CONF_COMMENT , CONFTYPE_STR , read_str , TAPERSCAN_COMMENT , NULL },
+ { CONF_PLUGIN , CONFTYPE_STR , read_str , TAPERSCAN_PLUGIN , NULL },
+ { CONF_PROPERTY , CONFTYPE_PROPLIST , read_property , TAPERSCAN_PROPERTY , NULL },
+ { CONF_UNKNOWN , CONFTYPE_INT , NULL , TAPERSCAN_TAPERSCAN , NULL }
+};
+
/*
* Lexical Analysis Implementation
*/
*buf++ = (char)ch;
while (inquote && ((ch = conftoken_getc()) != EOF)) {
if (ch == '\n') {
- if (!escape)
+ if (!escape) {
+ conf_parserror(_("string not terminated"));
+ conftoken_ungetc(ch);
break;
+ }
escape = 0;
buf--; /* Consume escape in buffer */
- } else if (ch == '\\') {
+ } else if (ch == '\\' && !escape) {
escape = 1;
} else {
if (ch == '"') {
if (kwp->keyword == NULL)
str = _("token not");
else
- str = kwp->keyword;
+ str = str_keyword(kwp);
break;
}
conf_parserror(_("%s is expected"), str);
read_conffile(tokenval.v.s, is_client, FALSE);
break;
- case CONF_HOLDING:
- if (is_client) {
- handle_invalid_keyword(tokenval.v.s);
- } else {
- get_holdingdisk();
- }
- break;
-
case CONF_DEFINE:
if (is_client) {
get_conftoken(CONF_ANY);
- if(tok == CONF_APPLICATION_TOOL) get_application();
- else if(tok == CONF_PP_SCRIPT_TOOL) get_pp_script();
+ /* accept application-tool here, too, for backward compatibility */
+ if(tok == CONF_APPLICATION_TOOL || tok == CONF_APPLICATION) get_application();
+ else if(tok == CONF_SCRIPT_TOOL || tok == CONF_SCRIPT) get_pp_script();
else conf_parserror(_("APPLICATION-TOOL or SCRIPT-TOOL expected"));
} else {
get_conftoken(CONF_ANY);
if(tok == CONF_DUMPTYPE) get_dumptype();
else if(tok == CONF_TAPETYPE) get_tapetype();
else if(tok == CONF_INTERFACE) get_interface();
- else if(tok == CONF_APPLICATION_TOOL) get_application();
- else if(tok == CONF_PP_SCRIPT_TOOL) get_pp_script();
+ else if(tok == CONF_APPLICATION_TOOL || tok == CONF_APPLICATION) get_application();
+ else if(tok == CONF_SCRIPT_TOOL || tok == CONF_SCRIPT) get_pp_script();
else if(tok == CONF_DEVICE) get_device_config();
else if(tok == CONF_CHANGER) get_changer_config();
- else conf_parserror(_("DUMPTYPE, INTERFACE, TAPETYPE, APPLICATION-TOOL, SCRIPT-TOOL, DEVICE, or CHANGER expected"));
+ else if(tok == CONF_HOLDING) get_holdingdisk(1);
+ else if(tok == CONF_INTERACTIVITY) get_interactivity();
+ else if(tok == CONF_TAPERSCAN) get_taperscan();
+ else conf_parserror(_("DUMPTYPE, INTERFACE, TAPETYPE, HOLDINGDISK, APPLICATION, SCRIPT, DEVICE, CHANGER, INTERACTIVITY or TAPERSCAN expected"));
+ current_block = NULL;
}
break;
case CONF_END: /* end of file */
return 0;
+ /* These should never be at the begining of a line */
+ case CONF_LBRACE:
+ case CONF_RBRACE:
+ case CONF_IDENT:
+ case CONF_INT:
+ case CONF_INT64:
+ case CONF_BOOL:
+ case CONF_REAL:
+ case CONF_STRING:
+ case CONF_TIME:
+ case CONF_SIZE:
+ conf_parserror("error: not a keyword.");
+ break;
+
/* if it's not a known punctuation mark, then check the parse table and use the
* read_function we find there. */
default:
static void
handle_deprecated_keyword(void)
{
- tok_t *dep;
/* Procedure for deprecated keywords:
- * 1) At time of deprecation, add to warning_deprecated below.
- * Note the date of deprecation. The keyword will still be
- * parsed, and can still be used from other parts of Amanda,
- * during this time.
- * 2) After two years, move the keyword (as a string) to
+ *
+ * 1) At time of deprecation, add to warning_deprecated below. Note the
+ * version in which deprecation will expire. The keyword will still be
+ * parsed, and can still be used from other parts of Amanda, during this
+ * time.
+ * 2) After it has expired, move the keyword (as a string) to
* error_deprecated below. Remove the token (CONF_XXX) and
* config parameter (CNF_XXX) from the rest of the module.
* Note the date of the move.
*/
- static tok_t warning_deprecated[] = {
- CONF_RAWTAPEDEV, /* 2007-01-23 */
- CONF_TAPEBUFS, /* 2007-10-15 */
- CONF_FILE_PAD, /* 2008-07-01 */
- 0
- };
-
- for (dep = warning_deprecated; *dep; dep++) {
- if (tok == *dep) {
- conf_parswarn(_("warning: Keyword %s is deprecated."),
- tokenval.v.s);
+ static struct { tok_t tok; gboolean warned; }
+ warning_deprecated[] = {
+ { CONF_LABEL_NEW_TAPES, 0 }, /* exp in Amanda-3.2 */
+ { CONF_AMRECOVER_DO_FSF, 0 }, /* exp in Amanda-3.3 */
+ { CONF_AMRECOVER_CHECK_LABEL, 0 }, /* exp in Amanda-3.3 */
+ { CONF_TAPE_SPLITSIZE, 0 }, /* exp. in Amanda-3.3 */
+ { CONF_SPLIT_DISKBUFFER, 0 }, /* exp. in Amanda-3.3 */
+ { CONF_FALLBACK_SPLITSIZE, 0 }, /* exp. in Amanda-3.3 */
+ { 0, 0 },
+ }, *dep;
+
+ for (dep = warning_deprecated; dep->tok; dep++) {
+ if (tok == dep->tok) {
+ if (!dep->warned)
+ conf_parswarn(_("warning: Keyword %s is deprecated."),
+ tokenval.v.s);
+ dep->warned = 1;
+ break;
}
}
}
const char * token)
{
static const char * error_deprecated[] = {
+ "rawtapedev",
+ "tapebufs", /* deprecated: 2007-10-15; invalid: 2010-04-14 */
+ "file-pad", /* deprecated: 2008-07-01; invalid: 2010-04-14 */
NULL
};
const char ** s;
+ char *folded_token, *p;
+
+ /* convert '_' to '-' in TOKEN */
+ folded_token = g_strdup(token);
+ for (p = folded_token; *p; p++) {
+ if (*p == '_') *p = '-';
+ }
for (s = error_deprecated; *s != NULL; s ++) {
- if (strcmp(*s, token) == 0) {
+ if (g_ascii_strcasecmp(*s, folded_token) == 0) {
conf_parserror(_("error: Keyword %s is deprecated."),
token);
+ g_free(folded_token);
return;
}
}
+ g_free(folded_token);
+
if (*s == NULL) {
conf_parserror(_("configuration keyword expected"));
}
val_t *valarray,
char *errormsg,
int read_brace,
- void (*copy_function)(void))
+ void (*copy_function)(void),
+ char *type,
+ char *name)
{
conf_var_t *np;
- int done;
+ int done;
+ char *key_ovr;
+ int i;
if(read_brace) {
get_conftoken(CONF_LBRACE);
do {
current_line_num += 1;
get_conftoken(CONF_ANY);
+ handle_deprecated_keyword();
+
switch(tok) {
case CONF_RBRACE:
done = 1;
if(tok != CONF_NL && tok != CONF_END && tok != CONF_RBRACE)
get_conftoken(CONF_NL);
} while(!done);
+
+ if (!config_overrides)
+ return;
+
+ key_ovr = vstralloc(type, ":", name, NULL);
+ for (i = 0; i < config_overrides->n_used; i++) {
+ config_override_t *co = &config_overrides->ovr[i];
+ char *key = co->key;
+ char *keyword;
+ char *value;
+ keytab_t *kt;
+
+ if (key_ovr && strncasecmp(key_ovr, key, strlen(key_ovr)) != 0)
+ continue;
+
+ if (strlen(key) <= strlen(key_ovr) + 1)
+ continue;
+
+ keyword = key + strlen(key_ovr) + 1;
+ value = co->value;
+
+ /* find the token in keytable */
+ for (kt = keytable; kt->token != CONF_UNKNOWN; kt++) {
+ if (kt->keyword && strcasecmp(kt->keyword, keyword) == 0)
+ break;
+ }
+ if (kt->token == CONF_UNKNOWN)
+ continue;
+
+ /* find the var in read_var */
+ for (np = read_var; np->token != CONF_UNKNOWN; np++)
+ if (np->token == kt->token) break;
+ if (np->token == CONF_UNKNOWN)
+ continue;
+
+ /* now set up a fake line and use the relevant read_function to
+ * parse it. This is sneaky! */
+ if (np->type == CONFTYPE_STR) {
+ current_line = quote_string_always(value);
+ } else {
+ current_line = stralloc(value);
+ }
+
+ current_char = current_line;
+ token_pushed = 0;
+ current_line_num = -2;
+ allow_overwrites = 1;
+ co->applied = TRUE;
+
+ np->read_function(np, &valarray[np->parm]);
+ if (np->validate_function)
+ np->validate_function(np, &valarray[np->parm]);
+
+ amfree(current_line);
+ current_char = NULL;
+ }
+ amfree(key_ovr);
+
+}
+
+static void
+read_holdingdisk(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val G_GNUC_UNUSED)
+{
+ assert (val == &conf_data[CNF_HOLDINGDISK]);
+ get_holdingdisk(0);
}
static void
get_holdingdisk(
- void)
+ int is_define)
{
int save_overwrites;
get_conftoken(CONF_IDENT);
hdcur.name = stralloc(tokenval.v.s);
+ current_block = g_strconcat("holdingdisk ", hdcur.name, NULL);
+ hdcur.seen.block = current_block;
hdcur.seen.filename = current_filename;
hdcur.seen.linenum = current_line_num;
- read_block(holding_var, hdcur.value,
- _("holding disk parameter expected"), 1, NULL);
- get_conftoken(CONF_NL);
- save_holdingdisk();
+ get_conftoken(CONF_ANY);
+ if (tok == CONF_LBRACE) {
+ holdingdisk_t *hd;
+ hd = lookup_holdingdisk(hdcur.name);
+ if (hd) {
+ conf_parserror(_("holding disk '%s' already defined"),
+ hdcur.name);
+ } else {
+ unget_conftoken();
+ read_block(holding_var, hdcur.value,
+ _("holding disk parameter expected"), 1, copy_holdingdisk,
+ "HOLDINGDISK", hdcur.name);
+ get_conftoken(CONF_NL);
+ save_holdingdisk();
+ if (!is_define) {
+ conf_data[CNF_HOLDINGDISK].v.identlist = g_slist_append(
+ conf_data[CNF_HOLDINGDISK].v.identlist,
+ stralloc(hdcur.name));
+ }
+ }
+ } else { /* use the already defined holding disk */
+ unget_conftoken();
+ if (is_define) {
+ conf_parserror(_("holdingdisk definition must specify holdingdisk parameters"));
+ }
+ do {
+ identlist_t il;
+
+ for (il = conf_data[CNF_HOLDINGDISK].v.identlist; il != NULL;
+ il = il->next) {
+ if (strcmp((char *)il->data, hdcur.name) == 0) {
+ break;
+ }
+ }
+ if (il) {
+ conf_parserror(_("holding disk '%s' already in use"),
+ hdcur.name);
+ } else {
+ conf_data[CNF_HOLDINGDISK].v.identlist = g_slist_append(
+ conf_data[CNF_HOLDINGDISK].v.identlist,
+ stralloc(hdcur.name));
+ }
+ amfree(hdcur.name);
+ get_conftoken(CONF_ANY);
+ if (tok == CONF_IDENT || tok == CONF_STRING) {
+ hdcur.name = stralloc(tokenval.v.s);
+ } else if (tok != CONF_NL) {
+ conf_parserror(_("IDENT or NL expected"));
+ }
+ } while (tok == CONF_IDENT || tok == CONF_STRING);
+ }
allow_overwrites = save_overwrites;
}
{
conf_init_str(&hdcur.value[HOLDING_COMMENT] , "");
conf_init_str(&hdcur.value[HOLDING_DISKDIR] , "");
- conf_init_int64(&hdcur.value[HOLDING_DISKSIZE] , (gint64)0);
+ conf_init_int64(&hdcur.value[HOLDING_DISKSIZE] , CONF_UNIT_K, (gint64)0);
/* 1 Gb = 1M counted in 1Kb blocks */
- conf_init_int64(&hdcur.value[HOLDING_CHUNKSIZE], (gint64)1024*1024);
+ conf_init_int64(&hdcur.value[HOLDING_CHUNKSIZE], CONF_UNIT_K, (gint64)1024*1024);
}
static void
hp = alloc(sizeof(holdingdisk_t));
*hp = hdcur;
- hp->next = holdinglist;
- holdinglist = hp;
+ holdinglist = g_slist_append(holdinglist, hp);
+}
+
+static void
+copy_holdingdisk(
+ void)
+{
+ holdingdisk_t *hp;
+ int i;
+
+ hp = lookup_holdingdisk(tokenval.v.s);
+
+ if (hp == NULL) {
+ conf_parserror(_("holdingdisk parameter expected"));
+ return;
+ }
+
+ for(i=0; i < HOLDING_HOLDING; i++) {
+ if(hp->value[i].seen.linenum) {
+ merge_val_t(&hdcur.value[i], &hp->value[i]);
+ }
+ }
+
}
get_conftoken(CONF_IDENT);
dpcur.name = stralloc(tokenval.v.s);
}
+ current_block = g_strconcat("dumptype ", dpcur.name, NULL);
+ dpcur.seen.block = current_block;
dpcur.seen.filename = current_filename;
dpcur.seen.linenum = current_line_num;
read_block(dumptype_var, dpcur.value,
_("dumptype parameter expected"),
- (name == NULL), copy_dumptype);
+ (name == NULL), copy_dumptype,
+ "DUMPTYPE", dpcur.name);
if(!name) /* !name => reading disklist, not conffile */
get_conftoken(CONF_NL);
conf_init_str (&dpcur.value[DUMPTYPE_CLNTCOMPPROG] , "");
conf_init_str (&dpcur.value[DUMPTYPE_SRV_ENCRYPT] , "");
conf_init_str (&dpcur.value[DUMPTYPE_CLNT_ENCRYPT] , "");
- conf_init_str (&dpcur.value[DUMPTYPE_AMANDAD_PATH] , "X");
- conf_init_str (&dpcur.value[DUMPTYPE_CLIENT_USERNAME] , "X");
- conf_init_str (&dpcur.value[DUMPTYPE_SSH_KEYS] , "X");
- conf_init_str (&dpcur.value[DUMPTYPE_SECURITY_DRIVER] , "BSD");
+ conf_init_str (&dpcur.value[DUMPTYPE_AMANDAD_PATH] , "");
+ conf_init_str (&dpcur.value[DUMPTYPE_CLIENT_USERNAME] , "");
+ conf_init_str (&dpcur.value[DUMPTYPE_CLIENT_PORT] , "");
+ conf_init_str (&dpcur.value[DUMPTYPE_SSH_KEYS] , "");
+ conf_init_str (&dpcur.value[DUMPTYPE_AUTH] , "BSDTCP");
conf_init_exinclude(&dpcur.value[DUMPTYPE_EXCLUDE]);
conf_init_exinclude(&dpcur.value[DUMPTYPE_INCLUDE]);
conf_init_priority (&dpcur.value[DUMPTYPE_PRIORITY] , 1);
- conf_init_int (&dpcur.value[DUMPTYPE_DUMPCYCLE] , conf_data[CNF_DUMPCYCLE].v.i);
- conf_init_int (&dpcur.value[DUMPTYPE_MAXDUMPS] , conf_data[CNF_MAXDUMPS].v.i);
- conf_init_int (&dpcur.value[DUMPTYPE_MAXPROMOTEDAY] , 10000);
- conf_init_int (&dpcur.value[DUMPTYPE_BUMPPERCENT] , conf_data[CNF_BUMPPERCENT].v.i);
- conf_init_int64 (&dpcur.value[DUMPTYPE_BUMPSIZE] , conf_data[CNF_BUMPSIZE].v.int64);
- conf_init_int (&dpcur.value[DUMPTYPE_BUMPDAYS] , conf_data[CNF_BUMPDAYS].v.i);
+ conf_init_int (&dpcur.value[DUMPTYPE_DUMPCYCLE] , CONF_UNIT_NONE, conf_data[CNF_DUMPCYCLE].v.i);
+ conf_init_int (&dpcur.value[DUMPTYPE_MAXDUMPS] , CONF_UNIT_NONE, conf_data[CNF_MAXDUMPS].v.i);
+ conf_init_int (&dpcur.value[DUMPTYPE_MAXPROMOTEDAY] , CONF_UNIT_NONE, 10000);
+ conf_init_int (&dpcur.value[DUMPTYPE_BUMPPERCENT] , CONF_UNIT_NONE, conf_data[CNF_BUMPPERCENT].v.i);
+ conf_init_int64 (&dpcur.value[DUMPTYPE_BUMPSIZE] , CONF_UNIT_K , conf_data[CNF_BUMPSIZE].v.int64);
+ conf_init_int (&dpcur.value[DUMPTYPE_BUMPDAYS] , CONF_UNIT_NONE, conf_data[CNF_BUMPDAYS].v.i);
conf_init_real (&dpcur.value[DUMPTYPE_BUMPMULT] , conf_data[CNF_BUMPMULT].v.r);
conf_init_time (&dpcur.value[DUMPTYPE_STARTTIME] , (time_t)0);
conf_init_strategy (&dpcur.value[DUMPTYPE_STRATEGY] , DS_STANDARD);
- conf_init_estimate (&dpcur.value[DUMPTYPE_ESTIMATE] , ES_CLIENT);
+ conf_init_estimatelist(&dpcur.value[DUMPTYPE_ESTIMATELIST] , ES_CLIENT);
conf_init_compress (&dpcur.value[DUMPTYPE_COMPRESS] , COMP_FAST);
conf_init_encrypt (&dpcur.value[DUMPTYPE_ENCRYPT] , ENCRYPT_NONE);
+ conf_init_data_path(&dpcur.value[DUMPTYPE_DATA_PATH] , DATA_PATH_AMANDA);
conf_init_str (&dpcur.value[DUMPTYPE_SRV_DECRYPT_OPT] , "-d");
conf_init_str (&dpcur.value[DUMPTYPE_CLNT_DECRYPT_OPT] , "-d");
conf_init_rate (&dpcur.value[DUMPTYPE_COMPRATE] , 0.50, 0.50);
- conf_init_int64 (&dpcur.value[DUMPTYPE_TAPE_SPLITSIZE] , (gint64)0);
- conf_init_int64 (&dpcur.value[DUMPTYPE_FALLBACK_SPLITSIZE], (gint64)10 * 1024);
+ conf_init_int64 (&dpcur.value[DUMPTYPE_TAPE_SPLITSIZE] , CONF_UNIT_K, (gint64)0);
+ conf_init_int64 (&dpcur.value[DUMPTYPE_FALLBACK_SPLITSIZE], CONF_UNIT_K, (gint64)10 * 1024);
conf_init_str (&dpcur.value[DUMPTYPE_SPLIT_DISKBUFFER] , NULL);
conf_init_bool (&dpcur.value[DUMPTYPE_RECORD] , 1);
conf_init_bool (&dpcur.value[DUMPTYPE_SKIP_INCR] , 0);
conf_init_bool (&dpcur.value[DUMPTYPE_IGNORE] , 0);
conf_init_bool (&dpcur.value[DUMPTYPE_INDEX] , 1);
conf_init_application(&dpcur.value[DUMPTYPE_APPLICATION]);
- conf_init_pp_scriptlist(&dpcur.value[DUMPTYPE_PP_SCRIPTLIST]);
+ conf_init_identlist(&dpcur.value[DUMPTYPE_SCRIPTLIST], NULL);
conf_init_proplist(&dpcur.value[DUMPTYPE_PROPERTY]);
+ conf_init_bool (&dpcur.value[DUMPTYPE_ALLOW_SPLIT] , 1);
+ conf_init_int (&dpcur.value[DUMPTYPE_MAX_WARNINGS] , CONF_UNIT_NONE, 20);
+ conf_init_host_limit(&dpcur.value[DUMPTYPE_RECOVERY_LIMIT]);
+ conf_init_host_limit_server(&dpcur.value[DUMPTYPE_DUMP_LIMIT]);
}
static void
for(i=0; i < DUMPTYPE_DUMPTYPE; i++) {
if(dt->value[i].seen.linenum) {
- free_val_t(&dpcur.value[i]);
- copy_val_t(&dpcur.value[i], &dt->value[i]);
+ merge_val_t(&dpcur.value[i], &dt->value[i]);
+ if (i == DUMPTYPE_SCRIPTLIST) {
+ /* sort in 'order' */
+ dpcur.value[i].v.identlist = g_slist_sort(dpcur.value[i].v.identlist, &compare_pp_script_order);
+ }
}
}
}
get_conftoken(CONF_IDENT);
tpcur.name = stralloc(tokenval.v.s);
+ current_block = g_strconcat("tapetype ", tpcur.name, NULL);
+ tpcur.seen.block = current_block;
tpcur.seen.filename = current_filename;
tpcur.seen.linenum = current_line_num;
read_block(tapetype_var, tpcur.value,
- _("tapetype parameter expected"), 1, copy_tapetype);
+ _("tapetype parameter expected"), 1, copy_tapetype,
+ "TAPETYPE", tpcur.name);
get_conftoken(CONF_NL);
if (tapetype_get_readblocksize(&tpcur) <
tapetype_get_blocksize(&tpcur)) {
- conf_init_size(&tpcur.value[TAPETYPE_READBLOCKSIZE],
+ conf_init_size(&tpcur.value[TAPETYPE_READBLOCKSIZE], CONF_UNIT_K,
tapetype_get_blocksize(&tpcur));
}
save_tapetype();
{
conf_init_str(&tpcur.value[TAPETYPE_COMMENT] , "");
conf_init_str(&tpcur.value[TAPETYPE_LBL_TEMPL] , "");
- conf_init_size (&tpcur.value[TAPETYPE_BLOCKSIZE] , DISK_BLOCK_KB);
- conf_init_size (&tpcur.value[TAPETYPE_READBLOCKSIZE], DISK_BLOCK_KB);
- conf_init_int64 (&tpcur.value[TAPETYPE_LENGTH] , ((gint64)2000 * 1024));
- conf_init_int64 (&tpcur.value[TAPETYPE_FILEMARK] , (gint64)1000);
- conf_init_int (&tpcur.value[TAPETYPE_SPEED] , 200);
- conf_init_bool (&tpcur.value[TAPETYPE_FILE_PAD] , 1);
+ conf_init_size (&tpcur.value[TAPETYPE_BLOCKSIZE] , CONF_UNIT_K, DISK_BLOCK_KB);
+ conf_init_size (&tpcur.value[TAPETYPE_READBLOCKSIZE], CONF_UNIT_K, DISK_BLOCK_KB);
+ conf_init_int64 (&tpcur.value[TAPETYPE_LENGTH] , CONF_UNIT_K, ((gint64)2000));
+ conf_init_int64 (&tpcur.value[TAPETYPE_FILEMARK] , CONF_UNIT_K, (gint64)1);
+ conf_init_int (&tpcur.value[TAPETYPE_SPEED] , CONF_UNIT_NONE, 200);
+ conf_init_int64(&tpcur.value[TAPETYPE_PART_SIZE], CONF_UNIT_K, 0);
+ conf_init_part_cache_type(&tpcur.value[TAPETYPE_PART_CACHE_TYPE], PART_CACHE_TYPE_NONE);
+ conf_init_str(&tpcur.value[TAPETYPE_PART_CACHE_DIR], "");
+ conf_init_int64(&tpcur.value[TAPETYPE_PART_CACHE_MAX_SIZE], CONF_UNIT_K, 0);
}
static void
tp = alloc(sizeof(tapetype_t));
*tp = tpcur;
+
/* add at end of list */
if(!tapelist)
tapelist = tp;
for(i=0; i < TAPETYPE_TAPETYPE; i++) {
if(tp->value[i].seen.linenum) {
- free_val_t(&tpcur.value[i]);
- copy_val_t(&tpcur.value[i], &tp->value[i]);
+ merge_val_t(&tpcur.value[i], &tp->value[i]);
}
}
}
get_conftoken(CONF_IDENT);
ifcur.name = stralloc(tokenval.v.s);
+ current_block = g_strconcat("interface ", ifcur.name, NULL);
+ ifcur.seen.block = current_block;
ifcur.seen.filename = current_filename;
ifcur.seen.linenum = current_line_num;
read_block(interface_var, ifcur.value,
- _("interface parameter expected"), 1, copy_interface);
+ _("interface parameter expected"), 1, copy_interface,
+ "INTERFACE", ifcur.name);
get_conftoken(CONF_NL);
save_interface();
init_interface_defaults(void)
{
conf_init_str(&ifcur.value[INTER_COMMENT] , "");
- conf_init_int (&ifcur.value[INTER_MAXUSAGE], 8000);
+ conf_init_int (&ifcur.value[INTER_MAXUSAGE], CONF_UNIT_K, 80000);
}
static void
for(i=0; i < INTER_INTER; i++) {
if(ip->value[i].seen.linenum) {
- free_val_t(&ifcur.value[i]);
- copy_val_t(&ifcur.value[i], &ip->value[i]);
+ merge_val_t(&ifcur.value[i], &ip->value[i]);
}
}
}
-application_t *
+static application_t *
read_application(
char *name,
FILE *from,
get_conftoken(CONF_IDENT);
apcur.name = stralloc(tokenval.v.s);
}
+ current_block = g_strconcat("application ", apcur.name, NULL);
+ apcur.seen.block = current_block;
apcur.seen.filename = current_filename;
apcur.seen.linenum = current_line_num;
read_block(application_var, apcur.value,
- _("application-tool parameter expected"),
- (name == NULL), *copy_application);
+ _("application parameter expected"),
+ (name == NULL), *copy_application,
+ "APPLICATION", apcur.name);
if(!name)
get_conftoken(CONF_NL);
- if (!application_get_plugin(&apcur) ||
- strlen(application_get_plugin(&apcur)) == 0) {
- conf_parserror("plugin not set for application");
- }
-
save_application();
allow_overwrites = save_overwrites;
conf_init_str(&apcur.value[APPLICATION_COMMENT] , "");
conf_init_str(&apcur.value[APPLICATION_PLUGIN] , "");
conf_init_proplist(&apcur.value[APPLICATION_PROPERTY]);
+ conf_init_str(&apcur.value[APPLICATION_CLIENT_NAME] , "");
}
static void
ap = lookup_application(apcur.name);
if(ap != (application_t *)0) {
- conf_parserror(_("application-tool %s already defined at %s:%d"),
+ conf_parserror(_("application %s already defined at %s:%d"),
ap->name, ap->seen.filename, ap->seen.linenum);
return;
}
for(i=0; i < APPLICATION_APPLICATION; i++) {
if(ap->value[i].seen.linenum) {
- free_val_t(&apcur.value[i]);
- copy_val_t(&apcur.value[i], &ap->value[i]);
+ merge_val_t(&apcur.value[i], &ap->value[i]);
}
}
}
-pp_script_t *
-read_pp_script(
+static interactivity_t *
+read_interactivity(
char *name,
FILE *from,
char *fname,
save_overwrites = allow_overwrites;
allow_overwrites = 1;
- init_pp_script_defaults();
+ init_interactivity_defaults();
if (name) {
- pscur.name = name;
+ ivcur.name = name;
} else {
get_conftoken(CONF_IDENT);
- pscur.name = stralloc(tokenval.v.s);
+ ivcur.name = stralloc(tokenval.v.s);
}
- pscur.seen.filename = current_filename;
- pscur.seen.linenum = current_line_num;
+ current_block = g_strconcat("interactivity ", ivcur.name, NULL);
+ ivcur.seen.block = current_block;
+ ivcur.seen.filename = current_filename;
+ ivcur.seen.linenum = current_line_num;
- read_block(pp_script_var, pscur.value,
- _("script-tool parameter expected"),
- (name == NULL), *copy_pp_script);
+ read_block(interactivity_var, ivcur.value,
+ _("interactivity parameter expected"),
+ (name == NULL), *copy_interactivity,
+ "INTERACTIVITY", ivcur.name);
if(!name)
get_conftoken(CONF_NL);
- if (!pp_script_get_plugin(&pscur) ||
- strlen(pp_script_get_plugin(&pscur)) == 0) {
- conf_parserror("plugin not set for script");
- }
-
- save_pp_script();
+ save_interactivity();
allow_overwrites = save_overwrites;
if (from)
current_file = saved_conf;
- return lookup_pp_script(pscur.name);
+ return lookup_interactivity(ivcur.name);
}
static void
-get_pp_script(
+get_interactivity(
void)
{
- read_pp_script(NULL, NULL, NULL, NULL);
+ read_interactivity(NULL, NULL, NULL, NULL);
}
static void
-init_pp_script_defaults(
+init_interactivity_defaults(
void)
{
- pscur.name = NULL;
- conf_init_str(&pscur.value[PP_SCRIPT_COMMENT] , "");
- conf_init_str(&pscur.value[PP_SCRIPT_PLUGIN] , "");
- conf_init_proplist(&pscur.value[PP_SCRIPT_PROPERTY]);
- conf_init_execute_on(&pscur.value[PP_SCRIPT_EXECUTE_ON], 0);
- conf_init_execute_where(&pscur.value[PP_SCRIPT_EXECUTE_WHERE], ES_CLIENT);
+ ivcur.name = NULL;
+ conf_init_str(&ivcur.value[INTERACTIVITY_COMMENT] , "");
+ conf_init_str(&ivcur.value[INTERACTIVITY_PLUGIN] , "");
+ conf_init_proplist(&ivcur.value[INTERACTIVITY_PROPERTY]);
}
static void
-save_pp_script(
+save_interactivity(
void)
{
- pp_script_t *ps, *ps1;
+ interactivity_t *iv, *iv1;
- ps = lookup_pp_script(pscur.name);
+ iv = lookup_interactivity(ivcur.name);
- if(ps != (pp_script_t *)0) {
- conf_parserror(_("script-tool %s already defined at %s:%d"),
- ps->name, ps->seen.filename, ps->seen.linenum);
+ if (iv != (interactivity_t *)0) {
+ conf_parserror(_("interactivity %s already defined at %s:%d"),
+ iv->name, iv->seen.filename, iv->seen.linenum);
return;
}
- ps = alloc(sizeof(pp_script_t));
- *ps = pscur;
- ps->next = NULL;
+ iv = alloc(sizeof(interactivity_t));
+ *iv = ivcur;
+ iv->next = NULL;
/* add at end of list */
- if (!pp_script_list)
- pp_script_list = ps;
+ if (!interactivity_list)
+ interactivity_list = iv;
else {
- ps1 = pp_script_list;
- while (ps1->next != NULL) {
- ps1 = ps1->next;
+ iv1 = interactivity_list;
+ while (iv1->next != NULL) {
+ iv1 = iv1->next;
}
- ps1->next = ps;
+ iv1->next = iv;
}
}
static void
-copy_pp_script(void)
+copy_interactivity(void)
{
- pp_script_t *ps;
+ interactivity_t *iv;
int i;
- ps = lookup_pp_script(tokenval.v.s);
+ iv = lookup_interactivity(tokenval.v.s);
- if(ps == NULL) {
- conf_parserror(_("script parameter expected"));
+ if (iv == NULL) {
+ conf_parserror(_("interactivity parameter expected"));
return;
}
- for(i=0; i < PP_SCRIPT_PP_SCRIPT; i++) {
- if(ps->value[i].seen.linenum) {
- free_val_t(&pscur.value[i]);
- copy_val_t(&pscur.value[i], &ps->value[i]);
+ for (i=0; i < INTERACTIVITY_INTERACTIVITY; i++) {
+ if(iv->value[i].seen.linenum) {
+ merge_val_t(&ivcur.value[i], &iv->value[i]);
}
}
}
-device_config_t *
-read_device_config(
+static taperscan_t *
+read_taperscan(
char *name,
FILE *from,
char *fname,
save_overwrites = allow_overwrites;
allow_overwrites = 1;
- init_device_config_defaults();
+ init_taperscan_defaults();
if (name) {
- dccur.name = name;
+ tscur.name = name;
} else {
get_conftoken(CONF_IDENT);
- dccur.name = stralloc(tokenval.v.s);
+ tscur.name = stralloc(tokenval.v.s);
}
- dccur.seen.filename = current_filename;
- dccur.seen.linenum = current_line_num;
+ current_block = g_strconcat("taperscan ", tscur.name, NULL);
+ tscur.seen.block = current_block;
+ tscur.seen.filename = current_filename;
+ tscur.seen.linenum = current_line_num;
- read_block(device_config_var, dccur.value,
- _("device parameter expected"),
- (name == NULL), *copy_device_config);
+ read_block(taperscan_var, tscur.value,
+ _("taperscan parameter expected"),
+ (name == NULL), *copy_taperscan,
+ "TAPERSCAN", tscur.name);
if(!name)
get_conftoken(CONF_NL);
- save_device_config();
+ save_taperscan();
allow_overwrites = save_overwrites;
if (from)
current_file = saved_conf;
- return lookup_device_config(dccur.name);
+ return lookup_taperscan(tscur.name);
}
static void
-get_device_config(
+get_taperscan(
void)
{
- read_device_config(NULL, NULL, NULL, NULL);
+ read_taperscan(NULL, NULL, NULL, NULL);
}
static void
-init_device_config_defaults(
+init_taperscan_defaults(
void)
{
- dccur.name = NULL;
- conf_init_str(&dccur.value[DEVICE_CONFIG_COMMENT] , "");
- conf_init_str(&dccur.value[DEVICE_CONFIG_TAPEDEV] , "");
- conf_init_proplist(&dccur.value[DEVICE_CONFIG_DEVICE_PROPERTY]);
+ tscur.name = NULL;
+ conf_init_str(&tscur.value[TAPERSCAN_COMMENT] , "");
+ conf_init_str(&tscur.value[TAPERSCAN_PLUGIN] , "");
+ conf_init_proplist(&tscur.value[TAPERSCAN_PROPERTY]);
}
static void
-save_device_config(
+save_taperscan(
void)
{
- device_config_t *dc, *dc1;
+ taperscan_t *ts, *ts1;
- dc = lookup_device_config(dccur.name);
+ ts = lookup_taperscan(tscur.name);
- if(dc != (device_config_t *)0) {
- conf_parserror(_("device %s already defined at %s:%d"),
- dc->name, dc->seen.filename, dc->seen.linenum);
+ if (ts != (taperscan_t *)0) {
+ conf_parserror(_("taperscan %s already defined at %s:%d"),
+ ts->name, ts->seen.filename, ts->seen.linenum);
return;
}
- dc = alloc(sizeof(device_config_t));
- *dc = dccur;
- dc->next = NULL;
+ ts = alloc(sizeof(taperscan_t));
+ *ts = tscur;
+ ts->next = NULL;
/* add at end of list */
- if (!device_config_list)
- device_config_list = dc;
+ if (!taperscan_list)
+ taperscan_list = ts;
else {
- dc1 = device_config_list;
- while (dc1->next != NULL) {
- dc1 = dc1->next;
+ ts1 = taperscan_list;
+ while (ts1->next != NULL) {
+ ts1 = ts1->next;
}
- dc1->next = dc;
+ ts1->next = ts;
}
}
static void
-copy_device_config(void)
+copy_taperscan(void)
{
- device_config_t *dc;
+ taperscan_t *ts;
int i;
- dc = lookup_device_config(tokenval.v.s);
+ ts = lookup_taperscan(tokenval.v.s);
- if(dc == NULL) {
- conf_parserror(_("device parameter expected"));
+ if (ts == NULL) {
+ conf_parserror(_("taperscan parameter expected"));
return;
}
- for(i=0; i < DEVICE_CONFIG_DEVICE_CONFIG; i++) {
- if(dc->value[i].seen.linenum) {
- free_val_t(&dccur.value[i]);
- copy_val_t(&dccur.value[i], &dc->value[i]);
+ for (i=0; i < TAPERSCAN_TAPERSCAN; i++) {
+ if(ts->value[i].seen.linenum) {
+ merge_val_t(&tscur.value[i], &ts->value[i]);
}
}
}
-changer_config_t *
-read_changer_config(
+static pp_script_t *
+read_pp_script(
char *name,
FILE *from,
char *fname,
if (fname) {
saved_fname = current_filename;
- current_filename = fname;
+ current_filename = get_seen_filename(fname);
}
if (linenum)
save_overwrites = allow_overwrites;
allow_overwrites = 1;
- init_changer_config_defaults();
+ init_pp_script_defaults();
if (name) {
- cccur.name = name;
+ pscur.name = name;
} else {
get_conftoken(CONF_IDENT);
- cccur.name = stralloc(tokenval.v.s);
+ pscur.name = stralloc(tokenval.v.s);
}
- cccur.seen = current_line_num;
+ current_block = g_strconcat("script ", pscur.name, NULL);
+ pscur.seen.block = current_block;
+ pscur.seen.filename = current_filename;
+ pscur.seen.linenum = current_line_num;
- read_block(changer_config_var, cccur.value,
- _("changer parameter expected"),
- (name == NULL), *copy_changer_config);
+ read_block(pp_script_var, pscur.value,
+ _("script parameter expected"),
+ (name == NULL), *copy_pp_script,
+ "SCRIPT", pscur.name);
if(!name)
get_conftoken(CONF_NL);
- save_changer_config();
+ save_pp_script();
allow_overwrites = save_overwrites;
if (from)
current_file = saved_conf;
- return lookup_changer_config(cccur.name);
+ return lookup_pp_script(pscur.name);
}
static void
-get_changer_config(
+get_pp_script(
void)
{
- read_changer_config(NULL, NULL, NULL, NULL);
+ read_pp_script(NULL, NULL, NULL, NULL);
}
static void
-init_changer_config_defaults(
+init_pp_script_defaults(
void)
{
- cccur.name = NULL;
- conf_init_str(&cccur.value[CHANGER_CONFIG_COMMENT] , "");
- conf_init_str(&cccur.value[CHANGER_CONFIG_TAPEDEV] , "");
- conf_init_str(&cccur.value[CHANGER_CONFIG_TPCHANGER] , "");
- conf_init_str(&cccur.value[CHANGER_CONFIG_CHANGERDEV] , "");
- conf_init_str(&cccur.value[CHANGER_CONFIG_CHANGERFILE] , "");
+ pscur.name = NULL;
+ conf_init_str(&pscur.value[PP_SCRIPT_COMMENT] , "");
+ conf_init_str(&pscur.value[PP_SCRIPT_PLUGIN] , "");
+ conf_init_proplist(&pscur.value[PP_SCRIPT_PROPERTY]);
+ conf_init_execute_on(&pscur.value[PP_SCRIPT_EXECUTE_ON], 0);
+ conf_init_execute_where(&pscur.value[PP_SCRIPT_EXECUTE_WHERE], ES_CLIENT);
+ conf_init_int(&pscur.value[PP_SCRIPT_ORDER], CONF_UNIT_NONE, 5000);
+ conf_init_bool(&pscur.value[PP_SCRIPT_SINGLE_EXECUTION], 0);
+ conf_init_str(&pscur.value[PP_SCRIPT_CLIENT_NAME], "");
}
static void
-save_changer_config(
+save_pp_script(
void)
{
- changer_config_t *dc, *dc1;
+ pp_script_t *ps, *ps1;
+
+ ps = lookup_pp_script(pscur.name);
+
+ if(ps != (pp_script_t *)0) {
+ conf_parserror(_("script %s already defined at %s:%d"),
+ ps->name, ps->seen.filename, ps->seen.linenum);
+ return;
+ }
+
+ ps = alloc(sizeof(pp_script_t));
+ *ps = pscur;
+ ps->next = NULL;
+ /* add at end of list */
+ if (!pp_script_list)
+ pp_script_list = ps;
+ else {
+ ps1 = pp_script_list;
+ while (ps1->next != NULL) {
+ ps1 = ps1->next;
+ }
+ ps1->next = ps;
+ }
+}
+
+static void
+copy_pp_script(void)
+{
+ pp_script_t *ps;
+ int i;
+
+ ps = lookup_pp_script(tokenval.v.s);
+
+ if(ps == NULL) {
+ conf_parserror(_("script parameter expected"));
+ return;
+ }
+
+ for(i=0; i < PP_SCRIPT_PP_SCRIPT; i++) {
+ if(ps->value[i].seen.linenum) {
+ merge_val_t(&pscur.value[i], &ps->value[i]);
+ }
+ }
+}
+
+static device_config_t *
+read_device_config(
+ char *name,
+ FILE *from,
+ char *fname,
+ int *linenum)
+{
+ int save_overwrites;
+ FILE *saved_conf = NULL;
+ char *saved_fname = NULL;
+
+ if (from) {
+ saved_conf = current_file;
+ current_file = from;
+ }
+
+ if (fname) {
+ saved_fname = current_filename;
+ current_filename = get_seen_filename(fname);
+ }
+
+ if (linenum)
+ current_line_num = *linenum;
+
+ save_overwrites = allow_overwrites;
+ allow_overwrites = 1;
+
+ init_device_config_defaults();
+ if (name) {
+ dccur.name = name;
+ } else {
+ get_conftoken(CONF_IDENT);
+ dccur.name = stralloc(tokenval.v.s);
+ }
+ current_block = g_strconcat("device ", dccur.name, NULL);
+ dccur.seen.block = current_block;
+ dccur.seen.filename = current_filename;
+ dccur.seen.linenum = current_line_num;
+
+ read_block(device_config_var, dccur.value,
+ _("device parameter expected"),
+ (name == NULL), *copy_device_config,
+ "DEVICE", dccur.name);
+ if(!name)
+ get_conftoken(CONF_NL);
+
+ save_device_config();
+
+ allow_overwrites = save_overwrites;
+
+ if (linenum)
+ *linenum = current_line_num;
+
+ if (fname)
+ current_filename = saved_fname;
+
+ if (from)
+ current_file = saved_conf;
+
+ return lookup_device_config(dccur.name);
+}
+
+static void
+get_device_config(
+ void)
+{
+ read_device_config(NULL, NULL, NULL, NULL);
+}
+
+static void
+init_device_config_defaults(
+ void)
+{
+ dccur.name = NULL;
+ conf_init_str(&dccur.value[DEVICE_CONFIG_COMMENT] , "");
+ conf_init_str(&dccur.value[DEVICE_CONFIG_TAPEDEV] , "");
+ conf_init_proplist(&dccur.value[DEVICE_CONFIG_DEVICE_PROPERTY]);
+}
+
+static void
+save_device_config(
+ void)
+{
+ device_config_t *dc, *dc1;
+
+ dc = lookup_device_config(dccur.name);
+
+ if(dc != (device_config_t *)0) {
+ conf_parserror(_("device %s already defined at %s:%d"),
+ dc->name, dc->seen.filename, dc->seen.linenum);
+ return;
+ }
+
+ dc = alloc(sizeof(device_config_t));
+ *dc = dccur;
+ dc->next = NULL;
+ /* add at end of list */
+ if (!device_config_list)
+ device_config_list = dc;
+ else {
+ dc1 = device_config_list;
+ while (dc1->next != NULL) {
+ dc1 = dc1->next;
+ }
+ dc1->next = dc;
+ }
+}
+
+static void
+copy_device_config(void)
+{
+ device_config_t *dc;
+ int i;
+
+ dc = lookup_device_config(tokenval.v.s);
+
+ if(dc == NULL) {
+ conf_parserror(_("device parameter expected"));
+ return;
+ }
+
+ for(i=0; i < DEVICE_CONFIG_DEVICE_CONFIG; i++) {
+ if(dc->value[i].seen.linenum) {
+ merge_val_t(&dccur.value[i], &dc->value[i]);
+ }
+ }
+}
+
+static changer_config_t *
+read_changer_config(
+ char *name,
+ FILE *from,
+ char *fname,
+ int *linenum)
+{
+ int save_overwrites;
+ FILE *saved_conf = NULL;
+ char *saved_fname = NULL;
+
+ if (from) {
+ saved_conf = current_file;
+ current_file = from;
+ }
+
+ if (fname) {
+ saved_fname = current_filename;
+ current_filename = fname;
+ }
+
+ if (linenum)
+ current_line_num = *linenum;
+
+ save_overwrites = allow_overwrites;
+ allow_overwrites = 1;
+
+ init_changer_config_defaults();
+ if (name) {
+ cccur.name = name;
+ } else {
+ get_conftoken(CONF_IDENT);
+ cccur.name = stralloc(tokenval.v.s);
+ }
+ current_block = g_strconcat("changer ", cccur.name, NULL);
+ cccur.seen.block = current_block;
+ cccur.seen.filename = current_filename;
+ cccur.seen.linenum = current_line_num;
+
+ read_block(changer_config_var, cccur.value,
+ _("changer parameter expected"),
+ (name == NULL), *copy_changer_config,
+ "CHANGER", cccur.name);
+ if(!name)
+ get_conftoken(CONF_NL);
+
+ save_changer_config();
+
+ allow_overwrites = save_overwrites;
+
+ if (linenum)
+ *linenum = current_line_num;
+
+ if (fname)
+ current_filename = saved_fname;
+
+ if (from)
+ current_file = saved_conf;
+
+ return lookup_changer_config(cccur.name);
+}
+
+static void
+get_changer_config(
+ void)
+{
+ read_changer_config(NULL, NULL, NULL, NULL);
+}
+
+static void
+init_changer_config_defaults(
+ void)
+{
+ cccur.name = NULL;
+ conf_init_str(&cccur.value[CHANGER_CONFIG_COMMENT] , "");
+ conf_init_str(&cccur.value[CHANGER_CONFIG_TAPEDEV] , "");
+ conf_init_str(&cccur.value[CHANGER_CONFIG_TPCHANGER] , "");
+ conf_init_str(&cccur.value[CHANGER_CONFIG_CHANGERDEV] , "");
+ conf_init_str(&cccur.value[CHANGER_CONFIG_CHANGERFILE] , "");
+ conf_init_proplist(&cccur.value[CHANGER_CONFIG_PROPERTY]);
+ conf_init_proplist(&cccur.value[CHANGER_CONFIG_DEVICE_PROPERTY]);
+}
+
+static void
+save_changer_config(
+ void)
+{
+ changer_config_t *dc, *dc1;
dc = lookup_changer_config(cccur.name);
if(dc != (changer_config_t *)0) {
- conf_parserror(_("changer %s already defined on line %d"),
- dc->name, dc->seen);
+ conf_parserror(_("changer %s already defined at %s:%d"),
+ dc->name, dc->seen.filename, dc->seen.linenum);
return;
}
for(i=0; i < CHANGER_CONFIG_CHANGER_CONFIG; i++) {
if(dc->value[i].seen.linenum) {
- free_val_t(&cccur.value[i]);
- copy_val_t(&cccur.value[i], &dc->value[i]);
+ merge_val_t(&cccur.value[i], &dc->value[i]);
}
}
}
val_t *val)
{
ckseen(&val->seen);
- val_t__int(val) = get_int();
+ val_t__int(val) = get_int(val->unit);
}
static void
val_t *val)
{
ckseen(&val->seen);
- val_t__int64(val) = get_int64();
+ val_t__int64(val) = get_int64(val->unit);
}
static void
val_t *val)
{
ckseen(&val->seen);
- val_t__size(val) = get_size();
+ val_t__size(val) = get_size(val->unit);
}
static void
val_t__boolean(val) = get_bool();
}
+static void
+read_no_yes_all(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ ckseen(&val->seen);
+ val_t__int(val) = get_no_yes_all();
+}
+
static void
read_compress(
conf_var_t *np G_GNUC_UNUSED,
}
static void
-read_estimate(
+read_estimatelist(
conf_var_t *np G_GNUC_UNUSED,
val_t *val)
{
- int estime;
+ estimatelist_t estimates = NULL;
ckseen(&val->seen);
get_conftoken(CONF_ANY);
- switch(tok) {
- case CONF_CLIENT:
- estime = ES_CLIENT;
- break;
- case CONF_SERVER:
- estime = ES_SERVER;
- break;
- case CONF_CALCSIZE:
- estime = ES_CALCSIZE;
- break;
- default:
- conf_parserror(_("CLIENT, SERVER or CALCSIZE expected"));
- estime = ES_CLIENT;
- }
- val_t__estimate(val) = estime;
+ do {
+ switch(tok) {
+ case CONF_CLIENT:
+ estimates = g_slist_append(estimates, GINT_TO_POINTER(ES_CLIENT));
+ break;
+ case CONF_SERVER:
+ estimates = g_slist_append(estimates, GINT_TO_POINTER(ES_SERVER));
+ break;
+ case CONF_CALCSIZE:
+ estimates = g_slist_append(estimates, GINT_TO_POINTER(ES_CALCSIZE));
+ break;
+ default:
+ conf_parserror(_("CLIENT, SERVER or CALCSIZE expected"));
+ }
+ get_conftoken(CONF_ANY);
+ if (tok == CONF_NL)
+ break;
+ } while (1);
+ val_t__estimatelist(val) = estimates;
}
static void
case CONF_ERROR: val_t__send_amreport(val) = SEND_AMREPORT_ERROR; break;
case CONF_NEVER: val_t__send_amreport(val) = SEND_AMREPORT_NEVER; break;
default:
- conf_parserror(_("ALL, STRANGE, ERROR or NEVER expected"));
+ conf_parserror(_("ALL, STRANGE, ERROR or NEVER expected"));
+ }
+}
+
+static void
+read_data_path(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ ckseen(&val->seen);
+
+ get_conftoken(CONF_ANY);
+ switch(tok) {
+ case CONF_AMANDA : val_t__data_path(val) = DATA_PATH_AMANDA ; break;
+ case CONF_DIRECTTCP: val_t__data_path(val) = DATA_PATH_DIRECTTCP; break;
+ default:
+ conf_parserror(_("AMANDA or DIRECTTCP expected"));
}
}
val_t *val)
{
int file, got_one = 0;
- sl_t *exclude;
+ am_sl_t *exclude;
int optional = 0;
get_conftoken(CONF_ANY);
val_t *val)
{
char *key;
+ gboolean set_seen = TRUE;
property_t *property = malloc(sizeof(property_t));
property_t *old_property;
property->append = 0;
conf_parserror(_("key expected"));
return;
}
- key = strdup(tokenval.v.s);
+ key = amandaify_property_name(tokenval.v.s);
get_conftoken(CONF_ANY);
if (tok == CONF_NL || tok == CONF_END) {
}
if(val->seen.linenum == 0) {
- val->seen.filename = current_filename;
- val->seen.linenum = current_line_num;
+ ckseen(&val->seen); // first property
}
old_property = g_hash_table_lookup(val->v.proplist, key);
if (property->append) {
+ /* old_property will be freed by g_hash_table_insert, so
+ * steal its values */
if (old_property) {
if (old_property->priority)
property->priority = 1;
property->values = old_property->values;
+ old_property->values = NULL;
+ set_seen = FALSE;
}
- } else {
- property->values = g_hash_table_lookup(val->v.proplist, key);
- if (old_property) {
- g_slist_free(old_property->values);
- amfree(old_property);
- }
- property->values = NULL;
}
while(tok == CONF_STRING) {
property->values = g_slist_append(property->values,
}
unget_conftoken();
g_hash_table_insert(val->v.proplist, key, property);
+ if (set_seen) {
+ property->seen.linenum = 0;
+ property->seen.filename = NULL;
+ property->seen.block = NULL;
+ ckseen(&property->seen);
+ }
}
conf_var_t *np G_GNUC_UNUSED,
val_t *val)
{
+ application_t *application;
get_conftoken(CONF_ANY);
if (tok == CONF_LBRACE) {
- val->v.application = read_application(vstralloc("custom(DUMPTYPE:",
- dpcur.name, ")", ".",
- anonymous_value(),NULL),
- NULL, NULL, NULL);
-
+ current_line_num -= 1;
+ application = read_application(vstralloc("custom(DUMPTYPE:",
+ dpcur.name, ")", ".",
+ anonymous_value(),NULL),
+ NULL, NULL, NULL);
+ current_line_num -= 1;
} else if (tok == CONF_STRING) {
- val->v.application = lookup_application(tokenval.v.s);
- if (val->v.application == NULL) {
+ application = lookup_application(tokenval.v.s);
+ if (application == NULL) {
conf_parserror(_("Unknown application named: %s"), tokenval.v.s);
return;
}
conf_parserror(_("application name expected: %d %d"), tok, CONF_STRING);
return;
}
+ amfree(val->v.s);
+ val->v.s = stralloc(application->name);
+ ckseen(&val->seen);
+}
+
+static void
+read_dinteractivity(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ interactivity_t *interactivity;
+
+ get_conftoken(CONF_ANY);
+ if (tok == CONF_LBRACE) {
+ current_line_num -= 1;
+ interactivity = read_interactivity(vstralloc("custom(iv)", ".",
+ anonymous_value(),NULL),
+ NULL, NULL, NULL);
+ current_line_num -= 1;
+ } else if (tok == CONF_STRING) {
+ interactivity = lookup_interactivity(tokenval.v.s);
+ if (interactivity == NULL) {
+ conf_parserror(_("Unknown interactivity named: %s"), tokenval.v.s);
+ return;
+ }
+ } else {
+ conf_parserror(_("interactivity name expected: %d %d"), tok, CONF_STRING);
+ return;
+ }
+ amfree(val->v.s);
+ val->v.s = stralloc(interactivity->name);
+ ckseen(&val->seen);
+}
+
+static void
+read_dtaperscan(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ taperscan_t *taperscan;
+
+ get_conftoken(CONF_ANY);
+ if (tok == CONF_LBRACE) {
+ current_line_num -= 1;
+ taperscan = read_taperscan(vstralloc("custom(ts)", ".",
+ anonymous_value(),NULL),
+ NULL, NULL, NULL);
+ current_line_num -= 1;
+ } else if (tok == CONF_STRING) {
+ taperscan = lookup_taperscan(tokenval.v.s);
+ if (taperscan == NULL) {
+ conf_parserror(_("Unknown taperscan named: %s"), tokenval.v.s);
+ return;
+ }
+ } else {
+ conf_parserror(_("taperscan name expected: %d %d"), tok, CONF_STRING);
+ return;
+ }
+ amfree(val->v.s);
+ val->v.s = stralloc(taperscan->name);
ckseen(&val->seen);
}
pp_script_t *pp_script;
get_conftoken(CONF_ANY);
if (tok == CONF_LBRACE) {
+ current_line_num -= 1;
pp_script = read_pp_script(vstralloc("custom(DUMPTYPE:", dpcur.name,
")", ".", anonymous_value(),NULL),
NULL, NULL, NULL);
- } else if (tok == CONF_STRING) {
- pp_script = lookup_pp_script(tokenval.v.s);
- if (pp_script == NULL) {
- conf_parserror(_("Unknown pp_script named: %s"), tokenval.v.s);
- return;
+ current_line_num -= 1;
+ val->v.identlist = g_slist_insert_sorted(val->v.identlist,
+ stralloc(pp_script->name), &compare_pp_script_order);
+ } else if (tok == CONF_STRING || tok == CONF_IDENT) {
+ while (tok == CONF_STRING || tok == CONF_IDENT) {
+ pp_script = lookup_pp_script(tokenval.v.s);
+ if (pp_script == NULL) {
+ conf_parserror(_("Unknown pp_script named: %s"), tokenval.v.s);
+ return;
+ }
+ val->v.identlist = g_slist_insert_sorted(val->v.identlist,
+ stralloc(pp_script->name), &compare_pp_script_order);
+ get_conftoken(CONF_ANY);
}
+ unget_conftoken();
} else {
conf_parserror(_("pp_script name expected: %d %d"), tok, CONF_STRING);
return;
}
- val->v.pp_scriptlist = g_slist_append(val->v.pp_scriptlist, pp_script);
ckseen(&val->seen);
}
static void
val->v.i = 0;
do {
switch(tok) {
+ case CONF_PRE_AMCHECK: val->v.i |= EXECUTE_ON_PRE_AMCHECK; break;
case CONF_PRE_DLE_AMCHECK: val->v.i |= EXECUTE_ON_PRE_DLE_AMCHECK; break;
case CONF_PRE_HOST_AMCHECK: val->v.i |= EXECUTE_ON_PRE_HOST_AMCHECK; break;
case CONF_POST_DLE_AMCHECK: val->v.i |= EXECUTE_ON_POST_DLE_AMCHECK; break;
case CONF_POST_HOST_AMCHECK: val->v.i |= EXECUTE_ON_POST_HOST_AMCHECK; break;
+ case CONF_POST_AMCHECK: val->v.i |= EXECUTE_ON_POST_AMCHECK; break;
+ case CONF_PRE_ESTIMATE: val->v.i |= EXECUTE_ON_PRE_ESTIMATE; break;
case CONF_PRE_DLE_ESTIMATE: val->v.i |= EXECUTE_ON_PRE_DLE_ESTIMATE; break;
case CONF_PRE_HOST_ESTIMATE: val->v.i |= EXECUTE_ON_PRE_HOST_ESTIMATE; break;
case CONF_POST_DLE_ESTIMATE: val->v.i |= EXECUTE_ON_POST_DLE_ESTIMATE; break;
case CONF_POST_HOST_ESTIMATE: val->v.i |= EXECUTE_ON_POST_HOST_ESTIMATE; break;
+ case CONF_POST_ESTIMATE: val->v.i |= EXECUTE_ON_POST_ESTIMATE; break;
+ case CONF_PRE_BACKUP: val->v.i |= EXECUTE_ON_PRE_BACKUP; break;
case CONF_PRE_DLE_BACKUP: val->v.i |= EXECUTE_ON_PRE_DLE_BACKUP; break;
case CONF_PRE_HOST_BACKUP: val->v.i |= EXECUTE_ON_PRE_HOST_BACKUP; break;
+ case CONF_POST_BACKUP: val->v.i |= EXECUTE_ON_POST_BACKUP; break;
case CONF_POST_DLE_BACKUP: val->v.i |= EXECUTE_ON_POST_DLE_BACKUP; break;
case CONF_POST_HOST_BACKUP: val->v.i |= EXECUTE_ON_POST_HOST_BACKUP; break;
case CONF_PRE_RECOVER: val->v.i |= EXECUTE_ON_PRE_RECOVER; break;
case CONF_POST_LEVEL_RECOVER: val->v.i |= EXECUTE_ON_POST_LEVEL_RECOVER; break;
case CONF_INTER_LEVEL_RECOVER: val->v.i |= EXECUTE_ON_INTER_LEVEL_RECOVER; break;
default:
- conf_parserror(_("Execute_on expected"));
+ conf_parserror(_("Execute-on expected"));
}
get_conftoken(CONF_ANY);
if (tok != CONF_COMMA) {
}
}
+static void
+read_int_or_str(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ ckseen(&val->seen);
+
+ get_conftoken(CONF_ANY);
+ switch(tok) {
+ case CONF_INT:
+ amfree(val->v.s);
+ val->v.s = g_strdup_printf("%d", tokenval.v.i);
+ break;
+
+ case CONF_SIZE:
+ amfree(val->v.s);
+ val->v.s = g_strdup_printf("%zu", tokenval.v.size);
+ break;
+
+ case CONF_INT64:
+ amfree(val->v.s);
+ val->v.s = g_strdup_printf("%jd", (intmax_t)tokenval.v.int64);
+ break;
+
+ case CONF_STRING:
+ val->v.s = newstralloc(val->v.s, tokenval.v.s);
+ break;
+ default:
+ conf_parserror(_("an integer or a quoted string is expected"));
+ }
+}
+
+static void
+read_autolabel(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ int data = 0;
+ ckseen(&val->seen);
+
+ get_conftoken(CONF_ANY);
+ if (tok == CONF_STRING) {
+ data++;
+ val->v.autolabel.template = newstralloc(val->v.autolabel.template,
+ tokenval.v.s);
+ get_conftoken(CONF_ANY);
+ }
+ val->v.autolabel.autolabel = 0;
+ while (tok != CONF_NL && tok != CONF_END) {
+ data++;
+ if (tok == CONF_ANY_VOLUME)
+ val->v.autolabel.autolabel |= AL_OTHER_CONFIG | AL_NON_AMANDA |
+ AL_VOLUME_ERROR | AL_EMPTY;
+ else if (tok == CONF_OTHER_CONFIG)
+ val->v.autolabel.autolabel |= AL_OTHER_CONFIG;
+ else if (tok == CONF_NON_AMANDA)
+ val->v.autolabel.autolabel |= AL_NON_AMANDA;
+ else if (tok == CONF_VOLUME_ERROR)
+ val->v.autolabel.autolabel |= AL_VOLUME_ERROR;
+ else if (tok == CONF_EMPTY)
+ val->v.autolabel.autolabel |= AL_EMPTY;
+ else {
+ conf_parserror(_("ANY, NEW-VOLUME, OTHER-CONFIG, NON-AMANDA, VOLUME-ERROR or EMPTY is expected"));
+ }
+ get_conftoken(CONF_ANY);
+ }
+ if (data == 0) {
+ amfree(val->v.autolabel.template);
+ val->v.autolabel.autolabel = 0;
+ } else if (val->v.autolabel.autolabel == 0) {
+ val->v.autolabel.autolabel = AL_VOLUME_ERROR | AL_EMPTY;
+ }
+}
+
+static void
+read_part_cache_type(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ part_cache_type_t part_cache_type;
+
+ ckseen(&val->seen);
+
+ get_conftoken(CONF_ANY);
+ switch(tok) {
+ case CONF_NONE:
+ part_cache_type = PART_CACHE_TYPE_NONE;
+ break;
+
+ case CONF_DISK:
+ part_cache_type = PART_CACHE_TYPE_DISK;
+ break;
+
+ case CONF_MEMORY:
+ part_cache_type = PART_CACHE_TYPE_MEMORY;
+ break;
+
+ default:
+ conf_parserror(_("NONE, DISK or MEMORY expected"));
+ part_cache_type = PART_CACHE_TYPE_NONE;
+ break;
+ }
+
+ val_t__part_cache_type(val) = (int)part_cache_type;
+}
+
+static void
+read_host_limit(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ host_limit_t *rl = &val_t__host_limit(val);
+ ckseen(&val->seen);
+
+ rl->match_pats = NULL;
+ rl->same_host = FALSE;
+ rl->server = FALSE;
+
+ while (1) {
+ get_conftoken(CONF_ANY);
+ switch(tok) {
+ case CONF_STRING:
+ rl->match_pats = g_slist_append(rl->match_pats, g_strdup(tokenval.v.s));
+ break;
+ case CONF_SAME_HOST:
+ rl->same_host = TRUE;
+ break;
+
+ case CONF_SERVER:
+ rl->server = TRUE;
+ break;
+
+ case CONF_NL:
+ case CONF_END:
+ return;
+
+ default:
+ conf_parserror("SAME-HOST or a string expected");
+ break;
+ }
+ }
+}
+
/* get_* functions */
/* these functions use precompiler conditionals to skip useless size checks
}
static int
-get_int(void)
+get_int(
+ confunit_t unit)
{
int val;
keytab_t *save_kt;
}
/* get multiplier, if any */
- get_conftoken(CONF_ANY);
- switch(tok) {
- case CONF_NL: /* multiply by one */
- case CONF_END:
- case CONF_MULT1:
- case CONF_MULT1K:
- break;
-
- case CONF_MULT7:
- if (val > (INT_MAX / 7))
- conf_parserror(_("value too large"));
- if (val < (INT_MIN / 7))
- conf_parserror(_("value too small"));
- val *= 7;
- break;
-
- case CONF_MULT1M:
- if (val > (INT_MAX / 1024))
- conf_parserror(_("value too large"));
- if (val < (INT_MIN / 1024))
- conf_parserror(_("value too small"));
- val *= 1024;
- break;
-
- case CONF_MULT1G:
- if (val > (INT_MAX / (1024 * 1024)))
- conf_parserror(_("value too large"));
- if (val < (INT_MIN / (1024 * 1024)))
- conf_parserror(_("value too small"));
- val *= 1024 * 1024;
- break;
-
- default: /* it was not a multiplier */
- unget_conftoken();
- break;
- }
+ val = get_multiplier(val, unit);
keytable = save_kt;
return val;
}
static ssize_t
-get_size(void)
+get_size(
+ confunit_t unit)
{
ssize_t val;
keytab_t *save_kt;
}
/* get multiplier, if any */
- get_conftoken(CONF_ANY);
-
- switch(tok) {
- case CONF_NL: /* multiply by one */
- case CONF_MULT1:
- case CONF_MULT1K:
- break;
-
- case CONF_MULT7:
- if (val > (ssize_t)(SSIZE_MAX / 7))
- conf_parserror(_("value too large"));
- if (val < (ssize_t)(SSIZE_MIN / 7))
- conf_parserror(_("value too small"));
- val *= (ssize_t)7;
- break;
-
- case CONF_MULT1M:
- if (val > (ssize_t)(SSIZE_MAX / (ssize_t)1024))
- conf_parserror(_("value too large"));
- if (val < (ssize_t)(SSIZE_MIN / (ssize_t)1024))
- conf_parserror(_("value too small"));
- val *= (ssize_t)1024;
- break;
-
- case CONF_MULT1G:
- if (val > (ssize_t)(SSIZE_MAX / (1024 * 1024)))
- conf_parserror(_("value too large"));
- if (val < (ssize_t)(SSIZE_MIN / (1024 * 1024)))
- conf_parserror(_("value too small"));
- val *= (ssize_t)(1024 * 1024);
- break;
-
- default: /* it was not a multiplier */
- unget_conftoken();
- break;
- }
+ val = get_multiplier(val, unit);
keytable = save_kt;
return val;
}
static gint64
-get_int64(void)
+get_int64(
+ confunit_t unit)
{
gint64 val;
keytab_t *save_kt;
}
/* get multiplier, if any */
- get_conftoken(CONF_ANY);
+ val = get_multiplier(val, unit);
- switch(tok) {
- case CONF_NL: /* multiply by one */
- case CONF_MULT1:
- case CONF_MULT1K:
- break;
+ keytable = save_kt;
+
+ return val;
+}
- case CONF_MULT7:
+gint64
+get_multiplier(
+ gint64 val,
+ confunit_t unit)
+{
+ /* get multiplier, if any */
+ get_conftoken(CONF_ANY);
+
+ if (tok == CONF_NL || tok == CONF_END) { /* no multiplier */
+ val = val;
+ } else if (tok == CONF_MULT1 && unit == CONF_UNIT_K) {
+ val /= 1024;
+ } else if (tok == CONF_MULT1 ||
+ (tok == CONF_MULT1K && unit == CONF_UNIT_K)) {
+ val *= 1; /* multiply by one */
+ } else if (tok == CONF_MULT7) {
if (val > G_MAXINT64/7 || val < ((gint64)G_MININT64)/7)
conf_parserror(_("value too large"));
val *= 7;
- break;
-
- case CONF_MULT1M:
+ } else if (tok == CONF_MULT1K ||
+ (tok == CONF_MULT1M && unit == CONF_UNIT_K)) {
if (val > G_MAXINT64/1024 || val < ((gint64)G_MININT64)/1024)
conf_parserror(_("value too large"));
val *= 1024;
- break;
-
- case CONF_MULT1G:
+ } else if (tok == CONF_MULT1M ||
+ (tok == CONF_MULT1G && unit == CONF_UNIT_K)) {
if (val > G_MAXINT64/(1024*1024) || val < ((gint64)G_MININT64)/(1024*1024))
conf_parserror(_("value too large"));
val *= 1024*1024;
- break;
-
- default: /* it was not a multiplier */
+ } else if (tok == CONF_MULT1G ||
+ (tok == CONF_MULT1T && unit == CONF_UNIT_K)) {
+ if (val > G_MAXINT64/(1024*1024*1024) || val < ((gint64)G_MININT64)/(1024*1024*1024))
+ conf_parserror(_("value too large"));
+ val *= 1024*1024*1024;
+ } else if (tok == CONF_MULT1T) {
+ if (val > G_MAXINT64/(1024*1024*1024*1024LL) || val < ((gint64)G_MININT64)/(1024*1024*1024*1024LL))
+ conf_parserror(_("value too large"));
+ val *= 1024*1024*1024*1024LL;
+ } else {
+ val *= 1;
unget_conftoken();
- break;
}
- keytable = save_kt;
-
return val;
}
default:
unget_conftoken();
val = 3; /* a bad argument - most likely TRUE */
- conf_parserror(_("YES, NO, TRUE, FALSE, ON, OFF expected"));
+ conf_parserror(_("YES, NO, TRUE, FALSE, ON, OFF, 0, 1 expected"));
+ break;
+ }
+
+ keytable = save_kt;
+ return val;
+}
+
+static int
+get_no_yes_all(void)
+{
+ int val;
+ keytab_t *save_kt;
+
+ save_kt = keytable;
+ keytable = no_yes_all_keytable;
+
+ get_conftoken(CONF_ANY);
+
+ switch(tok) {
+ case CONF_INT:
+ val = tokenval.v.i;
+ break;
+
+ case CONF_SIZE:
+ val = tokenval.v.size;
+ break;
+
+ case CONF_INT64:
+ val = tokenval.v.int64;
+ break;
+
+ case CONF_ALL:
+ val = 2;
+ break;
+
+ case CONF_ATRUE:
+ val = 1;
+ break;
+
+ case CONF_AFALSE:
+ val = 0;
+ break;
+
+ case CONF_NL:
+ unget_conftoken();
+ val = 3; /* no argument - most likely TRUE */
+ break;
+ default:
+ unget_conftoken();
+ val = 3; /* a bad argument - most likely TRUE */
+ conf_parserror(_("%d: YES, NO, ALL, TRUE, FALSE, ON, OFF, 0, 1, 2 expected"), tok);
break;
}
+ if (val > 2 || val < 0)
+ val = 1;
keytable = save_kt;
return val;
}
conf_parserror(_("duplicate parameter; previous definition %s:%d"),
seen->filename, seen->linenum);
}
+ seen->block = current_block;
seen->filename = current_filename;
seen->linenum = current_line_num;
}
conf_parserror(_("%s must be positive"), get_token_name(np->token));
break;
default:
- conf_parserror(_("validate_nonnegative invalid type %d\n"), val->type);
+ conf_parserror(_("validate_nonnegative invalid type %d\n"), val->type);
+ }
+}
+
+static void
+validate_non_zero(
+ struct conf_var_s *np,
+ val_t *val)
+{
+ switch(val->type) {
+ case CONFTYPE_INT:
+ if(val_t__int(val) == 0)
+ conf_parserror(_("%s must not be 0"), get_token_name(np->token));
+ break;
+ case CONFTYPE_INT64:
+ if(val_t__int64(val) == 0)
+ conf_parserror(_("%s must not be 0"), get_token_name(np->token));
+ break;
+ case CONFTYPE_TIME:
+ if(val_t__time(val) == 0)
+ conf_parserror(_("%s must not be 0"), get_token_name(np->token));
+ break;
+ case CONFTYPE_SIZE:
+ if(val_t__size(val) == 0)
+ conf_parserror(_("%s must not be 0"), get_token_name(np->token));
+ break;
+ default:
+ conf_parserror(_("validate_non_zero invalid type %d\n"), val->type);
}
}
validate_port_range(val, IPPORT_RESERVED, 65535);
}
+/*
+ * Validate tmpdir, the directory must exist and be writable by the user.
+ */
+
+static void validate_tmpdir(conf_var_t *var G_GNUC_UNUSED, val_t *value)
+{
+ struct stat stat_buf;
+ gchar *tmpdir = val_t_to_str(value);
+
+ if (stat(tmpdir, &stat_buf)) {
+ conf_parserror(_("invalid TMPDIR: directory '%s': %s."),
+ tmpdir, strerror(errno));
+ } else if (!S_ISDIR(stat_buf.st_mode)) {
+ conf_parserror(_("invalid TMPDIR: '%s' is not a directory."),
+ tmpdir);
+ } else {
+ gchar *dir = g_strconcat(tmpdir, "/.", NULL);
+ if (access(dir, R_OK|W_OK) == -1) {
+ conf_parserror(_("invalid TMPDIR: '%s': can not read/write: %s."),
+ tmpdir, strerror(errno));
+ }
+ g_free(dir);
+ }
+}
+
/*
* Initialization Implementation
*/
/* store away our client-ness for later reference */
config_client = flags & CONFIG_INIT_CLIENT;
+ /* if we're using an explicit name, but the name is '.', then we're using the
+ * current directory */
+ if ((flags & CONFIG_INIT_EXPLICIT_NAME) && arg_config_name) {
+ if (0 == strcmp(arg_config_name, "."))
+ flags = (flags & (~CONFIG_INIT_EXPLICIT_NAME)) | CONFIG_INIT_USE_CWD;
+ }
+
if ((flags & CONFIG_INIT_EXPLICIT_NAME) && arg_config_name) {
config_name = newstralloc(config_name, arg_config_name);
config_dir = newvstralloc(config_dir, CONFIG_DIR, "/", arg_config_name, NULL);
config_name = stralloc(config_name + 1);
}
- amfree(cwd);
} else if (flags & CONFIG_INIT_CLIENT) {
amfree(config_name);
config_dir = newstralloc(config_dir, CONFIG_DIR);
} else {
- /* ok, then, we won't read anything (for e.g., amrestore), but
- * will set up for server-side config_overwrites */
+ /* ok, then, we won't read anything (for e.g., amrestore) */
amfree(config_name);
amfree(config_dir);
+ }
+
+ /* setup for apply_config_overrides */
+ if (flags & CONFIG_INIT_CLIENT) {
+ keytable = client_keytab;
+ parsetable = client_var;
+ } else {
keytable = server_keytab;
parsetable = server_var;
}
+ if (config_overrides) {
+ int i;
+ for (i = 0; i < config_overrides->n_used; i++) {
+ config_overrides->ovr[i].applied = FALSE;
+ }
+ }
+
+ /* apply config overrides to default setting */
+ apply_config_overrides(config_overrides, NULL);
+
/* If we have a config_dir, we can try reading something */
if (config_dir) {
if (flags & CONFIG_INIT_CLIENT) {
amfree(config_filename);
}
+ /* apply config overrides to default setting */
+ apply_config_overrides(config_overrides, NULL);
+
+ if (config_overrides) {
+ int i;
+ for (i = 0; i < config_overrides->n_used; i++) {
+ if (config_overrides->ovr[i].applied == FALSE) {
+ conf_parserror(_("unknown parameter '%s'"),
+ config_overrides->ovr[i].key);
+ }
+ }
+ }
+
update_derived_values(flags & CONFIG_INIT_CLIENT);
return cfgerr_level;
void
config_uninit(void)
{
- holdingdisk_t *hp, *hpnext;
+ GSList *hp;
+ holdingdisk_t *hd;
dumptype_t *dp, *dpnext;
tapetype_t *tp, *tpnext;
interface_t *ip, *ipnext;
pp_script_t *pp, *ppnext;
device_config_t *dc, *dcnext;
changer_config_t *cc, *ccnext;
+ interactivity_t *iv, *ivnext;
+ taperscan_t *ts, *tsnext;
int i;
if (!config_initialized) return;
- for(hp=holdinglist; hp != NULL; hp = hpnext) {
- amfree(hp->name);
- for(i=0; i<HOLDING_HOLDING-1; i++) {
- free_val_t(&hp->value[i]);
+ for(hp=holdinglist; hp != NULL; hp = hp->next) {
+ hd = hp->data;
+ amfree(hd->name);
+ for(i=0; i<HOLDING_HOLDING; i++) {
+ free_val_t(&hd->value[i]);
}
- hpnext = hp->next;
- amfree(hp);
}
+ slist_free_full(holdinglist, g_free);
holdinglist = NULL;
for(dp=dumplist; dp != NULL; dp = dpnext) {
amfree(dp->name);
- for(i=0; i<DUMPTYPE_DUMPTYPE-1; i++) {
+ for(i=0; i<DUMPTYPE_DUMPTYPE; i++) {
free_val_t(&dp->value[i]);
}
dpnext = dp->next;
for(tp=tapelist; tp != NULL; tp = tpnext) {
amfree(tp->name);
- for(i=0; i<TAPETYPE_TAPETYPE-1; i++) {
+ for(i=0; i<TAPETYPE_TAPETYPE; i++) {
free_val_t(&tp->value[i]);
}
tpnext = tp->next;
for(ip=interface_list; ip != NULL; ip = ipnext) {
amfree(ip->name);
- for(i=0; i<INTER_INTER-1; i++) {
+ for(i=0; i<INTER_INTER; i++) {
free_val_t(&ip->value[i]);
}
ipnext = ip->next;
for(ap=application_list; ap != NULL; ap = apnext) {
amfree(ap->name);
- for(i=0; i<INTER_INTER-1; i++) {
+ for(i=0; i<APPLICATION_APPLICATION; i++) {
free_val_t(&ap->value[i]);
}
apnext = ap->next;
for(pp=pp_script_list; pp != NULL; pp = ppnext) {
amfree(pp->name);
- for(i=0; i<INTER_INTER-1; i++) {
+ for(i=0; i<PP_SCRIPT_PP_SCRIPT; i++) {
free_val_t(&pp->value[i]);
}
ppnext = pp->next;
for(dc=device_config_list; dc != NULL; dc = dcnext) {
amfree(dc->name);
- for(i=0; i<INTER_INTER-1; i++) {
+ for(i=0; i<DEVICE_CONFIG_DEVICE_CONFIG; i++) {
free_val_t(&dc->value[i]);
}
dcnext = dc->next;
for(cc=changer_config_list; cc != NULL; cc = ccnext) {
amfree(cc->name);
- for(i=0; i<INTER_INTER-1; i++) {
+ for(i=0; i<CHANGER_CONFIG_CHANGER_CONFIG; i++) {
free_val_t(&cc->value[i]);
}
ccnext = cc->next;
amfree(cc);
}
-
changer_config_list = NULL;
- for(i=0; i<CNF_CNF-1; i++)
+ for(iv=interactivity_list; iv != NULL; iv = ivnext) {
+ amfree(iv->name);
+ for(i=0; i<INTERACTIVITY_INTERACTIVITY; i++) {
+ free_val_t(&iv->value[i]);
+ }
+ ivnext = iv->next;
+ amfree(iv);
+ }
+ interactivity_list = NULL;
+
+ for(ts=taperscan_list; ts != NULL; ts = tsnext) {
+ amfree(ts->name);
+ for(i=0; i<TAPERSCAN_TAPERSCAN; i++) {
+ free_val_t(&ts->value[i]);
+ }
+ tsnext = ts->next;
+ amfree(ts);
+ }
+ taperscan_list = NULL;
+
+ for(i=0; i<CNF_CNF; i++)
free_val_t(&conf_data[i]);
- if (applied_config_overwrites) {
- free_config_overwrites(applied_config_overwrites);
- applied_config_overwrites = NULL;
+ if (config_overrides) {
+ free_config_overrides(config_overrides);
+ config_overrides = NULL;
}
amfree(config_name);
amfree(config_dir);
+ amfree(config_filename);
- g_slist_free_full(seen_filenames);
+ slist_free_full(seen_filenames, g_free);
seen_filenames = NULL;
config_client = FALSE;
/* defaults for exported variables */
conf_init_str(&conf_data[CNF_ORG], DEFAULT_CONFIG);
conf_init_str(&conf_data[CNF_CONF], DEFAULT_CONFIG);
+ conf_init_str(&conf_data[CNF_AMDUMP_SERVER], DEFAULT_SERVER);
conf_init_str(&conf_data[CNF_INDEX_SERVER], DEFAULT_SERVER);
conf_init_str(&conf_data[CNF_TAPE_SERVER], DEFAULT_TAPE_SERVER);
- conf_init_str(&conf_data[CNF_AUTH], "bsd");
+ conf_init_str(&conf_data[CNF_AUTH], "bsdtcp");
conf_init_str(&conf_data[CNF_SSH_KEYS], "");
conf_init_str(&conf_data[CNF_AMANDAD_PATH], "");
conf_init_str(&conf_data[CNF_CLIENT_USERNAME], "");
+ conf_init_str(&conf_data[CNF_CLIENT_PORT], "");
conf_init_str(&conf_data[CNF_GNUTAR_LIST_DIR], GNUTAR_LISTED_INCREMENTAL_DIR);
conf_init_str(&conf_data[CNF_AMANDATES], DEFAULT_AMANDATES_FILE);
- conf_init_str(&conf_data[CNF_MAILTO], "operators");
+ conf_init_str(&conf_data[CNF_MAILTO], "");
conf_init_str(&conf_data[CNF_DUMPUSER], CLIENT_LOGIN);
conf_init_str(&conf_data[CNF_TAPEDEV], DEFAULT_TAPE_DEVICE);
- conf_init_str(&conf_data[CNF_RAWTAPEDEV], DEFAULT_TAPE_DEVICE);
conf_init_proplist(&conf_data[CNF_DEVICE_PROPERTY]);
conf_init_proplist(&conf_data[CNF_PROPERTY]);
- conf_init_str(&conf_data[CNF_CHANGERDEV], DEFAULT_CHANGER_DEVICE);
- conf_init_str(&conf_data[CNF_CHANGERFILE], "/usr/adm/amanda/changer-status");
+ conf_init_str(&conf_data[CNF_CHANGERDEV], NULL);
+ conf_init_str(&conf_data[CNF_CHANGERFILE] , "changer");
conf_init_str (&conf_data[CNF_LABELSTR] , ".*");
conf_init_str (&conf_data[CNF_TAPELIST] , "tapelist");
conf_init_str (&conf_data[CNF_DISKFILE] , "disklist");
conf_init_str (&conf_data[CNF_INFOFILE] , "/usr/adm/amanda/curinfo");
conf_init_str (&conf_data[CNF_LOGDIR] , "/usr/adm/amanda");
conf_init_str (&conf_data[CNF_INDEXDIR] , "/usr/adm/amanda/index");
- conf_init_ident (&conf_data[CNF_TAPETYPE] , "EXABYTE");
- conf_init_int (&conf_data[CNF_DUMPCYCLE] , 10);
- conf_init_int (&conf_data[CNF_RUNSPERCYCLE] , 0);
- conf_init_int (&conf_data[CNF_TAPECYCLE] , 15);
- conf_init_int (&conf_data[CNF_NETUSAGE] , 8000);
- conf_init_int (&conf_data[CNF_INPARALLEL] , 10);
+ conf_init_ident (&conf_data[CNF_TAPETYPE] , "DEFAULT_TAPE");
+ conf_init_identlist(&conf_data[CNF_HOLDINGDISK] , NULL);
+ conf_init_int (&conf_data[CNF_DUMPCYCLE] , CONF_UNIT_NONE, 10);
+ conf_init_int (&conf_data[CNF_RUNSPERCYCLE] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_TAPECYCLE] , CONF_UNIT_NONE, 15);
+ conf_init_int (&conf_data[CNF_NETUSAGE] , CONF_UNIT_K , 80000);
+ conf_init_int (&conf_data[CNF_INPARALLEL] , CONF_UNIT_NONE, 10);
conf_init_str (&conf_data[CNF_DUMPORDER] , "ttt");
- conf_init_int (&conf_data[CNF_BUMPPERCENT] , 0);
- conf_init_int64 (&conf_data[CNF_BUMPSIZE] , (gint64)10*1024);
+ conf_init_int (&conf_data[CNF_BUMPPERCENT] , CONF_UNIT_NONE, 0);
+ conf_init_int64 (&conf_data[CNF_BUMPSIZE] , CONF_UNIT_K , (gint64)10*1024);
conf_init_real (&conf_data[CNF_BUMPMULT] , 1.5);
- conf_init_int (&conf_data[CNF_BUMPDAYS] , 2);
+ conf_init_int (&conf_data[CNF_BUMPDAYS] , CONF_UNIT_NONE, 2);
conf_init_str (&conf_data[CNF_TPCHANGER] , "");
- conf_init_int (&conf_data[CNF_RUNTAPES] , 1);
- conf_init_int (&conf_data[CNF_MAXDUMPS] , 1);
- conf_init_int (&conf_data[CNF_ETIMEOUT] , 300);
- conf_init_int (&conf_data[CNF_DTIMEOUT] , 1800);
- conf_init_int (&conf_data[CNF_CTIMEOUT] , 30);
- conf_init_int (&conf_data[CNF_TAPEBUFS] , 20);
- conf_init_size (&conf_data[CNF_DEVICE_OUTPUT_BUFFER_SIZE], 40*32768);
+ conf_init_int (&conf_data[CNF_RUNTAPES] , CONF_UNIT_NONE, 1);
+ conf_init_int (&conf_data[CNF_MAXDUMPS] , CONF_UNIT_NONE, 1);
+ conf_init_int (&conf_data[CNF_MAX_DLE_BY_VOLUME] , CONF_UNIT_NONE, 1000000000);
+ conf_init_int (&conf_data[CNF_ETIMEOUT] , CONF_UNIT_NONE, 300);
+ conf_init_int (&conf_data[CNF_DTIMEOUT] , CONF_UNIT_NONE, 1800);
+ conf_init_int (&conf_data[CNF_CTIMEOUT] , CONF_UNIT_NONE, 30);
+ conf_init_size (&conf_data[CNF_DEVICE_OUTPUT_BUFFER_SIZE], CONF_UNIT_NONE, 40*32768);
conf_init_str (&conf_data[CNF_PRINTER] , "");
conf_init_str (&conf_data[CNF_MAILER] , DEFAULT_MAILER);
- conf_init_bool (&conf_data[CNF_AUTOFLUSH] , 0);
- conf_init_int (&conf_data[CNF_RESERVE] , 100);
- conf_init_int64 (&conf_data[CNF_MAXDUMPSIZE] , (gint64)-1);
+ conf_init_no_yes_all(&conf_data[CNF_AUTOFLUSH] , 0);
+ conf_init_int (&conf_data[CNF_RESERVE] , CONF_UNIT_NONE, 100);
+ conf_init_int64 (&conf_data[CNF_MAXDUMPSIZE] , CONF_UNIT_K , (gint64)-1);
conf_init_str (&conf_data[CNF_COLUMNSPEC] , "");
conf_init_bool (&conf_data[CNF_AMRECOVER_DO_FSF] , 1);
conf_init_str (&conf_data[CNF_AMRECOVER_CHANGER] , "");
conf_init_bool (&conf_data[CNF_AMRECOVER_CHECK_LABEL], 1);
conf_init_taperalgo(&conf_data[CNF_TAPERALGO] , 0);
- conf_init_int (&conf_data[CNF_FLUSH_THRESHOLD_DUMPED] , 0);
- conf_init_int (&conf_data[CNF_FLUSH_THRESHOLD_SCHEDULED], 0);
- conf_init_int (&conf_data[CNF_TAPERFLUSH] , 0);
+ conf_init_int (&conf_data[CNF_TAPER_PARALLEL_WRITE] , CONF_UNIT_NONE, 1);
+ conf_init_int (&conf_data[CNF_FLUSH_THRESHOLD_DUMPED] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_FLUSH_THRESHOLD_SCHEDULED], CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_TAPERFLUSH] , CONF_UNIT_NONE, 0);
conf_init_str (&conf_data[CNF_DISPLAYUNIT] , "k");
conf_init_str (&conf_data[CNF_KRB5KEYTAB] , "/.amanda-v5-keytab");
conf_init_str (&conf_data[CNF_KRB5PRINCIPAL] , "service/amanda");
conf_init_str (&conf_data[CNF_LABEL_NEW_TAPES] , "");
+ conf_init_bool (&conf_data[CNF_EJECT_VOLUME] , 0);
+ conf_init_bool (&conf_data[CNF_REPORT_USE_MEDIA] , TRUE);
+ conf_init_bool (&conf_data[CNF_REPORT_NEXT_MEDIA] , TRUE);
+ conf_init_str (&conf_data[CNF_TMPDIR] , "");
conf_init_bool (&conf_data[CNF_USETIMESTAMPS] , 1);
- conf_init_int (&conf_data[CNF_CONNECT_TRIES] , 3);
- conf_init_int (&conf_data[CNF_REP_TRIES] , 5);
- conf_init_int (&conf_data[CNF_REQ_TRIES] , 3);
- conf_init_int (&conf_data[CNF_DEBUG_AMANDAD] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_AMIDXTAPED] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_AMINDEXD] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_AMRECOVER] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_AUTH] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_EVENT] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_HOLDING] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_PROTOCOL] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_PLANNER] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_DRIVER] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_DUMPER] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_CHUNKER] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_TAPER] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_SELFCHECK] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_SENDSIZE] , 0);
- conf_init_int (&conf_data[CNF_DEBUG_SENDBACKUP] , 0);
+ conf_init_int (&conf_data[CNF_CONNECT_TRIES] , CONF_UNIT_NONE, 3);
+ conf_init_int (&conf_data[CNF_REP_TRIES] , CONF_UNIT_NONE, 5);
+ conf_init_int (&conf_data[CNF_REQ_TRIES] , CONF_UNIT_NONE, 3);
+ conf_init_int (&conf_data[CNF_DEBUG_DAYS] , CONF_UNIT_NONE, AMANDA_DEBUG_DAYS);
+ conf_init_int (&conf_data[CNF_DEBUG_AMANDAD] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_RECOVERY] , CONF_UNIT_NONE, 1);
+ conf_init_int (&conf_data[CNF_DEBUG_AMIDXTAPED] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_AMINDEXD] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_AMRECOVER] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_AUTH] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_EVENT] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_HOLDING] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_PROTOCOL] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_PLANNER] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_DRIVER] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_DUMPER] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_CHUNKER] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_TAPER] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_SELFCHECK] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_SENDSIZE] , CONF_UNIT_NONE, 0);
+ conf_init_int (&conf_data[CNF_DEBUG_SENDBACKUP] , CONF_UNIT_NONE, 0);
#ifdef UDPPORTRANGE
conf_init_intrange (&conf_data[CNF_RESERVED_UDP_PORT] , UDPPORTRANGE);
#else
conf_init_intrange (&conf_data[CNF_UNRESERVED_TCP_PORT] , IPPORT_RESERVED, 65535);
#endif
conf_init_send_amreport (&conf_data[CNF_SEND_AMREPORT_ON], SEND_AMREPORT_ALL);
+ conf_init_autolabel(&conf_data[CNF_AUTOLABEL]);
+ conf_init_str(&conf_data[CNF_META_AUTOLABEL], NULL);
+ conf_init_host_limit(&conf_data[CNF_RECOVERY_LIMIT]);
+ conf_init_str(&conf_data[CNF_INTERACTIVITY], NULL);
+ conf_init_str(&conf_data[CNF_TAPERSCAN], NULL);
/* reset internal variables */
config_clear_errors();
init_dumptype_defaults();
dpcur.name = stralloc("BSD-AUTH");
dpcur.seen.linenum = -1;
- free_val_t(&dpcur.value[DUMPTYPE_SECURITY_DRIVER]);
- val_t__str(&dpcur.value[DUMPTYPE_SECURITY_DRIVER]) = stralloc("BSD");
- val_t__seen(&dpcur.value[DUMPTYPE_SECURITY_DRIVER]).linenum = -1;
+ free_val_t(&dpcur.value[DUMPTYPE_AUTH]);
+ val_t__str(&dpcur.value[DUMPTYPE_AUTH]) = stralloc("BSD");
+ val_t__seen(&dpcur.value[DUMPTYPE_AUTH]).linenum = -1;
save_dumptype();
init_dumptype_defaults();
- dpcur.name = stralloc("KRB4-AUTH");
+ dpcur.name = stralloc("BSDTCP-AUTH");
dpcur.seen.linenum = -1;
- free_val_t(&dpcur.value[DUMPTYPE_SECURITY_DRIVER]);
- val_t__str(&dpcur.value[DUMPTYPE_SECURITY_DRIVER]) = stralloc("KRB4");
- val_t__seen(&dpcur.value[DUMPTYPE_SECURITY_DRIVER]).linenum = -1;
+ free_val_t(&dpcur.value[DUMPTYPE_AUTH]);
+ val_t__str(&dpcur.value[DUMPTYPE_AUTH]) = stralloc("BSDTCP");
+ val_t__seen(&dpcur.value[DUMPTYPE_AUTH]).linenum = -1;
save_dumptype();
init_dumptype_defaults();
{
char **config_options;
char **config_option;
- int n_applied_config_overwrites = 0;
+ int n_config_overrides = 0;
int i;
- if (applied_config_overwrites)
- n_applied_config_overwrites = applied_config_overwrites->n_used;
+ if (config_overrides)
+ n_config_overrides = config_overrides->n_used;
- config_options = alloc((first+n_applied_config_overwrites+1)*SIZEOF(char *));
+ config_options = alloc((first+n_config_overrides+1)*SIZEOF(char *));
config_option = config_options + first;
- for (i = 0; i < n_applied_config_overwrites; i++) {
- char *key = applied_config_overwrites->ovr[i].key;
- char *value = applied_config_overwrites->ovr[i].value;
+ for (i = 0; i < n_config_overrides; i++) {
+ char *key = config_overrides->ovr[i].key;
+ char *value = config_overrides->ovr[i].value;
*config_option = vstralloc("-o", key, "=", value, NULL);
config_option++;
}
update_derived_values(
gboolean is_client)
{
- interface_t *ip;
+ interface_t *ip;
+ identlist_t il;
+ holdingdisk_t *hd;
if (!is_client) {
/* Add a 'default' interface if one doesn't already exist */
/* Check the tapetype is defined */
if (lookup_tapetype(getconf_str(CNF_TAPETYPE)) == NULL) {
- /* Create a default tapetype */
+ /* Create a default tapetype so that other code has
+ * something to refer to, but don't pretend it's real */
if (!getconf_seen(CNF_TAPETYPE) &&
- strcmp(getconf_str(CNF_TAPETYPE), "EXABYTE") == 0 &&
- !lookup_tapetype("EXABYTE")) {
+ strcmp(getconf_str(CNF_TAPETYPE), "DEFAULT_TAPE") == 0 &&
+ !lookup_tapetype("DEFAULT_TAPE")) {
init_tapetype_defaults();
- tpcur.name = stralloc("EXABYTE");
+ tpcur.name = stralloc("DEFAULT_TAPE");
tpcur.seen = val_t__seen(getconf(CNF_TAPETYPE));
save_tapetype();
} else {
getconf_str(CNF_TAPETYPE));
}
}
+
+ /* Check the holdingdisk are defined */
+ for (il = getconf_identlist(CNF_HOLDINGDISK);
+ il != NULL; il = il->next) {
+ hd = lookup_holdingdisk(il->data);
+ if (!hd) {
+ conf_parserror(_("holdingdisk %s is not defined"),
+ (char *)il->data);
+ }
+ }
+
+ if ((getconf_seen(CNF_LABEL_NEW_TAPES) > 0 &&
+ getconf_seen(CNF_AUTOLABEL) > 0) ||
+ (getconf_seen(CNF_LABEL_NEW_TAPES) < 0 &&
+ getconf_seen(CNF_AUTOLABEL) < 0)) {
+ conf_parserror(_("Can't specify both label-new-tapes and autolabel"));
+ }
+ if ((getconf_seen(CNF_LABEL_NEW_TAPES) != 0 &&
+ getconf_seen(CNF_AUTOLABEL) == 0) ||
+ (getconf_seen(CNF_LABEL_NEW_TAPES) < 0 &&
+ getconf_seen(CNF_AUTOLABEL) >= 0)) {
+ autolabel_t *autolabel = &(conf_data[CNF_AUTOLABEL].v.autolabel);
+ autolabel->template = g_strdup(getconf_str(CNF_LABEL_NEW_TAPES));
+ if (!autolabel->template || autolabel->template == '\0') {
+ autolabel->template = NULL;
+ autolabel->autolabel = 0;
+ } else {
+ autolabel->autolabel = AL_VOLUME_ERROR | AL_EMPTY;
+ }
+ }
+
+ if (!getconf_seen(CNF_REPORT_USE_MEDIA) &&
+ getconf_seen(CNF_MAX_DLE_BY_VOLUME)) {
+ conf_init_bool(&conf_data[CNF_REPORT_USE_MEDIA], FALSE);
+ }
+ if (!getconf_seen(CNF_REPORT_NEXT_MEDIA) &&
+ getconf_seen(CNF_MAX_DLE_BY_VOLUME)) {
+ conf_init_bool(&conf_data[CNF_REPORT_NEXT_MEDIA], FALSE);
+ }
}
/* fill in the debug_* values */
debug_amandad = getconf_int(CNF_DEBUG_AMANDAD);
+ debug_recovery = getconf_int(CNF_DEBUG_RECOVERY);
debug_amidxtaped = getconf_int(CNF_DEBUG_AMIDXTAPED);
debug_amindexd = getconf_int(CNF_DEBUG_AMINDEXD);
debug_amrecover = getconf_int(CNF_DEBUG_AMRECOVER);
static void
conf_init_int(
val_t *val,
+ confunit_t unit,
int i)
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_INT;
+ val->unit = unit;
val_t__int(val) = i;
}
static void
conf_init_int64(
val_t *val,
+ confunit_t unit,
gint64 l)
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_INT64;
+ val->unit = unit;
val_t__int64(val) = l;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_REAL;
+ val->unit = CONF_UNIT_NONE;
val_t__real(val) = r;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_STR;
+ val->unit = CONF_UNIT_NONE;
if(s)
val->v.s = stralloc(s);
else
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_IDENT;
+ val->unit = CONF_UNIT_NONE;
if(s)
val->v.s = stralloc(s);
else
val->v.s = NULL;
}
+static void
+conf_init_identlist(
+ val_t *val,
+ char *s)
+{
+ val->seen.linenum = 0;
+ val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_IDENTLIST;
+ val->unit = CONF_UNIT_NONE;
+ val->v.identlist = NULL;
+ if (s)
+ val->v.identlist = g_slist_append(val->v.identlist, stralloc(s));
+}
+
static void
conf_init_time(
val_t *val,
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_TIME;
+ val->unit = CONF_UNIT_NONE;
val_t__time(val) = t;
}
static void
conf_init_size(
val_t *val,
+ confunit_t unit,
ssize_t sz)
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_SIZE;
+ val->unit = unit;
val_t__size(val) = sz;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_BOOLEAN;
+ val->unit = CONF_UNIT_NONE;
val_t__boolean(val) = i;
}
+static void
+conf_init_no_yes_all(
+ val_t *val,
+ int i)
+{
+ val->seen.linenum = 0;
+ val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_NO_YES_ALL;
+ val->unit = CONF_UNIT_NONE;
+ val_t__int(val) = i;
+}
+
static void
conf_init_compress(
val_t *val,
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_COMPRESS;
+ val->unit = CONF_UNIT_NONE;
val_t__compress(val) = (int)i;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_ENCRYPT;
+ val->unit = CONF_UNIT_NONE;
val_t__encrypt(val) = (int)i;
}
+static void
+conf_init_part_cache_type(
+ val_t *val,
+ part_cache_type_t i)
+{
+ val->seen.linenum = 0;
+ val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_PART_CACHE_TYPE;
+ val->unit = CONF_UNIT_NONE;
+ val_t__part_cache_type(val) = (int)i;
+}
+
+static void
+conf_init_host_limit(
+ val_t *val)
+{
+ val->seen.linenum = 0;
+ val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_HOST_LIMIT;
+ val->unit = CONF_UNIT_NONE;
+ val_t__host_limit(val).match_pats = NULL;
+ val_t__host_limit(val).same_host = FALSE;
+ val_t__host_limit(val).server = FALSE;
+}
+
+static void
+conf_init_host_limit_server(
+ val_t *val)
+{
+ conf_init_host_limit(val);
+ val_t__host_limit(val).server = TRUE;
+}
+
+static void
+conf_init_data_path(
+ val_t *val,
+ data_path_t i)
+{
+ val->seen.linenum = 0;
+ val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_DATA_PATH;
+ val->unit = CONF_UNIT_NONE;
+ val_t__data_path(val) = (int)i;
+}
+
static void
conf_init_holding(
val_t *val,
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_HOLDING;
+ val->unit = CONF_UNIT_NONE;
val_t__holding(val) = (int)i;
}
static void
-conf_init_estimate(
+conf_init_estimatelist(
val_t *val,
estimate_t i)
{
+ GSList *estimates = NULL;
val->seen.linenum = 0;
val->seen.filename = NULL;
- val->type = CONFTYPE_ESTIMATE;
- val_t__estimate(val) = i;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_ESTIMATELIST;
+ val->unit = CONF_UNIT_NONE;
+ estimates = g_slist_append(estimates, GINT_TO_POINTER(i));
+ val_t__estimatelist(val) = estimates;
}
static void
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->unit = CONF_UNIT_NONE;
val->type = CONFTYPE_STRATEGY;
val_t__strategy(val) = i;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_TAPERALGO;
+ val->unit = CONF_UNIT_NONE;
val_t__taperalgo(val) = i;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_PRIORITY;
+ val->unit = CONF_UNIT_NONE;
val_t__priority(val) = i;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_RATE;
+ val->unit = CONF_UNIT_NONE;
val_t__rate(val)[0] = r1;
val_t__rate(val)[1] = r2;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_EXINCLUDE;
+ val->unit = CONF_UNIT_NONE;
val_t__exinclude(val).optional = 0;
val_t__exinclude(val).sl_list = NULL;
val_t__exinclude(val).sl_file = NULL;
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_INTRANGE;
+ val->unit = CONF_UNIT_NONE;
val_t__intrange(val)[0] = i1;
val_t__intrange(val)[1] = i2;
}
+static void
+conf_init_autolabel(
+ val_t *val) {
+ val->seen.linenum = 0;
+ val->seen.filename = NULL;
+ val->seen.block = NULL;
+ val->type = CONFTYPE_AUTOLABEL;
+ val->unit = CONF_UNIT_NONE;
+ val->v.autolabel.template = NULL;
+ val->v.autolabel.autolabel = 0;
+}
+
+void
+free_property_t(
+ gpointer p)
+{
+ property_t *propery = (property_t *)p;
+ slist_free_full(propery->values, g_free);
+ amfree(propery);
+}
+
static void
conf_init_proplist(
val_t *val)
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_PROPLIST;
+ val->unit = CONF_UNIT_NONE;
val_t__proplist(val) =
- g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
+ g_hash_table_new_full(g_str_amanda_hash, g_str_amanda_equal,
+ &g_free, &free_property_t);
}
static void
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_EXECUTE_ON;
+ val->unit = CONF_UNIT_NONE;
val->v.i = i;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_EXECUTE_WHERE;
+ val->unit = CONF_UNIT_NONE;
val->v.i = i;
}
{
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_SEND_AMREPORT_ON;
+ val->unit = CONF_UNIT_NONE;
val->v.i = i;
}
-static void conf_init_pp_scriptlist(val_t *val) {
- val->seen.linenum = 0;
- val->seen.filename = NULL;
- val->type = CONFTYPE_PP_SCRIPTLIST;
- val->v.proplist = NULL;
-}
-
static void conf_init_application(val_t *val) {
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
val->type = CONFTYPE_APPLICATION;
- val->v.application = NULL;
+ val->unit = CONF_UNIT_NONE;
+ val->v.s = NULL;
}
tapetype_t *tp;
dumptype_t *dp;
interface_t *ip;
- holdingdisk_t *hp;
+ holdingdisk_t *hd;
+ GSList *hp;
application_t *ap;
pp_script_t *pp;
device_config_t *dc;
changer_config_t *cc;
+ interactivity_t *iv;
+ taperscan_t *ts;
GSList *rv = NULL;
if (strcasecmp(listname,"tapetype") == 0) {
}
} else if (strcasecmp(listname,"holdingdisk") == 0) {
for(hp = holdinglist; hp != NULL; hp=hp->next) {
- rv = g_slist_append(rv, hp->name);
+ hd = hp->data;
+ rv = g_slist_append(rv, hd->name);
}
} else if (strcasecmp(listname,"interface") == 0) {
for(ip = interface_list; ip != NULL; ip=ip->next) {
rv = g_slist_append(rv, ip->name);
}
} else if (strcasecmp(listname,"application_tool") == 0
- || strcasecmp(listname,"application-tool") == 0) {
+ || strcasecmp(listname,"application-tool") == 0
+ || strcasecmp(listname,"application") == 0) {
for(ap = application_list; ap != NULL; ap=ap->next) {
rv = g_slist_append(rv, ap->name);
}
} else if (strcasecmp(listname,"script_tool") == 0
- || strcasecmp(listname,"script-tool") == 0) {
+ || strcasecmp(listname,"script-tool") == 0
+ || strcasecmp(listname,"script") == 0) {
for(pp = pp_script_list; pp != NULL; pp=pp->next) {
rv = g_slist_append(rv, pp->name);
}
for(cc = changer_config_list; cc != NULL; cc=cc->next) {
rv = g_slist_append(rv, cc->name);
}
+ } else if (strcasecmp(listname,"interactivity") == 0) {
+ for(iv = interactivity_list; iv != NULL; iv=iv->next) {
+ rv = g_slist_append(rv, iv->name);
+ }
+ } else if (strcasecmp(listname,"taperscan") == 0) {
+ for(ts = taperscan_list; ts != NULL; ts=ts->next) {
+ rv = g_slist_append(rv, ts->name);
+ }
}
return rv;
}
conf_parserror("program must be \"DUMP\", \"GNUTAR\", \"STAR\" or \"APPLICATION\"");
}
+static void
+validate_dump_limit(
+ conf_var_t *np G_GNUC_UNUSED,
+ val_t *val)
+{
+ if (val->v.host_limit.match_pats) {
+ conf_parserror("dump-limit can't specify hostname");
+ }
+}
char *
tapetype_name(
lookup_holdingdisk(
char *str)
{
- holdingdisk_t *p;
+ GSList *hp;
+ holdingdisk_t *hd;
- for(p = holdinglist; p != NULL; p = p->next) {
- if(strcasecmp(p->name, str) == 0) return p;
+ for (hp = holdinglist; hp != NULL; hp = hp->next) {
+ hd = hp->data;
+ if (strcasecmp(hd->name, str) == 0) return hd;
}
return NULL;
}
-holdingdisk_t *
+GSList *
getconf_holdingdisks(
void)
{
return holdinglist;
}
-holdingdisk_t *
-holdingdisk_next(
- holdingdisk_t *hdisk)
-{
- if (hdisk) return hdisk->next;
- return NULL;
-}
-
val_t *
holdingdisk_getconf(
holdingdisk_t *hdisk,
return ap->name;
}
+interactivity_t *
+lookup_interactivity(
+ char *str)
+{
+ interactivity_t *p;
+
+ for(p = interactivity_list; p != NULL; p = p->next) {
+ if(strcasecmp(p->name, str) == 0) return p;
+ }
+ return NULL;
+}
+
+val_t *
+interactivity_getconf(
+ interactivity_t *iv,
+ interactivity_key key)
+{
+ assert(iv != NULL);
+ assert(key < INTERACTIVITY_INTERACTIVITY);
+ return &iv->value[key];
+}
+
+char *
+interactivity_name(
+ interactivity_t *iv)
+{
+ assert(iv != NULL);
+ return iv->name;
+}
+
+taperscan_t *
+lookup_taperscan(
+ char *str)
+{
+ taperscan_t *p;
+
+ for(p = taperscan_list; p != NULL; p = p->next) {
+ if(strcasecmp(p->name, str) == 0) return p;
+ }
+ return NULL;
+}
+
+val_t *
+taperscan_getconf(
+ taperscan_t *ts,
+ taperscan_key key)
+{
+ assert(ts != NULL);
+ assert(key < TAPERSCAN_TAPERSCAN);
+ return &ts->value[key];
+}
+
+char *
+taperscan_name(
+ taperscan_t *ts)
+{
+ assert(ts != NULL);
+ return ts->name;
+}
+
pp_script_t *
lookup_pp_script(
char *str)
* Command-line Handling Implementation
*/
-config_overwrites_t *
-new_config_overwrites(
+config_overrides_t *
+new_config_overrides(
int size_estimate)
{
- config_overwrites_t *co;
+ config_overrides_t *co;
if (size_estimate <= 0)
size_estimate = 10;
}
void
-free_config_overwrites(
- config_overwrites_t *co)
+free_config_overrides(
+ config_overrides_t *co)
{
int i;
amfree(co);
}
-void add_config_overwrite(
- config_overwrites_t *co,
+void add_config_override(
+ config_overrides_t *co,
char *key,
char *value)
{
}
void
-add_config_overwrite_opt(
- config_overwrites_t *co,
+add_config_override_opt(
+ config_overrides_t *co,
char *optarg)
{
char *value;
assert(optarg != NULL);
- value = index(optarg, '=');
+ value = strchr(optarg, '=');
if (value == NULL) {
error(_("Must specify a value for %s."), optarg);
/* NOTREACHED */
}
*value = '\0';
- add_config_overwrite(co, optarg, value+1);
+ add_config_override(co, optarg, value+1);
*value = '=';
}
-config_overwrites_t *
-extract_commandline_config_overwrites(
+config_overrides_t *
+extract_commandline_config_overrides(
int *argc,
char ***argv)
{
int i, j, moveup;
- config_overwrites_t *co = new_config_overwrites(*argc/2);
+ config_overrides_t *co = new_config_overrides(*argc/2);
i = 0;
while (i<*argc) {
if(strncmp((*argv)[i],"-o",2) == 0) {
if(strlen((*argv)[i]) > 2) {
- add_config_overwrite_opt(co, (*argv)[i]+2);
+ add_config_override_opt(co, (*argv)[i]+2);
moveup = 1;
}
else {
if (i+1 >= *argc) error(_("expect something after -o"));
- add_config_overwrite_opt(co, (*argv)[i+1]);
+ add_config_override_opt(co, (*argv)[i+1]);
moveup = 2;
}
return co;
}
-cfgerr_level_t
-apply_config_overwrites(
- config_overwrites_t *co)
+void
+set_config_overrides(
+ config_overrides_t *co)
+{
+ int i;
+
+ config_overrides = co;
+
+ for (i = 0; i < co->n_used; i++) {
+ g_debug("config_overrides: %s %s", co->ovr[i].key, co->ovr[i].value);
+ }
+
+ return;
+}
+
+static cfgerr_level_t
+apply_config_overrides(
+ config_overrides_t *co,
+ char *key_ovr)
{
int i;
val_t *key_val;
conf_var_t *key_parm;
+ if (key_ovr && strncasecmp(key_ovr, key, strlen(key_ovr)) != 0) {
+ continue;
+ }
+
if (!parm_key_info(key, &key_parm, &key_val)) {
- conf_parserror(_("unknown parameter '%s'"), key);
+ /* not an error, only default config is loaded */
continue;
}
/* now set up a fake line and use the relevant read_function to
* parse it. This is sneaky! */
-
if (key_parm->type == CONFTYPE_STR) {
- current_line = vstralloc("\"", value, "\"", NULL);
+ current_line = quote_string_always(value);
} else {
current_line = stralloc(value);
}
token_pushed = 0;
current_line_num = -2;
allow_overwrites = 1;
+ co->ovr[i].applied = TRUE;
key_parm->read_function(key_parm, key_val);
if ((key_parm)->validate_function)
current_char = NULL;
}
- /* merge these overwrites with previous overwrites, if necessary */
- if (applied_config_overwrites) {
- for (i = 0; i < co->n_used; i++) {
- char *key = co->ovr[i].key;
- char *value = co->ovr[i].value;
-
- add_config_overwrite(applied_config_overwrites, key, value);
- }
- free_config_overwrites(co);
- } else {
- applied_config_overwrites = co;
- }
-
- update_derived_values(config_client);
-
return cfgerr_level;
}
val_t_to_int(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_INT) {
error(_("val_t_to_int: val.type is not CONFTYPE_INT"));
/*NOTREACHED*/
val_t_to_int64(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_INT64) {
error(_("val_t_to_int64: val.type is not CONFTYPE_INT64"));
/*NOTREACHED*/
val_t_to_real(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_REAL) {
error(_("val_t_to_real: val.type is not CONFTYPE_REAL"));
/*NOTREACHED*/
val_t_to_str(
val_t *val)
{
+ assert(config_initialized);
/* support CONFTYPE_IDENT, too */
if (val->type != CONFTYPE_STR && val->type != CONFTYPE_IDENT) {
error(_("val_t_to_str: val.type is not CONFTYPE_STR nor CONFTYPE_IDENT"));
val_t_to_ident(
val_t *val)
{
+ assert(config_initialized);
/* support CONFTYPE_STR, too */
if (val->type != CONFTYPE_STR && val->type != CONFTYPE_IDENT) {
error(_("val_t_to_ident: val.type is not CONFTYPE_IDENT nor CONFTYPE_STR"));
return val_t__str(val);
}
+identlist_t
+val_t_to_identlist(
+ val_t *val)
+{
+ assert(config_initialized);
+ if (val->type != CONFTYPE_IDENTLIST) {
+ error(_("val_t_to_ident: val.type is not CONFTYPE_IDENTLIST"));
+ /*NOTREACHED*/
+ }
+ return val_t__identlist(val);
+}
+
time_t
val_t_to_time(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_TIME) {
error(_("val_t_to_time: val.type is not CONFTYPE_TIME"));
/*NOTREACHED*/
val_t_to_size(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_SIZE) {
error(_("val_t_to_size: val.type is not CONFTYPE_SIZE"));
/*NOTREACHED*/
val_t_to_boolean(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_BOOLEAN) {
error(_("val_t_to_bool: val.type is not CONFTYPE_BOOLEAN"));
/*NOTREACHED*/
return val_t__boolean(val);
}
+int
+val_t_to_no_yes_all(
+ val_t *val)
+{
+ assert(config_initialized);
+ if (val->type != CONFTYPE_NO_YES_ALL) {
+ error(_("val_t_to_no_yes_all: val.type is not CONFTYPE_NO_YES_ALL"));
+ /*NOTREACHED*/
+ }
+ return val_t__no_yes_all(val);
+}
+
comp_t
val_t_to_compress(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_COMPRESS) {
error(_("val_t_to_compress: val.type is not CONFTYPE_COMPRESS"));
/*NOTREACHED*/
val_t_to_encrypt(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_ENCRYPT) {
error(_("val_t_to_encrypt: val.type is not CONFTYPE_ENCRYPT"));
/*NOTREACHED*/
return val_t__encrypt(val);
}
+part_cache_type_t
+val_t_to_part_cache_type(
+ val_t *val)
+{
+ assert(config_initialized);
+ if (val->type != CONFTYPE_PART_CACHE_TYPE) {
+ error(_("val_t_to_part_cache_type: val.type is not CONFTYPE_PART_CACHE_TYPE"));
+ /*NOTREACHED*/
+ }
+ return val_t__part_cache_type(val);
+}
+
+host_limit_t *
+val_t_to_host_limit(
+ val_t *val)
+{
+ assert(config_initialized);
+ if (val->type != CONFTYPE_HOST_LIMIT) {
+ error(_("val_t_to_host_limit: val.type is not CONFTYPE_HOST_LIMIT"));
+ /*NOTREACHED*/
+ }
+ return &val_t__host_limit(val);
+}
+
dump_holdingdisk_t
val_t_to_holding(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_HOLDING) {
error(_("val_t_to_hold: val.type is not CONFTYPE_HOLDING"));
/*NOTREACHED*/
return val_t__holding(val);
}
-estimate_t
-val_t_to_estimate(
+estimatelist_t
+val_t_to_estimatelist(
val_t *val)
{
- if (val->type != CONFTYPE_ESTIMATE) {
- error(_("val_t_to_estimate: val.type is not CONFTYPE_ESTIMATE"));
+ assert(config_initialized);
+ if (val->type != CONFTYPE_ESTIMATELIST) {
+ error(_("val_t_to_estimatelist: val.type is not CONFTYPE_ESTIMATELIST"));
/*NOTREACHED*/
}
- return val_t__estimate(val);
+ return val_t__estimatelist(val);
}
strategy_t
val_t_to_strategy(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_STRATEGY) {
error(_("val_t_to_strategy: val.type is not CONFTYPE_STRATEGY"));
/*NOTREACHED*/
val_t_to_taperalgo(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_TAPERALGO) {
error(_("val_t_to_taperalgo: val.type is not CONFTYPE_TAPERALGO"));
/*NOTREACHED*/
val_t_to_send_amreport(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_SEND_AMREPORT_ON) {
error(_("val_t_to_send_amreport: val.type is not CONFTYPE_SEND_AMREPORT_ON"));
/*NOTREACHED*/
return val_t__send_amreport(val);
}
+data_path_t
+val_t_to_data_path(
+ val_t *val)
+{
+ assert(config_initialized);
+ if (val->type != CONFTYPE_DATA_PATH) {
+ error(_("val_t_to_data_path: val.type is not CONFTYPE_DATA_PATH"));
+ /*NOTREACHED*/
+ }
+ return val_t__data_path(val);
+}
+
int
val_t_to_priority(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_PRIORITY) {
error(_("val_t_to_priority: val.type is not CONFTYPE_PRIORITY"));
/*NOTREACHED*/
val_t_to_rate(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_RATE) {
error(_("val_t_to_rate: val.type is not CONFTYPE_RATE"));
/*NOTREACHED*/
val_t_to_exinclude(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_EXINCLUDE) {
error(_("val_t_to_exinclude: val.type is not CONFTYPE_EXINCLUDE"));
/*NOTREACHED*/
val_t_to_intrange(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_INTRANGE) {
error(_("val_t_to_intrange: val.type is not CONFTYPE_INTRANGE"));
/*NOTREACHED*/
val_t_to_proplist(
val_t *val)
{
+ assert(config_initialized);
if (val->type != CONFTYPE_PROPLIST) {
error(_("val_t_to_proplist: val.type is not CONFTYPE_PROPLIST"));
/*NOTREACHED*/
return val_t__proplist(val);
}
+autolabel_t
+val_t_to_autolabel(
+ val_t *val)
+{
+ assert(config_initialized);
+ if (val->type != CONFTYPE_AUTOLABEL) {
+ error(_("val_t_to_autolabel: val.type is not CONFTYPE_AUTOLABEL"));
+ /*NOTREACHED*/
+ }
+ return val_t__autolabel(val);
+}
+
+static void
+merge_val_t(
+ val_t *valdst,
+ val_t *valsrc)
+{
+ if (valsrc->type == CONFTYPE_PROPLIST) {
+ if (valsrc->v.proplist) {
+ if (valdst->v.proplist == NULL ||
+ g_hash_table_size(valdst->v.proplist) == 0) {
+ valdst->seen.block = current_block;
+ valdst->seen.filename = current_filename;
+ valdst->seen.linenum = current_line_num;
+ }
+ if (valdst->v.proplist == NULL) {
+ valdst->v.proplist = g_hash_table_new_full(g_str_amanda_hash,
+ g_str_amanda_equal,
+ &g_free,
+ &free_property_t);
+ g_hash_table_foreach(valsrc->v.proplist,
+ ©_proplist_foreach_fn,
+ valdst->v.proplist);
+ } else {
+ g_hash_table_foreach(valsrc->v.proplist,
+ &merge_proplist_foreach_fn,
+ valdst->v.proplist);
+ }
+ }
+ } else if (valsrc->type == CONFTYPE_IDENTLIST) {
+ if (valsrc->v.identlist) {
+ identlist_t il;
+ for (il = valsrc->v.identlist; il != NULL; il = il->next) {
+ valdst->v.identlist = g_slist_append(valdst->v.identlist,
+ stralloc((char *)il->data));
+ }
+ }
+ } else {
+ free_val_t(valdst);
+ copy_val_t(valdst, valsrc);
+ }
+}
+
static void
copy_val_t(
val_t *valdst,
val_t *valsrc)
{
+ GSList *ia;
+
if(valsrc->seen.linenum) {
valdst->type = valsrc->type;
valdst->seen = valsrc->seen;
switch(valsrc->type) {
case CONFTYPE_INT:
case CONFTYPE_BOOLEAN:
+ case CONFTYPE_NO_YES_ALL:
case CONFTYPE_COMPRESS:
case CONFTYPE_ENCRYPT:
case CONFTYPE_HOLDING:
- case CONFTYPE_ESTIMATE:
case CONFTYPE_EXECUTE_ON:
case CONFTYPE_EXECUTE_WHERE:
case CONFTYPE_SEND_AMREPORT_ON:
+ case CONFTYPE_DATA_PATH:
case CONFTYPE_STRATEGY:
case CONFTYPE_TAPERALGO:
case CONFTYPE_PRIORITY:
+ case CONFTYPE_PART_CACHE_TYPE:
valdst->v.i = valsrc->v.i;
break;
valdst->v.s = stralloc(valsrc->v.s);
break;
+ case CONFTYPE_IDENTLIST:
+ valdst->v.identlist = NULL;
+ for (ia = valsrc->v.identlist; ia != NULL; ia = ia->next) {
+ valdst->v.identlist = g_slist_append(valdst->v.identlist,
+ stralloc(ia->data));
+ }
+ break;
+
+ case CONFTYPE_HOST_LIMIT:
+ valdst->v.host_limit = valsrc->v.host_limit;
+ valdst->v.host_limit.match_pats = NULL;
+ for (ia = valsrc->v.host_limit.match_pats; ia != NULL; ia = ia->next) {
+ valdst->v.host_limit.match_pats =
+ g_slist_append(valdst->v.host_limit.match_pats, g_strdup(ia->data));
+ }
+ break;
+
case CONFTYPE_TIME:
valdst->v.t = valsrc->v.t;
break;
+ case CONFTYPE_ESTIMATELIST: {
+ estimatelist_t estimates = valsrc->v.estimatelist;
+ estimatelist_t dst_estimates = NULL;
+ while (estimates != NULL) {
+ dst_estimates = g_slist_append(dst_estimates, estimates->data);
+ estimates = estimates->next;
+ }
+ valdst->v.estimatelist = dst_estimates;
+ break;
+ }
+
case CONFTYPE_EXINCLUDE:
valdst->v.exinclude.optional = valsrc->v.exinclude.optional;
valdst->v.exinclude.sl_list = duplicate_sl(valsrc->v.exinclude.sl_list);
case CONFTYPE_PROPLIST:
if (valsrc->v.proplist) {
- valdst->v.proplist = g_hash_table_new_full(g_str_hash,
- g_str_equal,
- NULL, NULL);
+ valdst->v.proplist = g_hash_table_new_full(g_str_amanda_hash,
+ g_str_amanda_equal,
+ &g_free,
+ &free_property_t);
- g_hash_table_foreach(valsrc->v.proplist, ©_proplist,
+ g_hash_table_foreach(valsrc->v.proplist,
+ ©_proplist_foreach_fn,
valdst->v.proplist);
} else {
valdst->v.proplist = NULL;
}
break;
- case CONFTYPE_PP_SCRIPTLIST:
- valdst->v.pp_scriptlist = NULL;
- if (valsrc->v.pp_scriptlist) {
- g_slist_foreach(valsrc->v.pp_scriptlist, ©_pp_scriptlist,
- valdst->v.pp_scriptlist);
- }
+ case CONFTYPE_APPLICATION:
+ valdst->v.s = stralloc(valsrc->v.s);
+ break;
+
+ case CONFTYPE_AUTOLABEL:
+ valdst->v.autolabel.template = stralloc(valsrc->v.autolabel.template);
+ valdst->v.autolabel.autolabel = valsrc->v.autolabel.autolabel;
break;
+ }
+ }
+}
+
+static void
+merge_proplist_foreach_fn(
+ gpointer key_p,
+ gpointer value_p,
+ gpointer user_data_p)
+{
+ char *property_s = key_p;
+ property_t *property = value_p;
+ proplist_t proplist = user_data_p;
+ GSList *elem = NULL;
+ int new_prop = 0;
+ property_t *new_property = g_hash_table_lookup(proplist, property_s);
+ if (new_property && !property->append) {
+ g_hash_table_remove(proplist, property_s);
+ new_property = NULL;
+ }
+ if (!new_property) {
+ new_property = malloc(sizeof(property_t));
+ new_property->seen = property->seen;
+ new_property->append = property->append;
+ new_property->priority = property->priority;
+ new_property->values = NULL;
+ new_prop = 1;
+ }
- case CONFTYPE_APPLICATION:
- valdst->v.application = valsrc->v.application;
- break;
- }
+ for(elem = property->values;elem != NULL; elem=elem->next) {
+ new_property->values = g_slist_append(new_property->values,
+ stralloc(elem->data));
}
+ if (new_prop)
+ g_hash_table_insert(proplist, stralloc(property_s), new_property);
}
static void
-copy_proplist(
+copy_proplist_foreach_fn(
gpointer key_p,
gpointer value_p,
gpointer user_data_p)
property_t *new_property = malloc(sizeof(property_t));
new_property->append = property->append;
new_property->priority = property->priority;
+ new_property->seen = property->seen;
new_property->values = NULL;
for(elem = property->values;elem != NULL; elem=elem->next) {
new_property->values = g_slist_append(new_property->values,
stralloc(elem->data));
}
- g_hash_table_insert(proplist, property_s, new_property);
-}
-
-static void
-copy_pp_scriptlist(
- gpointer data_p,
- gpointer user_data_p)
-{
- pp_script_t *pp_script = data_p;
- pp_scriptlist_t pp_scriptlist = user_data_p;
-
- pp_scriptlist = g_slist_append(pp_scriptlist, pp_script);
+ g_hash_table_insert(proplist, stralloc(property_s), new_property);
}
static void
switch(val->type) {
case CONFTYPE_INT:
case CONFTYPE_BOOLEAN:
+ case CONFTYPE_NO_YES_ALL:
case CONFTYPE_COMPRESS:
case CONFTYPE_ENCRYPT:
case CONFTYPE_HOLDING:
- case CONFTYPE_ESTIMATE:
case CONFTYPE_EXECUTE_WHERE:
case CONFTYPE_EXECUTE_ON:
case CONFTYPE_SEND_AMREPORT_ON:
+ case CONFTYPE_DATA_PATH:
case CONFTYPE_STRATEGY:
case CONFTYPE_SIZE:
case CONFTYPE_TAPERALGO:
case CONFTYPE_REAL:
case CONFTYPE_RATE:
case CONFTYPE_INTRANGE:
+ case CONFTYPE_PART_CACHE_TYPE:
break;
case CONFTYPE_IDENT:
case CONFTYPE_STR:
+ case CONFTYPE_APPLICATION:
amfree(val->v.s);
break;
+ case CONFTYPE_IDENTLIST:
+ slist_free_full(val->v.identlist, g_free);
+ break;
+
+ case CONFTYPE_HOST_LIMIT:
+ slist_free_full(val->v.host_limit.match_pats, g_free);
+ break;
+
case CONFTYPE_TIME:
break;
+ case CONFTYPE_ESTIMATELIST:
+ g_slist_free(val->v.estimatelist);
+ break;
+
case CONFTYPE_EXINCLUDE:
free_sl(val_t__exinclude(val).sl_list);
free_sl(val_t__exinclude(val).sl_file);
g_hash_table_destroy(val_t__proplist(val));
break;
- case CONFTYPE_PP_SCRIPTLIST:
- g_slist_free_full(val->v.pp_scriptlist);
- break;
-
- case CONFTYPE_APPLICATION:
+ case CONFTYPE_AUTOLABEL:
+ amfree(val->v.autolabel.template);
break;
}
val->seen.linenum = 0;
val->seen.filename = NULL;
+ val->seen.block = NULL;
}
/*
if(strcmp(string, "conf")==0) {
return(getconf_str(CNF_CONF));
+ } else if(strcmp(string, "amdump_server")==0) {
+ return(getconf_str(CNF_AMDUMP_SERVER));
} else if(strcmp(string, "index_server")==0) {
return(getconf_str(CNF_INDEX_SERVER));
} else if(strcmp(string, "tape_server")==0) {
return(getconf_str(CNF_AMANDAD_PATH));
} else if(strcmp(string, "client_username")==0) {
return(getconf_str(CNF_CLIENT_USERNAME));
+ } else if(strcmp(string, "client_port")==0) {
+ return(getconf_str(CNF_CLIENT_PORT));
} else if(strcmp(string, "gnutar_list_dir")==0) {
return(getconf_str(CNF_GNUTAR_LIST_DIR));
} else if(strcmp(string, "amandates")==0) {
}
void
-dump_configuration(void)
+dump_configuration(
+ gboolean print_default,
+ gboolean print_source)
{
tapetype_t *tp;
dumptype_t *dp;
interface_t *ip;
- holdingdisk_t *hp;
+ holdingdisk_t *hd;
+ GSList *hp;
application_t *ap;
pp_script_t *ps;
device_config_t *dc;
changer_config_t *cc;
+ interactivity_t *iv;
+ taperscan_t *ts;
int i;
conf_var_t *np;
keytab_t *kt;
if(kt->token == CONF_UNKNOWN)
error(_("server bad token"));
- val_t_print_token(stdout, NULL, "%-21s ", kt, &conf_data[np->parm]);
+ val_t_print_token(print_default, print_source, stdout, NULL, "%-21s ", kt, &conf_data[np->parm]);
}
for(hp = holdinglist; hp != NULL; hp = hp->next) {
- g_printf("\nHOLDINGDISK %s {\n", hp->name);
+ hd = hp->data;
+ g_printf("\nDEFINE HOLDINGDISK %s {\n", hd->name);
for(i=0; i < HOLDING_HOLDING; i++) {
for(np=holding_var; np->token != CONF_UNKNOWN; np++) {
if(np->parm == i)
if(kt->token == CONF_UNKNOWN)
error(_("holding bad token"));
- val_t_print_token(stdout, NULL, " %-9s ", kt, &hp->value[i]);
+ val_t_print_token(print_default, print_source, stdout, NULL, " %-9s ", kt, &hd->value[i]);
}
g_printf("}\n");
}
if(kt->token == CONF_UNKNOWN)
error(_("tapetype bad token"));
- val_t_print_token(stdout, prefix, " %-9s ", kt, &tp->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-9s ", kt, &tp->value[i]);
}
g_printf("%s}\n", prefix);
}
if(kt->token == CONF_UNKNOWN)
error(_("dumptype bad token"));
- val_t_print_token(stdout, prefix, " %-19s ", kt, &dp->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &dp->value[i]);
}
g_printf("%s}\n", prefix);
}
if(kt->token == CONF_UNKNOWN)
error(_("interface bad token"));
- val_t_print_token(stdout, prefix, " %-19s ", kt, &ip->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &ip->value[i]);
}
g_printf("%s}\n",prefix);
}
prefix = "#";
else
prefix = "";
- g_printf("\n%sDEFINE APPLICATION-TOOL %s {\n", prefix, ap->name);
+ g_printf("\n%sDEFINE APPLICATION %s {\n", prefix, ap->name);
for(i=0; i < APPLICATION_APPLICATION; i++) {
for(np=application_var; np->token != CONF_UNKNOWN; np++)
if(np->parm == i) break;
if(np->token == CONF_UNKNOWN)
- error(_("application-tool bad value"));
+ error(_("application bad value"));
for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
if(kt->token == np->token) break;
if(kt->token == CONF_UNKNOWN)
error(_("application bad token"));
- val_t_print_token(stdout, prefix, " %-19s ", kt, &ap->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &ap->value[i]);
}
g_printf("%s}\n",prefix);
}
prefix = "#";
else
prefix = "";
- g_printf("\n%sDEFINE SCRIPT-TOOL %s {\n", prefix, ps->name);
+ g_printf("\n%sDEFINE SCRIPT %s {\n", prefix, ps->name);
for(i=0; i < PP_SCRIPT_PP_SCRIPT; i++) {
for(np=pp_script_var; np->token != CONF_UNKNOWN; np++)
if(np->parm == i) break;
if(np->token == CONF_UNKNOWN)
- error(_("script-tool bad value"));
+ error(_("script bad value"));
for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
if(kt->token == np->token) break;
if(kt->token == CONF_UNKNOWN)
error(_("script bad token"));
- val_t_print_token(stdout, prefix, " %-19s ", kt, &ps->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &ps->value[i]);
}
g_printf("%s}\n",prefix);
}
if(kt->token == CONF_UNKNOWN)
error(_("device bad token"));
- val_t_print_token(stdout, prefix, " %-19s ", kt, &dc->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &dc->value[i]);
}
g_printf("%s}\n",prefix);
}
if(kt->token == CONF_UNKNOWN)
error(_("changer bad token"));
- val_t_print_token(stdout, prefix, " %-19s ", kt, &cc->value[i]);
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &cc->value[i]);
+ }
+ g_printf("%s}\n",prefix);
+ }
+
+ for(iv = interactivity_list; iv != NULL; iv = iv->next) {
+ prefix = "";
+ g_printf("\n%sDEFINE INTERACTIVITY %s {\n", prefix, iv->name);
+ for(i=0; i < INTERACTIVITY_INTERACTIVITY; i++) {
+ for(np=interactivity_var; np->token != CONF_UNKNOWN; np++)
+ if(np->parm == i) break;
+ if(np->token == CONF_UNKNOWN)
+ error(_("interactivity bad value"));
+
+ for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
+ if(kt->token == np->token) break;
+ if(kt->token == CONF_UNKNOWN)
+ error(_("interactivity bad token"));
+
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &iv->value[i]);
+ }
+ g_printf("%s}\n",prefix);
+ }
+
+ for(ts = taperscan_list; ts != NULL; ts = ts->next) {
+ prefix = "";
+ g_printf("\n%sDEFINE TAPERSCAN %s {\n", prefix, ts->name);
+ for(i=0; i < TAPERSCAN_TAPERSCAN; i++) {
+ for(np=taperscan_var; np->token != CONF_UNKNOWN; np++)
+ if(np->parm == i) break;
+ if(np->token == CONF_UNKNOWN)
+ error(_("taperscan bad value"));
+
+ for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
+ if(kt->token == np->token) break;
+ if(kt->token == CONF_UNKNOWN)
+ error(_("taperscan bad token"));
+
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &ts->value[i]);
}
g_printf("%s}\n",prefix);
}
}
+void dump_dumptype(
+ dumptype_t *dp,
+ char *prefix,
+ gboolean print_default,
+ gboolean print_source)
+{
+ int i;
+ conf_var_t *np;
+ keytab_t *kt;
+
+ for(i=0; i < DUMPTYPE_DUMPTYPE; i++) {
+ for(np=dumptype_var; np->token != CONF_UNKNOWN; np++)
+ if(np->parm == i) break;
+ if(np->token == CONF_UNKNOWN)
+ error(_("dumptype bad value"));
+
+ for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
+ if(kt->token == np->token) break;
+ if(kt->token == CONF_UNKNOWN)
+ error(_("dumptype bad token"));
+
+ val_t_print_token(print_default, print_source, stdout, prefix, " %-19s ", kt, &dp->value[i]);
+ }
+}
+
static void
val_t_print_token(
+ gboolean print_default,
+ gboolean print_source,
FILE *output,
char *prefix,
char *format,
val_t *val)
{
char **dispstrs, **dispstr;
- dispstrs = val_t_display_strs(val, 1);
+
+ if (print_default == 0 && !val_t_seen(val)) {
+ return;
+ }
+
+ dispstrs = val_t_display_strs(val, 1, print_source, TRUE);
/* For most configuration types, this outputs
* PREFIX KEYWORD DISPSTR
for(dispstr=dispstrs; *dispstr!=NULL; dispstr++) {
if (prefix)
g_fprintf(output, "%s", prefix);
- g_fprintf(output, format, kt->keyword);
+ g_fprintf(output, format, str_keyword(kt));
g_fprintf(output, "%s\n", *dispstr);
}
} else {
g_strfreev(dispstrs);
}
+typedef struct proplist_display_str_foreach_user_data {
+ char **msg;
+ gboolean print_source;
+} proplist_display_str_foreach_user_data;
+
+char *source_string(seen_t *seen);
+char *source_string(
+ seen_t *seen)
+{
+ char *buf;
+
+ if (seen->linenum) {
+ if (seen->block) {
+ buf = g_strdup_printf(" (%s file %s line %d)",
+ seen->block, seen->filename, seen->linenum);
+ } else {
+ buf = g_strdup_printf(" (file %s line %d)",
+ seen->filename, seen->linenum);
+ }
+ } else {
+ buf = g_strdup(" (default)");
+ }
+ return buf;
+}
+
char **
val_t_display_strs(
val_t *val,
- int str_need_quote)
+ int str_need_quote,
+ gboolean print_source,
+ gboolean print_unit)
{
+ gboolean add_source = TRUE;
+ int i;
char **buf;
buf = malloc(3*SIZEOF(char *));
buf[0] = NULL;
switch(val->type) {
case CONFTYPE_INT:
- buf[0] = vstrallocf("%d", val_t__int(val));
+ buf[0] = vstrallocf("%d ", val_t__int(val));
+ i = strlen(buf[0]) - 1;
+ if (print_unit && val->unit == CONF_UNIT_K) {
+ buf[0][i] = 'K';
+ } else {
+ buf[0][i] = '\0';
+ }
break;
case CONFTYPE_SIZE:
- buf[0] = vstrallocf("%zd", (ssize_t)val_t__size(val));
+ buf[0] = vstrallocf("%zd ", (ssize_t)val_t__size(val));
+ i = strlen(buf[0]) - 1;
+ if (print_unit && val->unit == CONF_UNIT_K) {
+ buf[0][i] = 'K';
+ } else {
+ buf[0][i] = '\0';
+ }
break;
case CONFTYPE_INT64:
- buf[0] = vstrallocf("%lld", (long long)val_t__int64(val));
+ buf[0] = vstrallocf("%lld ", (long long)val_t__int64(val));
+ i = strlen(buf[0]) - 1;
+ if (print_unit && val->unit == CONF_UNIT_K) {
+ buf[0][i] = 'K';
+ } else {
+ buf[0][i] = '\0';
+ }
break;
case CONFTYPE_REAL:
}
break;
+ case CONFTYPE_IDENTLIST:
+ {
+ GSList *ia;
+ int first = 1;
+
+ buf[0] = NULL;
+ for (ia = val->v.identlist; ia != NULL; ia = ia->next) {
+ if (first) {
+ buf[0] = stralloc(ia->data);
+ first = 0;
+ } else {
+ strappend(buf[0], " ");
+ strappend(buf[0], ia->data);
+ }
+ }
+ }
+ break;
+
case CONFTYPE_STR:
if(str_need_quote) {
if(val->v.s) {
- buf[0] = vstrallocf("\"%s\"", val->v.s);
+ buf[0] = quote_string_always(val->v.s);
} else {
buf[0] = stralloc("\"\"");
}
}
break;
+ case CONFTYPE_AUTOLABEL:
+ {
+ buf[0] = quote_string_always(val->v.autolabel.template);
+ if (val->v.autolabel.autolabel & AL_OTHER_CONFIG) {
+ buf[0] = vstrextend(&buf[0], " OTHER-CONFIG", NULL);
+ }
+ if (val->v.autolabel.autolabel & AL_NON_AMANDA) {
+ buf[0] = vstrextend(&buf[0], " NON-AMANDA", NULL);
+ }
+ if (val->v.autolabel.autolabel & AL_VOLUME_ERROR) {
+ buf[0] = vstrextend(&buf[0], " VOLUME-ERROR", NULL);
+ }
+ if (val->v.autolabel.autolabel & AL_EMPTY) {
+ buf[0] = vstrextend(&buf[0], " EMPTY", NULL);
+ }
+ }
+ break;
+
case CONFTYPE_TIME:
buf[0] = vstrallocf("%2d%02d",
(int)val_t__time(val)/100, (int)val_t__time(val) % 100);
buf[0] = stralloc("no");
break;
+ case CONFTYPE_NO_YES_ALL:
+ switch(val_t__no_yes_all(val)) {
+ case 0:
+ buf[0] = stralloc("no");
+ break;
+ case 1:
+ buf[0] = stralloc("yes");
+ break;
+ case 2:
+ buf[0] = stralloc("all");
+ break;
+ }
+ break;
+
case CONFTYPE_STRATEGY:
switch(val_t__strategy(val)) {
case DS_SKIP:
}
break;
- case CONFTYPE_ESTIMATE:
- switch(val_t__estimate(val)) {
- case ES_CLIENT:
- buf[0] = vstrallocf("CLIENT");
- break;
+ case CONFTYPE_ESTIMATELIST: {
+ estimatelist_t es = val_t__estimatelist(val);
+ buf[0] = stralloc("");
+ while (es) {
+ switch((estimate_t)GPOINTER_TO_INT(es->data)) {
+ case ES_CLIENT:
+ strappend(buf[0], "CLIENT");
+ break;
- case ES_SERVER:
- buf[0] = vstrallocf("SERVER");
- break;
+ case ES_SERVER:
+ strappend(buf[0], "SERVER");
+ break;
- case ES_CALCSIZE:
- buf[0] = vstrallocf("CALCSIZE");
- break;
+ case ES_CALCSIZE:
+ strappend(buf[0], "CALCSIZE");
+ break;
+
+ case ES_ES:
+ break;
+ }
+ es = es->next;
+ if (es)
+ strappend(buf[0], " ");
}
break;
+ }
case CONFTYPE_EXECUTE_WHERE:
switch(val->v.i) {
}
break;
+ case CONFTYPE_DATA_PATH:
+ buf[0] = g_strdup(data_path_to_string(val->v.i));
+ break;
+
case CONFTYPE_ENCRYPT:
switch(val_t__encrypt(val)) {
case ENCRYPT_NONE:
}
break;
+ case CONFTYPE_PART_CACHE_TYPE:
+ switch(val_t__part_cache_type(val)) {
+ case PART_CACHE_TYPE_NONE:
+ buf[0] = vstrallocf("NONE");
+ break;
+
+ case PART_CACHE_TYPE_DISK:
+ buf[0] = vstrallocf("DISK");
+ break;
+
+ case PART_CACHE_TYPE_MEMORY:
+ buf[0] = vstrallocf("MEMORY");
+ break;
+ }
+ break;
+
+ case CONFTYPE_HOST_LIMIT: {
+ GSList *iter = val_t__host_limit(val).match_pats;
+
+ if (val_t__host_limit(val).same_host)
+ buf[0] = stralloc("SAME-HOST ");
+ else
+ buf[0] = stralloc("");
+
+ if (val_t__host_limit(val).server)
+ strappend(buf[0], "SERVER ");
+
+ while (iter) {
+ strappend(buf[0], quote_string_always((char *)iter->data));
+ strappend(buf[0], " ");
+ iter = iter->next;
+ }
+ break;
+ }
+
case CONFTYPE_HOLDING:
switch(val_t__holding(val)) {
case HOLD_NEVER:
case CONFTYPE_PROPLIST: {
int nb_property;
- char **mybuf;
+ proplist_display_str_foreach_user_data user_data;
nb_property = g_hash_table_size(val_t__proplist(val));
- amfree(buf);
+ g_free(buf);
buf = malloc((nb_property+1)*SIZEOF(char*));
buf[nb_property] = NULL;
- mybuf = buf;
+ user_data.msg = buf;
+ user_data.print_source = print_source;
g_hash_table_foreach(val_t__proplist(val),
proplist_display_str_foreach_fn,
- &mybuf);
- break;
- }
-
- case CONFTYPE_PP_SCRIPTLIST: {
- int nb_pp_scriplist;
- char **mybuf;
-
- nb_pp_scriplist = g_slist_length(val_t__pp_scriptlist(val));
- amfree(buf);
- buf = malloc((nb_pp_scriplist+1)*SIZEOF(char*));
- buf[nb_pp_scriplist] = NULL;
- mybuf = buf;
- g_slist_foreach(val_t__pp_scriptlist(val),
- pp_scriptlist_display_str_foreach_fn,
- &mybuf);
+ &user_data);
+ add_source = FALSE;
break;
}
case CONFTYPE_APPLICATION: {
- if (val->v.application) {
- buf[0] = vstrallocf("\"%s\"", val->v.application->name);
+ if (val->v.s) {
+ buf[0] = quote_string_always(val->v.s);
} else {
buf[0] = stralloc("");
}
buf[0] = stralloc("");
if (val->v.i != 0) {
char *sep = "";
+ if (val->v.i & EXECUTE_ON_PRE_AMCHECK) {
+ buf[0] = vstrextend(&buf[0], sep, "PRE-AMCHECK", NULL);
+ sep = ", ";
+ }
if (val->v.i & EXECUTE_ON_PRE_DLE_AMCHECK) {
buf[0] = vstrextend(&buf[0], sep, "PRE-DLE-AMCHECK", NULL);
sep = ", ";
buf[0] = vstrextend(&buf[0], sep, "POST-HOST-AMCHECK", NULL);
sep = ", ";
}
+ if (val->v.i & EXECUTE_ON_POST_AMCHECK) {
+ buf[0] = vstrextend(&buf[0], sep, "POST-AMCHECK", NULL);
+ sep = ", ";
+ }
+ if (val->v.i & EXECUTE_ON_PRE_ESTIMATE) {
+ buf[0] = vstrextend(&buf[0], sep, "PRE-ESTIMATE", NULL);
+ sep = ", ";
+ }
if (val->v.i & EXECUTE_ON_PRE_DLE_ESTIMATE) {
buf[0] = vstrextend(&buf[0], sep, "PRE-DLE-ESTIMATE", NULL);
sep = ", ";
buf[0] = vstrextend(&buf[0], sep, "POST-HOST-ESTIMATE", NULL);
sep = ", ";
}
+ if (val->v.i & EXECUTE_ON_POST_ESTIMATE) {
+ buf[0] = vstrextend(&buf[0], sep, "POST-ESTIMATE", NULL);
+ sep = ", ";
+ }
+ if (val->v.i & EXECUTE_ON_PRE_BACKUP) {
+ buf[0] = vstrextend(&buf[0], sep, "PRE-BACKUP", NULL);
+ sep = ", ";
+ }
if (val->v.i & EXECUTE_ON_PRE_DLE_BACKUP) {
buf[0] = vstrextend(&buf[0], sep, "PRE-DLE-BACKUP", NULL);
sep = ", ";
buf[0] = vstrextend(&buf[0], sep, "PRE-HOST-BACKUP", NULL);
sep = ", ";
}
+ if (val->v.i & EXECUTE_ON_POST_BACKUP) {
+ buf[0] = vstrextend(&buf[0], sep, "POST-BACKUP", NULL);
+ sep = ", ";
+ }
if (val->v.i & EXECUTE_ON_POST_DLE_BACKUP) {
buf[0] = vstrextend(&buf[0], sep, "POST-DLE-BACKUP", NULL);
sep = ", ";
break;
}
+
+ /* add source */
+ if (print_source && add_source) {
+ char **buf1;
+ for (buf1 = buf; *buf1 != NULL; buf1++) {
+ char *buf2 = g_strjoin("", *buf1, source_string(&val->seen), NULL);
+ g_free(*buf1);
+ *buf1 = buf2;
+ }
+ }
return buf;
}
return val->v.i;
}
-pp_scriptlist_t
-val_t_to_pp_scriptlist(
- val_t *val)
-{
- if (val->type != CONFTYPE_PP_SCRIPTLIST) {
- error(_("get_conftype_proplist: val.type is not CONFTYPE_PP_SCRIPTLIST"));
- /*NOTREACHED*/
- }
- return val->v.pp_scriptlist;
-}
-
-
-application_t *
+char *
val_t_to_application(
val_t *val)
{
error(_("get_conftype_applicaiton: val.type is not CONFTYPE_APPLICATION"));
/*NOTREACHED*/
}
- return val->v.application;
+ return val->v.s;
}
gpointer value_p,
gpointer user_data_p)
{
- char *property_s = key_p;
+ char *property_s = quote_string_always(key_p);
property_t *property = value_p;
GSList *value;
- char ***msg = (char ***)user_data_p;
+ proplist_display_str_foreach_user_data *user_data = user_data_p;
+ char ***msg = (char ***)&user_data->msg;
/* What to do with property->append? it should be printed only on client */
if (property->priority) {
- **msg = vstralloc("priority \"", property_s, "\"", NULL);
+ **msg = vstralloc("priority ", property_s, NULL);
+ amfree(property_s);
} else {
- **msg = vstralloc("\"", property_s, "\"", NULL);
+ **msg = property_s;
+ property_s = NULL;
}
for(value=property->values; value != NULL; value = value->next) {
- **msg = vstrextend(*msg, " \"", value->data, "\"", NULL);
+ char *qstr = quote_string_always((char *)value->data);
+ **msg = vstrextend(*msg, " ", qstr, NULL);
+ amfree(qstr);
+ }
+ if (user_data->print_source) {
+ **msg = vstrextend(*msg, source_string(&property->seen));
}
(*msg)++;
}
-static void
-pp_scriptlist_display_str_foreach_fn(
- gpointer data_p,
- gpointer user_data_p)
-{
- pp_script_t *pp_script = data_p;
- char ***msg = (char ***)user_data_p;
-
- **msg = vstralloc("\"", pp_script->name, "\"", NULL);
- (*msg)++;
-}
-
-
static char *
exinclude_display_str(
val_t *val,
int file)
{
- sl_t *sl;
+ am_sl_t *sl;
sle_t *excl;
char *rval;
if (sl != NULL) {
for(excl = sl->first; excl != NULL; excl = excl->next) {
- vstrextend(&rval, " \"", excl->name, "\"", NULL);
+ char *qstr = quote_string_always(excl->name);
+ vstrextend(&rval, " ", qstr, NULL);
+ amfree(qstr);
}
}
pp_script_t *pp;
device_config_t *dc;
changer_config_t *cc;
+ taperscan_t *ts;
+ interactivity_t *iv;
int success = FALSE;
/* WARNING: assumes globals keytable and parsetable are set correctly. */
if (*s == '-') *s = '_';
}
- subsec_key = strchr(subsec_name,':');
+ subsec_key = strrchr(subsec_name,':');
if(!subsec_key) goto out; /* failure */
*subsec_key = '\0';
if (val) *val = &ip->value[np->parm];
if (parm) *parm = np;
success = TRUE;
- } else if (strcmp(subsec_type, "APPLICATION_TOOL") == 0) {
+ /* accept the old name here, too */
+ } else if (strcmp(subsec_type, "APPLICATION_TOOL") == 0
+ || strcmp(subsec_type, "APPLICATION") == 0) {
ap = lookup_application(subsec_name);
if (!ap) goto out;
for(np = application_var; np->token != CONF_UNKNOWN; np++) {
if (val) *val = &ap->value[np->parm];
if (parm) *parm = np;
success = TRUE;
- } else if (strcmp(subsec_type, "SCRIPT_TOOL") == 0) {
+ /* accept the old name here, too */
+ } else if (strcmp(subsec_type, "SCRIPT_TOOL") == 0
+ || strcmp(subsec_type, "SCRIPT") == 0) {
pp = lookup_pp_script(subsec_name);
if (!pp) goto out;
for(np = pp_script_var; np->token != CONF_UNKNOWN; np++) {
if (val) *val = &cc->value[np->parm];
if (parm) *parm = np;
success = TRUE;
+ } else if (g_str_equal(subsec_type, "INTERACTIVITY")) {
+ iv = lookup_interactivity(subsec_name);
+ if (!iv) goto out;
+ for(np = interactivity_var; np->token != CONF_UNKNOWN; np++) {
+ if(np->token == kt->token)
+ break;
+ }
+ if (np->token == CONF_UNKNOWN) goto out;
+
+ if (val) *val = &iv->value[np->parm];
+ if (parm) *parm = np;
+ success = TRUE;
+ } else if (g_str_equal(subsec_type, "TAPERSCAN")) {
+ ts = lookup_taperscan(subsec_name);
+ if (!ts) goto out;
+ for(np = taperscan_var; np->token != CONF_UNKNOWN; np++) {
+ if(np->token == kt->token)
+ break;
+ }
+ if (np->token == CONF_UNKNOWN) goto out;
+
+ if (val) *val = &ts->value[np->parm];
+ if (parm) *parm = np;
+ success = TRUE;
}
/* No delimiters -- we're referencing a global config parameter */
return 1024*1024;
case CONF_MULT1G:
return 1024*1024*1024;
+ case CONF_MULT1T:
+ return (gint64)1024*1024*1024*1024;
case CONF_MULT7:
return 7;
case CONF_AMINFINITY:
return 0;
}
+int
+string_to_boolean(
+ const char *str)
+{
+ keytab_t * table_entry;
+
+ if (str == NULL || *str == '\0') {
+ return -1;
+ }
+
+ /* 0 and 1 are not in the table, as they are parsed as ints */
+ if (0 == strcmp(str, "0"))
+ return 0;
+ if (0 == strcmp(str, "1"))
+ return 1;
+
+ for (table_entry = bool_keytable; table_entry->keyword != NULL;
+ table_entry ++) {
+ if (strcasecmp(str, table_entry->keyword) == 0) {
+ switch (table_entry->token) {
+ case CONF_ATRUE:
+ return 1;
+ case CONF_AFALSE:
+ return 0;
+ default:
+ return -1;
+ }
+ }
+ }
+
+ return -1;
+}
+
/*
* Error Handling Implementaiton
*/
void
config_clear_errors(void)
{
- g_slist_free_full(cfgerr_errors);
+ slist_free_full(cfgerr_errors, g_free);
cfgerr_errors = NULL;
cfgerr_level = CFGERR_OK;
return config_filename;
}
-int
-property_argv_size(proplist_t proplist) {
- int nb;
-
- nb = 0;
- g_hash_table_foreach(proplist, &count_proplist, &nb);
- return nb*2;
-}
-
-int
-property_add_to_argv(
- char **argvchild,
- proplist_t proplist)
-{
- char **argv = argvchild;
-
- g_hash_table_foreach(proplist, &proplist_add_to_argv, &argv);
- return (argv - argvchild);
-}
-
char *
anonymous_value(void)
{
value++;
return number;
}
+
+gint compare_pp_script_order(
+ gconstpointer a,
+ gconstpointer b)
+{
+ return pp_script_get_order(lookup_pp_script((char *)a)) > pp_script_get_order(lookup_pp_script((char *)b));
+}
+
+char *
+data_path_to_string(
+ data_path_t data_path)
+{
+ switch (data_path) {
+ case DATA_PATH_AMANDA : return "AMANDA";
+ case DATA_PATH_DIRECTTCP: return "DIRECTTCP";
+ }
+ error(_("datapath is not DATA_PATH_AMANDA or DATA_PATH_DIRECTTCP"));
+ /* NOTREACHED */
+}
+
+data_path_t
+data_path_from_string(
+ char *data)
+{
+ if (strcmp(data, "AMANDA") == 0)
+ return DATA_PATH_AMANDA;
+ if (strcmp(data, "DIRECTTCP") == 0)
+ return DATA_PATH_DIRECTTCP;
+ error(_("datapath is not AMANDA or DIRECTTCP :%s:"), data);
+ /* NOTREACHED */
+}
+
+gchar *
+amandaify_property_name(
+ const gchar *name)
+{
+ gchar *ret, *cur_r;
+ const gchar *cur_o;
+ if (!name) return NULL;
+
+ ret = g_malloc0(strlen(name)+1);
+ cur_r = ret;
+ for (cur_o = name; *cur_o; cur_o++) {
+ if ('_' == *cur_o)
+ *cur_r = '-';
+ else
+ *cur_r = g_ascii_tolower(*cur_o);
+
+ cur_r++;
+ }
+
+ return ret;
+}
+
+static char keyword_str[1024];
+
+static char *
+str_keyword(
+ keytab_t *kt)
+{
+ char *p = kt->keyword;
+ char *s = keyword_str;
+
+ while(*p != '\0') {
+ if (*p == '_') {
+ *s = '-';
+ } else {
+ *s = *p;
+ }
+ p++;
+ s++;
+ }
+ *s = '\0';
+
+ return keyword_str;
+}
projects / debian / amanda / blobdiff