2 * Amanda, The Advanced Maryland Automatic Network Disk Archiver
3 * Copyright (c) 1991-2000 University of Maryland at College Park
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of U.M. not be used in advertising or
11 * publicity pertaining to distribution of the software without specific,
12 * written prior permission. U.M. makes no representations about the
13 * suitability of this software for any purpose. It is provided "as is"
14 * without express or implied warranty.
16 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
18 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
20 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 * Author: James da Silva, Systems Design and Analysis Group
24 * Computer Science Department
25 * University of Maryland at College Park
28 * $Id: conffile.c,v 1.156 2006/07/26 15:17:37 martinea Exp $
30 * read configuration file
46 #define INT_MAX 2147483647
49 /* this corresponds to the normal output of amanda, but may
50 * be adapted to any spacing as you like.
52 ColumnInfo ColumnData[] = {
53 { "HostName", 0, 12, 12, 0, "%-*.*s", "HOSTNAME" },
54 { "Disk", 1, 11, 11, 0, "%-*.*s", "DISK" },
55 { "Level", 1, 1, 1, 0, "%*.*d", "L" },
56 { "OrigKB", 1, 7, 0, 0, "%*.*lf", "ORIG-KB" },
57 { "OutKB", 1, 7, 0, 0, "%*.*lf", "OUT-KB" },
58 { "Compress", 1, 6, 1, 0, "%*.*lf", "COMP%" },
59 { "DumpTime", 1, 7, 7, 0, "%*.*s", "MMM:SS" },
60 { "DumpRate", 1, 6, 1, 0, "%*.*lf", "KB/s" },
61 { "TapeTime", 1, 6, 6, 0, "%*.*s", "MMM:SS" },
62 { "TapeRate", 1, 6, 1, 0, "%*.*lf", "KB/s" },
63 { NULL, 0, 0, 0, 0, NULL, NULL }
66 char *config_name = NULL;
67 char *config_dir = NULL;
69 /* visible holding disk variables */
71 holdingdisk_t *holdingdisks;
74 long int unit_divisor = 1;
76 /* configuration parameters */
78 val_t server_conf[CNF_CNF];
80 command_option_t *server_options = NULL;
82 /* other internal variables */
83 static holdingdisk_t hdcur;
85 static tapetype_t tpcur;
87 static dumptype_t dpcur;
89 static interface_t ifcur;
91 static dumptype_t *dumplist = NULL;
92 static tapetype_t *tapelist = NULL;
93 static interface_t *interface_list = NULL;
95 /* predeclare local functions */
97 char *get_token_name(tok_t);
100 void validate_positive0 (t_conf_var *, val_t *);
101 void validate_positive1 (t_conf_var *, val_t *);
102 void validate_runspercycle(t_conf_var *, val_t *);
103 void validate_bumppercent (t_conf_var *, val_t *);
104 void validate_bumpmult (t_conf_var *, val_t *);
105 void validate_inparallel (t_conf_var *, val_t *);
106 void validate_displayunit (t_conf_var *, val_t *);
107 void validate_reserve (t_conf_var *, val_t *);
108 void validate_use (t_conf_var *, val_t *);
109 void validate_chunksize (t_conf_var *, val_t *);
110 void validate_blocksize (t_conf_var *, val_t *);
112 static void init_defaults(void);
113 static void read_conffile_recursively(char *filename);
115 static int read_confline(void);
116 static void get_holdingdisk(void);
117 static void init_holdingdisk_defaults(void);
118 static void save_holdingdisk(void);
119 static void get_dumptype(void);
120 static void init_dumptype_defaults(void);
121 static void save_dumptype(void);
122 static void copy_dumptype(void);
123 static void get_tapetype(void);
124 static void init_tapetype_defaults(void);
125 static void save_tapetype(void);
126 static void copy_tapetype(void);
127 static void get_interface(void);
128 static void init_interface_defaults(void);
129 static void save_interface(void);
130 static void copy_interface(void);
131 static void get_comprate(t_conf_var *, val_t *);
132 static void get_compress(t_conf_var *, val_t *);
133 static void get_encrypt (t_conf_var *, val_t *);
134 static void get_holding (t_conf_var *, val_t *);
135 static void get_priority(t_conf_var *, val_t *);
136 static void get_strategy(t_conf_var *, val_t *);
137 static void get_estimate(t_conf_var *, val_t *);
138 static void get_exclude (t_conf_var *, val_t *);
139 /*static void get_include(t_conf_var *, val_t *);*/
140 static void get_taperalgo(t_conf_var *, val_t *);
142 keytab_t server_keytab[] = {
143 { "AMANDAD_PATH", CONF_AMANDAD_PATH },
144 { "AMRECOVER_CHANGER", CONF_AMRECOVER_CHANGER },
145 { "AMRECOVER_CHECK_LABEL", CONF_AMRECOVER_CHECK_LABEL },
146 { "AMRECOVER_DO_FSF", CONF_AMRECOVER_DO_FSF },
147 { "APPEND", CONF_APPEND },
148 { "AUTH", CONF_AUTH },
149 { "AUTO", CONF_AUTO },
150 { "AUTOFLUSH", CONF_AUTOFLUSH },
151 { "BEST", CONF_BEST },
152 { "BLOCKSIZE", CONF_BLOCKSIZE },
153 { "BUMPDAYS", CONF_BUMPDAYS },
154 { "BUMPMULT", CONF_BUMPMULT },
155 { "BUMPPERCENT", CONF_BUMPPERCENT },
156 { "BUMPSIZE", CONF_BUMPSIZE },
157 { "CALCSIZE", CONF_CALCSIZE },
158 { "CHANGERDEV", CONF_CHNGRDEV },
159 { "CHANGERFILE", CONF_CHNGRFILE },
160 { "CHUNKSIZE", CONF_CHUNKSIZE },
161 { "CLIENT", CONF_CLIENT },
162 { "CLIENT_CUSTOM_COMPRESS", CONF_CLNTCOMPPROG },
163 { "CLIENT_DECRYPT_OPTION", CONF_CLNT_DECRYPT_OPT },
164 { "CLIENT_ENCRYPT", CONF_CLNT_ENCRYPT },
165 { "CLIENT_USERNAME", CONF_CLIENT_USERNAME },
166 { "COLUMNSPEC", CONF_COLUMNSPEC },
167 { "COMMENT", CONF_COMMENT },
168 { "COMPRATE", CONF_COMPRATE },
169 { "COMPRESS", CONF_COMPRESS },
170 { "CTIMEOUT", CONF_CTIMEOUT },
171 { "CUSTOM", CONF_CUSTOM },
172 { "DEFINE", CONF_DEFINE },
173 { "DIRECTORY", CONF_DIRECTORY },
174 { "DISKFILE", CONF_DISKFILE },
175 { "DISPLAYUNIT", CONF_DISPLAYUNIT },
176 { "DTIMEOUT", CONF_DTIMEOUT },
177 { "DUMPCYCLE", CONF_DUMPCYCLE },
178 { "DUMPORDER", CONF_DUMPORDER },
179 { "DUMPTYPE", CONF_DUMPTYPE },
180 { "DUMPUSER", CONF_DUMPUSER },
181 { "ENCRYPT", CONF_ENCRYPT },
182 { "ESTIMATE", CONF_ESTIMATE },
183 { "ETIMEOUT", CONF_ETIMEOUT },
184 { "EXCLUDE", CONF_EXCLUDE },
185 { "EXCLUDE-FILE", CONF_EXCLUDE_FILE },
186 { "EXCLUDE-LIST", CONF_EXCLUDE_LIST },
187 { "FALLBACK_SPLITSIZE", CONF_FALLBACK_SPLITSIZE },
188 { "FAST", CONF_FAST },
189 { "FILE", CONF_EFILE },
190 { "FILE-PAD", CONF_FILE_PAD },
191 { "FILEMARK", CONF_FILEMARK },
192 { "FIRST", CONF_FIRST },
193 { "FIRSTFIT", CONF_FIRSTFIT },
194 { "HANOI", CONF_HANOI },
195 { "HIGH", CONF_HIGH },
196 { "HOLDINGDISK", CONF_HOLDING },
197 { "IGNORE", CONF_IGNORE },
198 { "INCLUDE", CONF_INCLUDE },
199 { "INCLUDEFILE", CONF_INCLUDEFILE },
200 { "INCRONLY", CONF_INCRONLY },
201 { "INDEX", CONF_INDEX },
202 { "INDEXDIR", CONF_INDEXDIR },
203 { "INFOFILE", CONF_INFOFILE },
204 { "INPARALLEL", CONF_INPARALLEL },
205 { "INTERFACE", CONF_INTERFACE },
206 { "KENCRYPT", CONF_KENCRYPT },
207 { "KRB5KEYTAB", CONF_KRB5KEYTAB },
208 { "KRB5PRINCIPAL", CONF_KRB5PRINCIPAL },
209 { "LABELSTR", CONF_LABELSTR },
210 { "LABEL_NEW_TAPES", CONF_LABEL_NEW_TAPES },
211 { "LARGEST", CONF_LARGEST },
212 { "LARGESTFIT", CONF_LARGESTFIT },
213 { "LAST", CONF_LAST },
214 { "LBL-TEMPL", CONF_LBL_TEMPL },
215 { "LENGTH", CONF_LENGTH },
216 { "LIST", CONF_LIST },
217 { "LOGDIR", CONF_LOGDIR },
219 { "MAILTO", CONF_MAILTO },
220 { "MAXDUMPS", CONF_MAXDUMPS },
221 { "MAXDUMPSIZE", CONF_MAXDUMPSIZE },
222 { "MAXPROMOTEDAY", CONF_MAXPROMOTEDAY },
223 { "MEDIUM", CONF_MEDIUM },
224 { "NETUSAGE", CONF_NETUSAGE }, /* XXX - historical */
225 { "NEVER", CONF_NEVER },
226 { "NOFULL", CONF_NOFULL },
227 { "NOINC", CONF_NOINC },
228 { "NONE", CONF_NONE },
229 { "OPTIONAL", CONF_OPTIONAL },
231 { "PRINTER", CONF_PRINTER },
232 { "PRIORITY", CONF_PRIORITY },
233 { "PROGRAM", CONF_PROGRAM },
234 { "RAWTAPEDEV", CONF_RAWTAPEDEV },
235 { "RECORD", CONF_RECORD },
236 { "REQUIRED", CONF_REQUIRED },
237 { "RESERVE", CONF_RESERVE },
238 { "RUNSPERCYCLE", CONF_RUNSPERCYCLE },
239 { "RUNTAPES", CONF_RUNTAPES },
240 { "SERVER", CONF_SERVER },
241 { "SERVER_CUSTOM_COMPRESS", CONF_SRVCOMPPROG },
242 { "SERVER_DECRYPT_OPTION", CONF_SRV_DECRYPT_OPT },
243 { "SERVER_ENCRYPT", CONF_SRV_ENCRYPT },
244 { "SKIP", CONF_SKIP },
245 { "SKIP-FULL", CONF_SKIP_FULL },
246 { "SKIP-INCR", CONF_SKIP_INCR },
247 { "SMALLEST", CONF_SMALLEST },
248 { "SPEED", CONF_SPEED },
249 { "SPLIT_DISKBUFFER", CONF_SPLIT_DISKBUFFER },
250 { "SSH_KEYS", CONF_SSH_KEYS },
251 { "STANDARD", CONF_STANDARD },
252 { "STARTTIME", CONF_STARTTIME },
253 { "STRATEGY", CONF_STRATEGY },
254 { "TAPEBUFS", CONF_TAPEBUFS },
255 { "TAPECYCLE", CONF_TAPECYCLE },
256 { "TAPEDEV", CONF_TAPEDEV },
257 { "TAPELIST", CONF_TAPELIST },
258 { "TAPERALGO", CONF_TAPERALGO },
259 { "TAPETYPE", CONF_TAPETYPE },
260 { "TAPE_SPLITSIZE", CONF_TAPE_SPLITSIZE },
261 { "TPCHANGER", CONF_TPCHANGER },
263 { "USETIMESTAMPS", CONF_USETIMESTAMPS },
264 { NULL, CONF_IDENT },
265 { NULL, CONF_UNKNOWN }
268 t_conf_var server_var [] = {
269 { CONF_ORG , CONFTYPE_STRING , read_string , CNF_ORG , NULL },
270 { CONF_MAILTO , CONFTYPE_STRING , read_string , CNF_MAILTO , NULL },
271 { CONF_DUMPUSER , CONFTYPE_STRING , read_string , CNF_DUMPUSER , NULL },
272 { CONF_PRINTER , CONFTYPE_STRING , read_string , CNF_PRINTER , NULL },
273 { CONF_TAPEDEV , CONFTYPE_STRING , read_string , CNF_TAPEDEV , NULL },
274 { CONF_TPCHANGER , CONFTYPE_STRING , read_string , CNF_TPCHANGER , NULL },
275 { CONF_CHNGRDEV , CONFTYPE_STRING , read_string , CNF_CHNGRDEV , NULL },
276 { CONF_CHNGRFILE , CONFTYPE_STRING , read_string , CNF_CHNGRFILE , NULL },
277 { CONF_LABELSTR , CONFTYPE_STRING , read_string , CNF_LABELSTR , NULL },
278 { CONF_TAPELIST , CONFTYPE_STRING , read_string , CNF_TAPELIST , NULL },
279 { CONF_DISKFILE , CONFTYPE_STRING , read_string , CNF_DISKFILE , NULL },
280 { CONF_INFOFILE , CONFTYPE_STRING , read_string , CNF_INFOFILE , NULL },
281 { CONF_LOGDIR , CONFTYPE_STRING , read_string , CNF_LOGDIR , NULL },
282 { CONF_INDEXDIR , CONFTYPE_STRING , read_string , CNF_INDEXDIR , NULL },
283 { CONF_TAPETYPE , CONFTYPE_IDENT , read_ident , CNF_TAPETYPE , NULL },
284 { CONF_DUMPCYCLE , CONFTYPE_INT , read_int , CNF_DUMPCYCLE , validate_positive0 },
285 { CONF_RUNSPERCYCLE , CONFTYPE_INT , read_int , CNF_RUNSPERCYCLE , validate_runspercycle },
286 { CONF_RUNTAPES , CONFTYPE_INT , read_int , CNF_RUNTAPES , validate_positive0 },
287 { CONF_TAPECYCLE , CONFTYPE_INT , read_int , CNF_TAPECYCLE , validate_positive1 },
288 { CONF_BUMPDAYS , CONFTYPE_INT , read_int , CNF_BUMPDAYS , validate_positive1 },
289 { CONF_BUMPSIZE , CONFTYPE_AM64 , read_am64 , CNF_BUMPSIZE , validate_positive1 },
290 { CONF_BUMPPERCENT , CONFTYPE_INT , read_int , CNF_BUMPPERCENT , validate_bumppercent },
291 { CONF_BUMPMULT , CONFTYPE_REAL , read_real , CNF_BUMPMULT , validate_bumpmult },
292 { CONF_NETUSAGE , CONFTYPE_INT , read_int , CNF_NETUSAGE , validate_positive1 },
293 { CONF_INPARALLEL , CONFTYPE_INT , read_int , CNF_INPARALLEL , validate_inparallel },
294 { CONF_DUMPORDER , CONFTYPE_STRING , read_string , CNF_DUMPORDER , NULL },
295 { CONF_MAXDUMPS , CONFTYPE_INT , read_int , CNF_MAXDUMPS , validate_positive1 },
296 { CONF_ETIMEOUT , CONFTYPE_TIME , read_time , CNF_ETIMEOUT , NULL },
297 { CONF_DTIMEOUT , CONFTYPE_TIME , read_time , CNF_DTIMEOUT , validate_positive1 },
298 { CONF_CTIMEOUT , CONFTYPE_TIME , read_time , CNF_CTIMEOUT , validate_positive1 },
299 { CONF_TAPEBUFS , CONFTYPE_INT , read_int , CNF_TAPEBUFS , validate_positive1 },
300 { CONF_RAWTAPEDEV , CONFTYPE_STRING , read_string , CNF_RAWTAPEDEV , NULL },
301 { CONF_COLUMNSPEC , CONFTYPE_STRING , read_string , CNF_COLUMNSPEC , NULL },
302 { CONF_TAPERALGO , CONFTYPE_TAPERALGO, get_taperalgo, CNF_TAPERALGO , NULL },
303 { CONF_DISPLAYUNIT , CONFTYPE_STRING , read_string , CNF_DISPLAYUNIT , validate_displayunit },
304 { CONF_AUTOFLUSH , CONFTYPE_BOOL , read_bool , CNF_AUTOFLUSH , NULL },
305 { CONF_RESERVE , CONFTYPE_INT , read_int , CNF_RESERVE , validate_reserve },
306 { CONF_MAXDUMPSIZE , CONFTYPE_AM64 , read_am64 , CNF_MAXDUMPSIZE , NULL },
307 { CONF_KRB5KEYTAB , CONFTYPE_STRING , read_string , CNF_KRB5KEYTAB , NULL },
308 { CONF_KRB5PRINCIPAL , CONFTYPE_STRING , read_string , CNF_KRB5PRINCIPAL , NULL },
309 { CONF_LABEL_NEW_TAPES , CONFTYPE_STRING , read_string , CNF_LABEL_NEW_TAPES , NULL },
310 { CONF_USETIMESTAMPS , CONFTYPE_BOOL , read_bool , CNF_USETIMESTAMPS , NULL },
311 { CONF_AMRECOVER_DO_FSF , CONFTYPE_BOOL , read_bool , CNF_AMRECOVER_DO_FSF , NULL },
312 { CONF_AMRECOVER_CHANGER , CONFTYPE_STRING , read_string , CNF_AMRECOVER_CHANGER , NULL },
313 { CONF_AMRECOVER_CHECK_LABEL, CONFTYPE_BOOL , read_bool , CNF_AMRECOVER_CHECK_LABEL, NULL },
314 { CONF_UNKNOWN , CONFTYPE_INT , NULL , CNF_CNF , NULL }
317 ** ------------------------
318 ** External entry points
319 ** ------------------------
330 /* We assume that conf_confname & conf are initialized to NULL above */
331 read_conffile_recursively(filename);
333 /* overwrite with command line option */
334 command_overwrite(server_options, server_var, server_keytab, server_conf,
337 if(got_parserror != -1 ) {
338 if(lookup_tapetype(server_conf[CNF_TAPETYPE].v.s) == NULL) {
339 char *save_confname = conf_confname;
341 conf_confname = filename;
342 if(!server_conf[CNF_TAPETYPE].seen)
343 conf_parserror("default tapetype %s not defined", server_conf[CNF_TAPETYPE].v.s);
345 conf_line_num = server_conf[CNF_TAPETYPE].seen;
346 conf_parserror("tapetype %s not defined", server_conf[CNF_TAPETYPE].v.s);
348 conf_confname = save_confname;
352 ip = alloc(SIZEOF(interface_t));
353 ip->name = stralloc("default");
354 ip->seen = server_conf[CNF_NETUSAGE].seen;
355 conf_init_string(&ip->value[INTER_COMMENT], "implicit from NETUSAGE");
356 conf_init_int(&ip->value[INTER_MAXUSAGE], server_conf[CNF_NETUSAGE].v.i);
358 ip->next = interface_list;
361 return got_parserror;
366 struct s_conf_var *np,
372 conf_parserror("%s must be positive", get_token_name(np->token));
376 conf_parserror("%s must be positive", get_token_name(np->token));
380 conf_parserror("%s must be positive", get_token_name(np->token));
383 conf_parserror("validate_positive0 invalid type %d\n", val->type);
389 struct s_conf_var *np,
395 conf_parserror("%s must be positive", get_token_name(np->token));
399 conf_parserror("%s must be positive", get_token_name(np->token));
403 conf_parserror("%s must be positive", get_token_name(np->token));
407 conf_parserror("%s must be positive", get_token_name(np->token));
410 conf_parserror("validate_positive1 invalid type %d\n", val->type);
415 validate_runspercycle(
416 struct s_conf_var *np,
421 conf_parserror("runspercycle must be >= -1");
425 validate_bumppercent(
426 struct s_conf_var *np,
430 if(val->v.i < 0 || val->v.i > 100)
431 conf_parserror("bumppercent must be between 0 and 100");
436 struct s_conf_var *np,
440 if(val->v.i < 1 || val->v.i >MAX_DUMPERS)
441 conf_parserror("inparallel must be between 1 and MAX_DUMPERS (%d)",
447 struct s_conf_var *np,
451 if(val->v.r < 0.999) {
452 conf_parserror("bumpmult must be positive");
457 validate_displayunit(
458 struct s_conf_var *np,
462 if(strcmp(val->v.s, "k") == 0 ||
463 strcmp(val->v.s, "K") == 0) {
464 val->v.s[0] = (char)toupper(val->v.s[0]);
467 else if(strcmp(val->v.s, "m") == 0 ||
468 strcmp(val->v.s, "M") == 0) {
469 val->v.s[0] = (char)toupper(val->v.s[0]);
472 else if(strcmp(val->v.s, "g") == 0 ||
473 strcmp(val->v.s, "G") == 0) {
474 val->v.s[0] = (char)toupper(val->v.s[0]);
475 unit_divisor=1024*1024;
477 else if(strcmp(val->v.s, "t") == 0 ||
478 strcmp(val->v.s, "T") == 0) {
479 val->v.s[0] = (char)toupper(val->v.s[0]);
480 unit_divisor=1024*1024*1024;
483 conf_parserror("displayunit must be k,m,g or t.");
489 struct s_conf_var *np,
493 if(val->v.i < 0 || val->v.i > 100)
494 conf_parserror("reserve must be between 0 and 100");
499 struct s_conf_var *np,
503 val->v.am64 = am_floor(val->v.am64, DISK_BLOCK_KB);
508 struct s_conf_var *np,
512 if(val->v.am64 == 0) {
513 val->v.am64 = ((AM64_MAX / 1024) - (2 * DISK_BLOCK_KB));
515 else if(val->v.am64 < 0) {
516 conf_parserror("Negative chunksize (%lld) is no longer supported", val->v.am64);
518 val->v.am64 = am_floor(val->v.am64, (off_t)DISK_BLOCK_KB);
523 struct s_conf_var *np,
527 if(val->v.l < DISK_BLOCK_KB) {
528 conf_parserror("Tape blocksize must be at least %d KBytes",
530 } else if(val->v.l > MAX_TAPE_BLOCK_KB) {
531 conf_parserror("Tape blocksize must not be larger than %d KBytes",
541 char number[NUM_STR_SIZE];
547 tmpstr = stralloc(str);
549 while((ch = *s++) != '\0') {
551 s[-1] = (char)toupper(ch);
553 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++) {
554 if(kt->keyword && strcmp(kt->keyword, tmpstr) == 0)
558 if(kt->token == CONF_UNKNOWN)
561 for(np = server_var; np->token != CONF_UNKNOWN; np++) {
562 if(np->token == kt->token)
566 if(np->token == CONF_UNKNOWN) return NULL;
568 if(np->type == CONFTYPE_INT) {
569 snprintf(number, sizeof(number), "%d", server_conf[np->parm].v.i);
570 tmpstr = newstralloc(tmpstr, number);
571 } else if(np->type == CONFTYPE_BOOL) {
572 if(getconf_boolean(np->parm) == 0) {
573 tmpstr = newstralloc(tmpstr, "off");
575 tmpstr = newstralloc(tmpstr, "on");
577 } else if(np->type == CONFTYPE_REAL) {
578 snprintf(number, sizeof(number), "%lf", server_conf[np->parm].v.r);
579 tmpstr = newstralloc(tmpstr, number);
580 } else if(np->type == CONFTYPE_AM64){
581 snprintf(number, sizeof(number), OFF_T_FMT,
582 (OFF_T_FMT_TYPE)server_conf[np->parm].v.am64);
583 tmpstr = newstralloc(tmpstr, number);
585 tmpstr = newstralloc(tmpstr, getconf_str(np->parm));
596 np = get_np(server_var, parm);
597 return(server_conf[np->parm].seen);
605 np = get_np(server_var, parm);
606 if (np->type != CONFTYPE_BOOL) {
607 error("getconf_boolean: np is not a CONFTYPE_BOOL");
610 return(server_conf[np->parm].v.i != 0);
618 np = get_np(server_var, parm);
619 if (np->type != CONFTYPE_INT) {
620 error("getconf_int: np is not a CONFTYPE_INT");
623 return(server_conf[np->parm].v.i);
631 np = get_np(server_var, parm);
632 if (np->type != CONFTYPE_LONG) {
633 error("getconf_long: np is not a CONFTYPE_LONG");
636 return(server_conf[np->parm].v.l);
644 np = get_np(server_var, parm);
645 if (np->type != CONFTYPE_TIME) {
646 error("getconf_time: np is not a CONFTYPE_TIME");
649 return(server_conf[np->parm].v.t);
657 np = get_np(server_var, parm);
658 if (np->type != CONFTYPE_SIZE) {
659 error("getconf_size: np is not a CONFTYPE_SIZE");
662 return(server_conf[np->parm].v.size);
670 np = get_np(server_var, parm);
671 if (np->type != CONFTYPE_AM64) {
672 error("getconf_am64: np is not a CONFTYPE_AM64");
675 return(server_conf[np->parm].v.am64);
683 np = get_np(server_var, parm);
684 if (np->type != CONFTYPE_REAL) {
685 error("getconf_real: np is not a CONFTYPE_REAL");
688 return(server_conf[np->parm].v.r);
696 np = get_np(server_var, parm);
697 if (np->type != CONFTYPE_STRING && np->type != CONFTYPE_IDENT) {
698 error("getconf_str: np is not a CONFTYPE_STRING|CONFTYPE_IDENT: %d", parm);
701 return(server_conf[np->parm].v.s);
709 np = get_np(server_var, parm);
710 if (np->type != CONFTYPE_TAPERALGO) {
711 error("getconf_taperalgo: np is not a CONFTYPE_TAPERALGO");
714 return(server_conf[np->parm].v.i);
718 getconf_holdingdisks(
730 for(p = dumplist; p != NULL; p = p->next) {
731 if(strcasecmp(p->name, str) == 0) return p;
742 for(p = tapelist; p != NULL; p = p->next) {
743 if(strcasecmp(p->name, str) == 0) return p;
757 return interface_list;
760 for (p = interface_list; p != NULL; p = p->next) {
761 if (strcasecmp(p->name, str) == 0)
770 ** ------------------------
772 ** ------------------------
782 /* defaults for exported variables */
784 #ifdef DEFAULT_CONFIG
789 conf_init_string(&server_conf[CNF_ORG], s);
790 conf_init_string(&server_conf[CNF_MAILTO], "operators");
791 conf_init_string(&server_conf[CNF_DUMPUSER], CLIENT_LOGIN);
792 #ifdef DEFAULT_TAPE_DEVICE
793 s = DEFAULT_TAPE_DEVICE;
797 conf_init_string(&server_conf[CNF_TAPEDEV], s);
798 #ifdef DEFAULT_CHANGER_DEVICE
799 s = DEFAULT_CHANGER_DEVICE;
803 conf_init_string(&server_conf[CNF_CHNGRDEV], s);
804 conf_init_string(&server_conf[CNF_CHNGRFILE], "/usr/adm/amanda/changer-status");
805 #ifdef DEFAULT_RAW_TAPE_DEVICE
806 s = DEFAULT_RAW_TAPE_DEVICE;
810 conf_init_string (&server_conf[CNF_LABELSTR] , ".*");
811 conf_init_string (&server_conf[CNF_TAPELIST] , "tapelist");
812 conf_init_string (&server_conf[CNF_DISKFILE] , "disklist");
813 conf_init_string (&server_conf[CNF_INFOFILE] , "/usr/adm/amanda/curinfo");
814 conf_init_string (&server_conf[CNF_LOGDIR] , "/usr/adm/amanda");
815 conf_init_string (&server_conf[CNF_INDEXDIR] , "/usr/adm/amanda/index");
816 conf_init_ident (&server_conf[CNF_TAPETYPE] , "EXABYTE");
817 conf_init_int (&server_conf[CNF_DUMPCYCLE] , 10);
818 conf_init_int (&server_conf[CNF_RUNSPERCYCLE] , 0);
819 conf_init_int (&server_conf[CNF_TAPECYCLE] , 15);
820 conf_init_int (&server_conf[CNF_NETUSAGE] , 300);
821 conf_init_int (&server_conf[CNF_INPARALLEL] , 10);
822 conf_init_string (&server_conf[CNF_DUMPORDER] , "ttt");
823 conf_init_int (&server_conf[CNF_BUMPPERCENT] , 0);
824 conf_init_am64 (&server_conf[CNF_BUMPSIZE] , (off_t)10*1024);
825 conf_init_real (&server_conf[CNF_BUMPMULT] , 1.5);
826 conf_init_int (&server_conf[CNF_BUMPDAYS] , 2);
827 conf_init_string (&server_conf[CNF_TPCHANGER] , "");
828 conf_init_int (&server_conf[CNF_RUNTAPES] , 1);
829 conf_init_int (&server_conf[CNF_MAXDUMPS] , 1);
830 conf_init_time (&server_conf[CNF_ETIMEOUT] , (time_t)300);
831 conf_init_time (&server_conf[CNF_DTIMEOUT] , (time_t)1800);
832 conf_init_time (&server_conf[CNF_CTIMEOUT] , (time_t)30);
833 conf_init_int (&server_conf[CNF_TAPEBUFS] , 20);
834 conf_init_string (&server_conf[CNF_RAWTAPEDEV] , s);
835 conf_init_string (&server_conf[CNF_PRINTER] , "");
836 conf_init_bool (&server_conf[CNF_AUTOFLUSH] , 0);
837 conf_init_int (&server_conf[CNF_RESERVE] , 100);
838 conf_init_am64 (&server_conf[CNF_MAXDUMPSIZE] , (off_t)-1);
839 conf_init_string (&server_conf[CNF_COLUMNSPEC] , "");
840 conf_init_bool (&server_conf[CNF_AMRECOVER_DO_FSF] , 1);
841 conf_init_string (&server_conf[CNF_AMRECOVER_CHANGER] , "");
842 conf_init_bool (&server_conf[CNF_AMRECOVER_CHECK_LABEL], 1);
843 conf_init_taperalgo(&server_conf[CNF_TAPERALGO] , 0);
844 conf_init_string (&server_conf[CNF_DISPLAYUNIT] , "k");
845 conf_init_string (&server_conf[CNF_KRB5KEYTAB] , "/.amanda-v5-keytab");
846 conf_init_string (&server_conf[CNF_KRB5PRINCIPAL] , "service/amanda");
847 conf_init_string (&server_conf[CNF_LABEL_NEW_TAPES] , "");
848 conf_init_bool (&server_conf[CNF_USETIMESTAMPS] , 0);
850 /* defaults for internal variables */
852 conf_line_num = got_parserror = 0;
853 allow_overwrites = 0;
856 while(holdingdisks != NULL) {
860 holdingdisks = holdingdisks->next;
863 num_holdingdisks = 0;
865 /* free any previously declared dump, tape and interface types */
867 while(dumplist != NULL) {
871 dumplist = dumplist->next;
874 while(tapelist != NULL) {
878 tapelist = tapelist->next;
881 while(interface_list != NULL) {
885 interface_list = interface_list->next;
889 /* create some predefined dumptypes for backwards compatability */
890 init_dumptype_defaults();
891 dpcur.name = stralloc("NO-COMPRESS");
893 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_NONE);
896 init_dumptype_defaults();
897 dpcur.name = stralloc("COMPRESS-FAST");
899 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_FAST);
902 init_dumptype_defaults();
903 dpcur.name = stralloc("COMPRESS-BEST");
905 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_BEST);
908 init_dumptype_defaults();
909 dpcur.name = stralloc("COMPRESS-CUST");
911 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_CUST);
914 init_dumptype_defaults();
915 dpcur.name = stralloc("SRVCOMPRESS");
917 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_SERV_FAST);
920 init_dumptype_defaults();
921 dpcur.name = stralloc("BSD-AUTH");
923 conf_set_string(&dpcur.value[DUMPTYPE_SECURITY_DRIVER], "BSD");
926 init_dumptype_defaults();
927 dpcur.name = stralloc("KRB4-AUTH");
929 conf_set_string(&dpcur.value[DUMPTYPE_SECURITY_DRIVER], "KRB4");
932 init_dumptype_defaults();
933 dpcur.name = stralloc("NO-RECORD");
935 conf_set_bool(&dpcur.value[DUMPTYPE_RECORD], 0);
938 init_dumptype_defaults();
939 dpcur.name = stralloc("NO-HOLD");
941 conf_set_holding(&dpcur.value[DUMPTYPE_HOLDINGDISK], HOLD_NEVER);
944 init_dumptype_defaults();
945 dpcur.name = stralloc("NO-FULL");
947 conf_set_strategy(&dpcur.value[DUMPTYPE_STRATEGY], DS_NOFULL);
952 read_conffile_recursively(
955 /* Save globals used in read_confline(), elsewhere. */
956 int save_line_num = conf_line_num;
957 FILE *save_conf = conf_conf;
958 char *save_confname = conf_confname;
961 if (*filename == '/' || config_dir == NULL) {
962 conf_confname = stralloc(filename);
964 conf_confname = stralloc2(config_dir, filename);
967 if((conf_conf = fopen(conf_confname, "r")) == NULL) {
968 fprintf(stderr, "could not open conf file \"%s\": %s\n", conf_confname,
970 amfree(conf_confname);
977 /* read_confline() can invoke us recursively via "includefile" */
979 rc = read_confline();
983 amfree(conf_confname);
985 /* Restore servers */
986 conf_line_num = save_line_num;
987 conf_conf = save_conf;
988 conf_confname = save_confname;
992 /* ------------------------ */
1001 keytable = server_keytab;
1004 get_conftoken(CONF_ANY);
1006 case CONF_INCLUDEFILE:
1011 get_conftoken(CONF_STRING);
1013 if (*fn == '/' || config_dir == NULL) {
1014 cname = stralloc(fn);
1016 cname = stralloc2(config_dir, fn);
1018 if ( cname != NULL && (access(cname, R_OK) == 0)) {
1019 read_conffile_recursively(cname);
1022 conf_parserror("cannot open %s: %s\n", fn, strerror(errno));
1034 get_conftoken(CONF_ANY);
1035 if(tok == CONF_DUMPTYPE) get_dumptype();
1036 else if(tok == CONF_TAPETYPE) get_tapetype();
1037 else if(tok == CONF_INTERFACE) get_interface();
1038 else conf_parserror("DUMPTYPE, INTERFACE or TAPETYPE expected");
1041 case CONF_NL: /* empty line */
1044 case CONF_END: /* end of file */
1049 for(np = server_var; np->token != CONF_UNKNOWN; np++)
1050 if(np->token == tok) break;
1052 if(np->token == CONF_UNKNOWN) {
1053 conf_parserror("configuration keyword expected");
1055 np->read_function(np, &server_conf[np->parm]);
1057 np->validate(np, &server_conf[np->parm]);
1062 get_conftoken(CONF_NL);
1066 t_conf_var holding_var [] = {
1067 { CONF_DIRECTORY, CONFTYPE_STRING, read_string, HOLDING_DISKDIR , NULL },
1068 { CONF_COMMENT , CONFTYPE_STRING, read_string, HOLDING_COMMENT , NULL },
1069 { CONF_USE , CONFTYPE_AM64 , read_am64 , HOLDING_DISKSIZE , validate_use },
1070 { CONF_CHUNKSIZE, CONFTYPE_AM64 , read_am64 , HOLDING_CHUNKSIZE, validate_chunksize },
1071 { CONF_UNKNOWN , CONFTYPE_INT , NULL , HOLDING_HOLDING , NULL }
1079 int save_overwrites;
1081 save_overwrites = allow_overwrites;
1082 allow_overwrites = 1;
1084 init_holdingdisk_defaults();
1086 get_conftoken(CONF_IDENT);
1087 hdcur.name = stralloc(tokenval.v.s);
1088 hdcur.seen = conf_line_num;
1090 prefix = vstralloc( "HOLDINGDISK:", hdcur.name, ":", NULL);
1091 read_block(server_options, holding_var, server_keytab, hdcur.value, prefix,
1092 "holding disk parameter expected", 1, NULL);
1094 get_conftoken(CONF_NL);
1096 hdcur.disksize = holdingdisk_get_disksize(&hdcur);
1099 allow_overwrites = save_overwrites;
1103 init_holdingdisk_defaults(
1106 conf_init_string(&hdcur.value[HOLDING_COMMENT] , "");
1107 conf_init_string(&hdcur.value[HOLDING_DISKDIR] , "");
1108 conf_init_am64(&hdcur.value[HOLDING_DISKSIZE] , (off_t)0);
1109 /* 1 Gb = 1M counted in 1Kb blocks */
1110 conf_init_am64(&hdcur.value[HOLDING_CHUNKSIZE], (off_t)1024*1024);
1112 hdcur.up = (void *)0;
1113 hdcur.disksize = 0LL;
1122 hp = alloc(sizeof(holdingdisk_t));
1124 hp->next = holdingdisks;
1131 t_conf_var dumptype_var [] = {
1132 { CONF_COMMENT , CONFTYPE_STRING , read_string , DUMPTYPE_COMMENT , NULL },
1133 { CONF_AUTH , CONFTYPE_STRING , read_string , DUMPTYPE_SECURITY_DRIVER , NULL },
1134 { CONF_BUMPDAYS , CONFTYPE_INT , read_int , DUMPTYPE_BUMPDAYS , NULL },
1135 { CONF_BUMPMULT , CONFTYPE_REAL , read_real , DUMPTYPE_BUMPMULT , NULL },
1136 { CONF_BUMPSIZE , CONFTYPE_AM64 , read_am64 , DUMPTYPE_BUMPSIZE , NULL },
1137 { CONF_BUMPPERCENT , CONFTYPE_INT , read_int , DUMPTYPE_BUMPPERCENT , NULL },
1138 { CONF_COMPRATE , CONFTYPE_REAL , get_comprate, DUMPTYPE_COMPRATE , NULL },
1139 { CONF_COMPRESS , CONFTYPE_INT , get_compress, DUMPTYPE_COMPRESS , NULL },
1140 { CONF_ENCRYPT , CONFTYPE_INT , get_encrypt , DUMPTYPE_ENCRYPT , NULL },
1141 { CONF_DUMPCYCLE , CONFTYPE_INT , read_int , DUMPTYPE_DUMPCYCLE , validate_positive0 },
1142 { CONF_EXCLUDE , CONFTYPE_EXINCLUDE, get_exclude , DUMPTYPE_EXCLUDE , NULL },
1143 { CONF_INCLUDE , CONFTYPE_EXINCLUDE, get_exclude , DUMPTYPE_INCLUDE , NULL },
1144 { CONF_IGNORE , CONFTYPE_BOOL , read_bool , DUMPTYPE_IGNORE , NULL },
1145 { CONF_HOLDING , CONFTYPE_HOLDING , get_holding , DUMPTYPE_HOLDINGDISK , NULL },
1146 { CONF_INDEX , CONFTYPE_BOOL , read_bool , DUMPTYPE_INDEX , NULL },
1147 { CONF_KENCRYPT , CONFTYPE_BOOL , read_bool , DUMPTYPE_KENCRYPT , NULL },
1148 { CONF_MAXDUMPS , CONFTYPE_INT , read_int , DUMPTYPE_MAXDUMPS , validate_positive1 },
1149 { CONF_MAXPROMOTEDAY , CONFTYPE_INT , read_int , DUMPTYPE_MAXPROMOTEDAY , validate_positive0 },
1150 { CONF_PRIORITY , CONFTYPE_PRIORITY , get_priority, DUMPTYPE_PRIORITY , NULL },
1151 { CONF_PROGRAM , CONFTYPE_STRING , read_string , DUMPTYPE_PROGRAM , NULL },
1152 { CONF_RECORD , CONFTYPE_BOOL , read_bool , DUMPTYPE_RECORD , NULL },
1153 { CONF_SKIP_FULL , CONFTYPE_BOOL , read_bool , DUMPTYPE_SKIP_FULL , NULL },
1154 { CONF_SKIP_INCR , CONFTYPE_BOOL , read_bool , DUMPTYPE_SKIP_INCR , NULL },
1155 { CONF_STARTTIME , CONFTYPE_TIME , read_time , DUMPTYPE_START_T , NULL },
1156 { CONF_STRATEGY , CONFTYPE_INT , get_strategy, DUMPTYPE_STRATEGY , NULL },
1157 { CONF_TAPE_SPLITSIZE , CONFTYPE_AM64 , read_am64 , DUMPTYPE_TAPE_SPLITSIZE , validate_positive0 },
1158 { CONF_SPLIT_DISKBUFFER , CONFTYPE_STRING , read_string , DUMPTYPE_SPLIT_DISKBUFFER , NULL },
1159 { CONF_ESTIMATE , CONFTYPE_INT , get_estimate, DUMPTYPE_ESTIMATE , NULL },
1160 { CONF_SRV_ENCRYPT , CONFTYPE_STRING , read_string , DUMPTYPE_SRV_ENCRYPT , NULL },
1161 { CONF_CLNT_ENCRYPT , CONFTYPE_STRING , read_string , DUMPTYPE_CLNT_ENCRYPT , NULL },
1162 { CONF_AMANDAD_PATH , CONFTYPE_STRING , read_string , DUMPTYPE_AMANDAD_PATH , NULL },
1163 { CONF_CLIENT_USERNAME , CONFTYPE_STRING , read_string , DUMPTYPE_CLIENT_USERNAME , NULL },
1164 { CONF_SSH_KEYS , CONFTYPE_STRING , read_string , DUMPTYPE_SSH_KEYS , NULL },
1165 { CONF_SRVCOMPPROG , CONFTYPE_STRING , read_string , DUMPTYPE_SRVCOMPPROG , NULL },
1166 { CONF_CLNTCOMPPROG , CONFTYPE_STRING , read_string , DUMPTYPE_CLNTCOMPPROG , NULL },
1167 { CONF_FALLBACK_SPLITSIZE, CONFTYPE_AM64 , read_am64 , DUMPTYPE_FALLBACK_SPLITSIZE, NULL },
1168 { CONF_SRV_DECRYPT_OPT , CONFTYPE_STRING , read_string , DUMPTYPE_SRV_DECRYPT_OPT , NULL },
1169 { CONF_CLNT_DECRYPT_OPT , CONFTYPE_STRING , read_string , DUMPTYPE_CLNT_DECRYPT_OPT , NULL },
1170 { CONF_UNKNOWN , CONFTYPE_INT , NULL , DUMPTYPE_DUMPTYPE , NULL }
1180 int save_overwrites;
1181 FILE *saved_conf = NULL;
1182 char *saved_fname = NULL;
1186 saved_conf = conf_conf;
1191 saved_fname = conf_confname;
1192 conf_confname = fname;
1196 conf_line_num = *linenum;
1198 save_overwrites = allow_overwrites;
1199 allow_overwrites = 1;
1201 init_dumptype_defaults();
1205 get_conftoken(CONF_IDENT);
1206 dpcur.name = stralloc(tokenval.v.s);
1208 dpcur.seen = conf_line_num;
1210 prefix = vstralloc( "DUMPTYPE:", dpcur.name, ":", NULL);
1211 read_block(server_options, dumptype_var, server_keytab, dpcur.value,
1212 prefix, "dumptype parameter expected",
1213 (name == NULL), *copy_dumptype);
1216 get_conftoken(CONF_NL);
1218 /* XXX - there was a stupidity check in here for skip-incr and
1219 ** skip-full. This check should probably be somewhere else. */
1223 allow_overwrites = save_overwrites;
1226 *linenum = conf_line_num;
1229 conf_confname = saved_fname;
1232 conf_conf = saved_conf;
1234 return lookup_dumptype(dpcur.name);
1240 read_dumptype(NULL, NULL, NULL, NULL);
1244 init_dumptype_defaults(void)
1247 conf_init_string (&dpcur.value[DUMPTYPE_COMMENT] , "");
1248 conf_init_string (&dpcur.value[DUMPTYPE_PROGRAM] , "DUMP");
1249 conf_init_string (&dpcur.value[DUMPTYPE_SRVCOMPPROG] , "");
1250 conf_init_string (&dpcur.value[DUMPTYPE_CLNTCOMPPROG] , "");
1251 conf_init_string (&dpcur.value[DUMPTYPE_SRV_ENCRYPT] , "");
1252 conf_init_string (&dpcur.value[DUMPTYPE_CLNT_ENCRYPT] , "");
1253 conf_init_string (&dpcur.value[DUMPTYPE_AMANDAD_PATH] , "X");
1254 conf_init_string (&dpcur.value[DUMPTYPE_CLIENT_USERNAME] , "X");
1255 conf_init_string (&dpcur.value[DUMPTYPE_SSH_KEYS] , "X");
1256 conf_init_string (&dpcur.value[DUMPTYPE_SECURITY_DRIVER] , "BSD");
1257 conf_init_exinclude(&dpcur.value[DUMPTYPE_EXCLUDE]);
1258 conf_init_exinclude(&dpcur.value[DUMPTYPE_INCLUDE]);
1259 conf_init_priority (&dpcur.value[DUMPTYPE_PRIORITY] , 1);
1260 conf_init_int (&dpcur.value[DUMPTYPE_DUMPCYCLE] , server_conf[CNF_DUMPCYCLE].v.i);
1261 conf_init_int (&dpcur.value[DUMPTYPE_MAXDUMPS] , server_conf[CNF_MAXDUMPS].v.i);
1262 conf_init_int (&dpcur.value[DUMPTYPE_MAXPROMOTEDAY] , 10000);
1263 conf_init_int (&dpcur.value[DUMPTYPE_BUMPPERCENT] , server_conf[CNF_BUMPPERCENT].v.i);
1264 conf_init_am64 (&dpcur.value[DUMPTYPE_BUMPSIZE] , server_conf[CNF_BUMPSIZE].v.am64);
1265 conf_init_int (&dpcur.value[DUMPTYPE_BUMPDAYS] , server_conf[CNF_BUMPDAYS].v.i);
1266 conf_init_real (&dpcur.value[DUMPTYPE_BUMPMULT] , server_conf[CNF_BUMPMULT].v.r);
1267 conf_init_time (&dpcur.value[DUMPTYPE_START_T] , (time_t)0);
1268 conf_init_strategy (&dpcur.value[DUMPTYPE_STRATEGY] , DS_STANDARD);
1269 conf_init_estimate (&dpcur.value[DUMPTYPE_ESTIMATE] , ES_CLIENT);
1270 conf_init_compress (&dpcur.value[DUMPTYPE_COMPRESS] , COMP_FAST);
1271 conf_init_encrypt (&dpcur.value[DUMPTYPE_ENCRYPT] , ENCRYPT_NONE);
1272 conf_init_string (&dpcur.value[DUMPTYPE_SRV_DECRYPT_OPT] , "-d");
1273 conf_init_string (&dpcur.value[DUMPTYPE_CLNT_DECRYPT_OPT] , "-d");
1274 conf_init_rate (&dpcur.value[DUMPTYPE_COMPRATE] , 0.50, 0.50);
1275 conf_init_am64 (&dpcur.value[DUMPTYPE_TAPE_SPLITSIZE] , (off_t)0);
1276 conf_init_am64 (&dpcur.value[DUMPTYPE_FALLBACK_SPLITSIZE], (off_t)10 * 1024);
1277 conf_init_string (&dpcur.value[DUMPTYPE_SPLIT_DISKBUFFER] , NULL);
1278 conf_init_bool (&dpcur.value[DUMPTYPE_RECORD] , 1);
1279 conf_init_bool (&dpcur.value[DUMPTYPE_SKIP_INCR] , 0);
1280 conf_init_bool (&dpcur.value[DUMPTYPE_SKIP_FULL] , 0);
1281 conf_init_holding (&dpcur.value[DUMPTYPE_HOLDINGDISK] , HOLD_AUTO);
1282 conf_init_bool (&dpcur.value[DUMPTYPE_KENCRYPT] , 0);
1283 conf_init_bool (&dpcur.value[DUMPTYPE_IGNORE] , 0);
1284 conf_init_bool (&dpcur.value[DUMPTYPE_INDEX] , 1);
1290 dumptype_t *dp, *dp1;;
1292 dp = lookup_dumptype(dpcur.name);
1294 if(dp != (dumptype_t *)0) {
1295 conf_parserror("dumptype %s already defined on line %d", dp->name, dp->seen);
1299 dp = alloc(sizeof(dumptype_t));
1302 /* add at end of list */
1307 while (dp1->next != NULL) {
1320 dt = lookup_dumptype(tokenval.v.s);
1323 conf_parserror("dumptype parameter expected");
1327 for(i=0; i < DUMPTYPE_DUMPTYPE; i++) {
1328 if(dt->value[i].seen) {
1329 free_val_t(&dpcur.value[i]);
1330 copy_val_t(&dpcur.value[i], &dt->value[i]);
1335 t_conf_var tapetype_var [] = {
1336 { CONF_COMMENT , CONFTYPE_STRING, read_string, TAPETYPE_COMMENT , NULL },
1337 { CONF_LBL_TEMPL, CONFTYPE_STRING, read_string, TAPETYPE_LBL_TEMPL, NULL },
1338 { CONF_BLOCKSIZE, CONFTYPE_SIZE , read_size , TAPETYPE_BLOCKSIZE, validate_blocksize },
1339 { CONF_LENGTH , CONFTYPE_AM64 , read_am64 , TAPETYPE_LENGTH , validate_positive0 },
1340 { CONF_FILEMARK , CONFTYPE_AM64 , read_am64 , TAPETYPE_FILEMARK , NULL },
1341 { CONF_SPEED , CONFTYPE_INT , read_int , TAPETYPE_SPEED , validate_positive0 },
1342 { CONF_FILE_PAD , CONFTYPE_BOOL , read_bool , TAPETYPE_FILE_PAD , NULL },
1343 { CONF_UNKNOWN , CONFTYPE_INT , NULL , TAPETYPE_TAPETYPE , NULL }
1349 int save_overwrites;
1352 save_overwrites = allow_overwrites;
1353 allow_overwrites = 1;
1355 init_tapetype_defaults();
1357 get_conftoken(CONF_IDENT);
1358 tpcur.name = stralloc(tokenval.v.s);
1359 tpcur.seen = conf_line_num;
1361 prefix = vstralloc( "TAPETYPE:", tpcur.name, ":", NULL);
1362 read_block(server_options, tapetype_var, server_keytab, tpcur.value,
1363 prefix, "tapetype parameter expected", 1, ©_tapetype);
1365 get_conftoken(CONF_NL);
1369 allow_overwrites = save_overwrites;
1373 init_tapetype_defaults(void)
1375 conf_init_string(&tpcur.value[TAPETYPE_COMMENT] , "");
1376 conf_init_string(&tpcur.value[TAPETYPE_LBL_TEMPL], "");
1377 conf_init_size (&tpcur.value[TAPETYPE_BLOCKSIZE], DISK_BLOCK_KB);
1378 conf_init_am64 (&tpcur.value[TAPETYPE_LENGTH] , (off_t)2000 * 1024);
1379 conf_init_am64 (&tpcur.value[TAPETYPE_FILEMARK] , (off_t)1000);
1380 conf_init_int (&tpcur.value[TAPETYPE_SPEED] , 200);
1381 conf_init_bool (&tpcur.value[TAPETYPE_FILE_PAD] , 1);
1387 tapetype_t *tp, *tp1;
1389 tp = lookup_tapetype(tpcur.name);
1391 if(tp != (tapetype_t *)0) {
1393 conf_parserror("tapetype %s already defined on line %d", tp->name, tp->seen);
1397 tp = alloc(sizeof(tapetype_t));
1399 /* add at end of list */
1404 while (tp1->next != NULL) {
1417 tp = lookup_tapetype(tokenval.v.s);
1420 conf_parserror("tape type parameter expected");
1424 for(i=0; i < TAPETYPE_TAPETYPE; i++) {
1425 if(tp->value[i].seen) {
1426 free_val_t(&tpcur.value[i]);
1427 copy_val_t(&tpcur.value[i], &tp->value[i]);
1432 t_conf_var interface_var [] = {
1433 { CONF_COMMENT, CONFTYPE_STRING, read_string, INTER_COMMENT , NULL },
1434 { CONF_USE , CONFTYPE_INT , read_int , INTER_MAXUSAGE, validate_positive1 },
1435 { CONF_UNKNOWN, CONFTYPE_INT , NULL , INTER_INTER , NULL }
1441 int save_overwrites;
1444 save_overwrites = allow_overwrites;
1445 allow_overwrites = 1;
1447 init_interface_defaults();
1449 get_conftoken(CONF_IDENT);
1450 ifcur.name = stralloc(tokenval.v.s);
1451 ifcur.seen = conf_line_num;
1453 prefix = vstralloc( "INTERFACE:", ifcur.name, ":", NULL);
1454 read_block(server_options, interface_var, server_keytab, ifcur.value,
1455 prefix, "interface parameter expected", 1, ©_interface);
1457 get_conftoken(CONF_NL);
1461 allow_overwrites = save_overwrites;
1467 init_interface_defaults(void)
1469 conf_init_string(&ifcur.value[INTER_COMMENT] , "");
1470 conf_init_int (&ifcur.value[INTER_MAXUSAGE], 300);
1476 save_interface(void)
1478 interface_t *ip, *ip1;
1480 ip = lookup_interface(ifcur.name);
1482 if(ip != (interface_t *)0) {
1483 conf_parserror("interface %s already defined on line %d", ip->name,
1488 ip = alloc(sizeof(interface_t));
1490 /* add at end of list */
1491 if(!interface_list) {
1492 interface_list = ip;
1494 ip1 = interface_list;
1495 while (ip1->next != NULL) {
1503 copy_interface(void)
1515 ip = lookup_interface(tokenval.v.s);
1518 conf_parserror("interface parameter expected");
1522 for(i=0; i < INTER_INTER; i++) {
1523 if(ip->value[i].seen) {
1524 free_val_t(&ifcur.value[i]);
1525 copy_val_t(&ifcur.value[i], &ip->value[i]);
1536 get_conftoken(CONF_REAL);
1537 val->v.rate[0] = tokenval.v.r;
1538 val->v.rate[1] = tokenval.v.r;
1539 val->seen = tokenval.seen;
1540 if(tokenval.v.r < 0) {
1541 conf_parserror("full compression rate must be >= 0");
1544 get_conftoken(CONF_ANY);
1559 get_conftoken(CONF_REAL);
1560 val->v.rate[1] = tokenval.v.r;
1561 if(tokenval.v.r < 0) {
1562 conf_parserror("incremental compression rate must be >= 0");
1571 int serv, clie, none, fast, best, custom;
1578 serv = clie = none = fast = best = custom = 0;
1582 get_conftoken(CONF_ANY);
1584 case CONF_NONE: none = 1; break;
1585 case CONF_FAST: fast = 1; break;
1586 case CONF_BEST: best = 1; break;
1587 case CONF_CLIENT: clie = 1; break;
1588 case CONF_SERVER: serv = 1; break;
1589 case CONF_CUSTOM: custom=1; break;
1590 case CONF_NL: done = 1; break;
1591 case CONF_END: done = 1; break;
1594 serv = clie = 1; /* force an error */
1598 if(serv + clie == 0) clie = 1; /* default to client */
1599 if(none + fast + best + custom == 0) fast = 1; /* default to fast */
1604 if(none && !fast && !best && !custom) comp = COMP_NONE;
1605 if(!none && fast && !best && !custom) comp = COMP_FAST;
1606 if(!none && !fast && best && !custom) comp = COMP_BEST;
1607 if(!none && !fast && !best && custom) comp = COMP_CUST;
1611 if(none && !fast && !best && !custom) comp = COMP_NONE;
1612 if(!none && fast && !best && !custom) comp = COMP_SERV_FAST;
1613 if(!none && !fast && best && !custom) comp = COMP_SERV_BEST;
1614 if(!none && !fast && !best && custom) comp = COMP_SERV_CUST;
1617 if((int)comp == -1) {
1618 conf_parserror("NONE, CLIENT FAST, CLIENT BEST, CLIENT CUSTOM, SERVER FAST, SERVER BEST or SERVER CUSTOM expected");
1622 val->v.i = (int)comp;
1635 get_conftoken(CONF_ANY);
1638 encrypt = ENCRYPT_NONE;
1642 encrypt = ENCRYPT_CUST;
1646 encrypt = ENCRYPT_SERV_CUST;
1650 conf_parserror("NONE, CLIENT or SERVER expected");
1651 encrypt = ENCRYPT_NONE;
1655 val->v.i = (int)encrypt;
1663 dump_holdingdisk_t holding;
1668 get_conftoken(CONF_ANY);
1671 holding = HOLD_NEVER;
1675 holding = HOLD_AUTO;
1679 holding = HOLD_REQUIRED;
1682 default: /* can be a BOOLEAN */
1684 holding = (dump_holdingdisk_t)get_bool();
1686 holding = HOLD_NEVER;
1687 else if (holding == 1 || holding == 2)
1688 holding = HOLD_AUTO;
1690 conf_parserror("NEVER, AUTO or REQUIRED expected");
1694 val->v.i = (int)holding;
1705 get_conftoken(CONF_ANY);
1707 case CONF_FIRST: val->v.i = ALGO_FIRST; break;
1708 case CONF_FIRSTFIT: val->v.i = ALGO_FIRSTFIT; break;
1709 case CONF_LARGEST: val->v.i = ALGO_LARGEST; break;
1710 case CONF_LARGESTFIT: val->v.i = ALGO_LARGESTFIT; break;
1711 case CONF_SMALLEST: val->v.i = ALGO_SMALLEST; break;
1712 case CONF_LAST: val->v.i = ALGO_LAST; break;
1714 conf_parserror("FIRST, FIRSTFIT, LARGEST, LARGESTFIT, SMALLEST or LAST expected");
1728 get_conftoken(CONF_ANY);
1730 case CONF_LOW: pri = 0; break;
1731 case CONF_MEDIUM: pri = 1; break;
1732 case CONF_HIGH: pri = 2; break;
1733 case CONF_INT: pri = tokenval.v.i; break;
1735 conf_parserror("LOW, MEDIUM, HIGH or integer expected");
1751 get_conftoken(CONF_ANY);
1757 strat = DS_STANDARD;
1769 strat = DS_INCRONLY;
1772 conf_parserror("STANDARD or NOFULL expected");
1773 strat = DS_STANDARD;
1788 get_conftoken(CONF_ANY);
1797 estime = ES_CALCSIZE;
1800 conf_parserror("CLIENT, SERVER or CALCSIZE expected");
1811 int file, got_one = 0;
1816 get_conftoken(CONF_ANY);
1817 if(tok == CONF_LIST) {
1819 get_conftoken(CONF_ANY);
1823 if(tok == CONF_EFILE) get_conftoken(CONF_ANY);
1825 val->v.exinclude.type = file;
1826 exclude = val->v.exinclude.sl;
1829 if(tok == CONF_OPTIONAL) {
1830 get_conftoken(CONF_ANY);
1834 if(tok == CONF_APPEND) {
1835 get_conftoken(CONF_ANY);
1842 while(tok == CONF_STRING) {
1843 exclude = append_sl(exclude, tokenval.v.s);
1845 get_conftoken(CONF_ANY);
1849 if(got_one == 0) { free_sl(exclude); exclude = NULL; }
1851 val->v.exinclude.sl = exclude;
1852 val->v.exinclude.optional = optional;
1856 static void get_include(np, val)
1860 int list, got_one = 0;
1865 get_conftoken(CONF_ANY);
1866 if(tok == CONF_LIST) {
1868 include = dpcur.value[DUMPTYPE_INCLUDE_LIST].v.sl;
1869 ckseen(&dpcur.value[DUMPTYPE_INCLUDE_LIST].seen);
1870 get_conftoken(CONF_ANY);
1874 include = dpcur.value[DUMPTYPE_INCLUDE_FILE].v.sl;
1875 ckseen(&dpcur.value[DUMPTYPE_INCLUDE_FILE].seen);
1876 if(tok == CONF_EFILE) get_conftoken(CONF_ANY);
1879 if(tok == CONF_OPTIONAL) {
1880 get_conftoken(CONF_ANY);
1884 if(tok == CONF_APPEND) {
1885 get_conftoken(CONF_ANY);
1894 while(tok == CONF_STRING) {
1895 include = append_sl(include, tokenval.v.s);
1897 get_conftoken(CONF_ANY);
1901 if(got_one == 0) { free_sl(include); include = NULL; }
1904 dpcur.value[DUMPTYPE_INCLUDE_FILE].v.sl = include;
1906 dpcur.value[DUMPTYPE_INCLUDE_LIST].v.sl = include;
1907 if(!append || optional)
1908 dpcur.value[DUMPTYPE_INCLUDE_OPTIONAL].v.i = optional;
1913 /* ------------------------ */
1916 ColumnDataCount(void )
1918 return (int)(SIZEOF(ColumnData) / SIZEOF(ColumnData[0]));
1921 /* conversion from string to table index
1929 for (cn=0; ColumnData[cn].Name != NULL; cn++) {
1930 if (strcasecmp(s, ColumnData[cn].Name) == 0) {
1941 return s[strlen(s)-1];
1945 SetColumDataFromString(
1951 char *myname= "SetColumDataFromString";
1955 /* Convert from a Columspec string to our internal format
1956 * of columspec. The purpose is to provide this string
1957 * as configuration paramter in the amanda.conf file or
1958 * (maybe) as environment variable.
1960 * This text should go as comment into the sample amanda.conf
1962 * The format for such a ColumnSpec string s is a ',' seperated
1963 * list of triples. Each triple consists of
1964 * -the name of the column (as in ColumnData.Name)
1965 * -prefix before the column
1966 * -the width of the column
1967 * if set to -1 it will be recalculated
1968 * to the maximum length of a line to print.
1970 * "Disk=1:17,HostName=1:10,OutKB=1:7"
1972 * "Disk=1:-1,HostName=1:10,OutKB=1:7"
1974 * You need only specify those colums that should be changed from
1975 * the default. If nothing is specified in the configfile, the
1976 * above compiled in values will be in effect, resulting in an
1977 * output as it was all the time.
1984 char *eon= strchr(s, '=');
1987 *errstr = stralloc2("invalid columnspec: ", s);
1989 fprintf(stderr, "%s: %s\n", myname, *errstr);
1994 cn=StringToColumn(s);
1995 if (ColumnData[cn].Name == NULL) {
1996 *errstr = stralloc2("invalid column name: ", s);
1998 fprintf(stderr, "%s: %s\n", myname, *errstr);
2002 if (sscanf(eon+1, "%d:%d", &Space, &Width) != 2) {
2003 *errstr = stralloc2("invalid format: ", eon + 1);
2005 fprintf(stderr, "%s: %s\n", myname, *errstr);
2009 ColumnData[cn].Width= Width;
2010 ColumnData[cn].PrefixSpace = Space;
2011 if (LastChar(ColumnData[cn].Format) == 's') {
2013 ColumnData[cn].MaxWidth= 1;
2015 if (Width > ColumnData[cn].Precision)
2016 ColumnData[cn].Precision= Width;
2018 else if (Width < ColumnData[cn].Precision)
2019 ColumnData[cn].Precision = Width;
2020 s= strchr(eon+1, ',');
2029 getconf_unit_divisor(void)
2031 return unit_divisor;
2034 /* ------------------------ */
2050 printf("AMANDA CONFIGURATION FROM FILE \"%s\":\n\n", filename);
2052 for(i=0; i < CNF_CNF; i++) {
2053 for(np=server_var; np->token != CONF_UNKNOWN; np++) {
2057 if(np->token == CONF_UNKNOWN)
2058 error("server bad value");
2060 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2061 if(kt->token == np->token) break;
2062 if(kt->token == CONF_UNKNOWN)
2063 error("server bad token");
2065 printf("%-21s %s\n", kt->keyword, conf_print(&server_conf[i]));
2068 for(hp = holdingdisks; hp != NULL; hp = hp->next) {
2069 printf("\nHOLDINGDISK %s {\n", hp->name);
2070 for(i=0; i < HOLDING_HOLDING; i++) {
2071 for(np=holding_var; np->token != CONF_UNKNOWN; np++) {
2075 if(np->token == CONF_UNKNOWN)
2076 error("holding bad value");
2078 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++) {
2079 if(kt->token == np->token)
2082 if(kt->token == CONF_UNKNOWN)
2083 error("holding bad token");
2085 printf(" %-9s %s\n", kt->keyword, conf_print(&hp->value[i]));
2090 for(tp = tapelist; tp != NULL; tp = tp->next) {
2091 printf("\nDEFINE TAPETYPE %s {\n", tp->name);
2092 for(i=0; i < TAPETYPE_TAPETYPE; i++) {
2093 for(np=tapetype_var; np->token != CONF_UNKNOWN; np++)
2094 if(np->parm == i) break;
2095 if(np->token == CONF_UNKNOWN)
2096 error("tapetype bad value");
2098 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2099 if(kt->token == np->token) break;
2100 if(kt->token == CONF_UNKNOWN)
2101 error("tapetype bad token");
2103 printf(" %-9s %s\n", kt->keyword, conf_print(&tp->value[i]));
2108 for(dp = dumplist; dp != NULL; dp = dp->next) {
2113 printf("\n%sDEFINE DUMPTYPE %s {\n", prefix, dp->name);
2114 for(i=0; i < DUMPTYPE_DUMPTYPE; i++) {
2115 for(np=dumptype_var; np->token != CONF_UNKNOWN; np++)
2116 if(np->parm == i) break;
2117 if(np->token == CONF_UNKNOWN)
2118 error("dumptype bad value");
2120 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2121 if(kt->token == np->token) break;
2122 if(kt->token == CONF_UNKNOWN)
2123 error("dumptype bad token");
2125 printf("%s %-19s %s\n", prefix, kt->keyword, conf_print(&dp->value[i]));
2127 printf("%s}\n", prefix);
2130 for(ip = interface_list; ip != NULL; ip = ip->next) {
2131 if(strcmp(ip->name,"default") == 0)
2135 printf("\n%sDEFINE INTERFACE %s {\n", prefix, ip->name);
2136 for(i=0; i < INTER_INTER; i++) {
2137 for(np=interface_var; np->token != CONF_UNKNOWN; np++)
2138 if(np->parm == i) break;
2139 if(np->token == CONF_UNKNOWN)
2140 error("interface bad value");
2142 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2143 if(kt->token == np->token) break;
2144 if(kt->token == CONF_UNKNOWN)
2145 error("interface bad token");
2147 printf("%s %-9s %s\n", prefix, kt->keyword, conf_print(&ip->value[i]));
2149 printf("%s}\n",prefix);
2165 unsigned long malloc_hist_1, malloc_size_1;
2166 unsigned long malloc_hist_2, malloc_size_2;
2170 set_pname("conffile");
2172 /* Don't die when child closes pipe */
2173 signal(SIGPIPE, SIG_IGN);
2175 malloc_size_1 = malloc_inuse(&malloc_hist_1);
2180 if (argv[1][0] == '/') {
2181 config_dir = stralloc(argv[1]);
2182 config_name = strrchr(config_dir, '/') + 1;
2183 config_name[-1] = '\0';
2184 config_dir = newstralloc2(config_dir, config_dir, "/");
2186 config_name = stralloc(argv[1]);
2187 config_dir = vstralloc(CONFIG_DIR, "/", config_name, "/", NULL);
2190 char my_cwd[STR_SIZE];
2192 if (getcwd(my_cwd, sizeof(my_cwd)) == NULL) {
2193 error("cannot determine current working directory");
2195 config_dir = stralloc2(my_cwd, "/");
2196 if ((config_name = strrchr(my_cwd, '/')) != NULL) {
2197 config_name = stralloc(config_name + 1);
2201 conffile = stralloc2(config_dir, CONFFILE_NAME);
2202 result = read_conffile(conffile);
2204 diskfile = getconf_str(CNF_DISKFILE);
2205 if (diskfile != NULL && access(diskfile, R_OK) == 0) {
2206 result = read_diskfile(diskfile, &lst);
2209 dump_configuration(CONFFILE_NAME);
2212 malloc_size_2 = malloc_inuse(&malloc_hist_2);
2214 if(malloc_size_1 != malloc_size_2) {
2215 malloc_list(fileno(stderr), malloc_hist_1, malloc_hist_2);
2224 generic_get_security_conf(
2229 if(!string || !*string)
2232 if(strcmp(string, "krb5principal")==0) {
2233 return(getconf_str(CNF_KRB5PRINCIPAL));
2234 } else if(strcmp(string, "krb5keytab")==0) {
2235 return(getconf_str(CNF_KRB5KEYTAB));
2246 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2247 if(kt->token == token) break;
2249 if(kt->token == CONF_UNKNOWN)
2251 return(kt->keyword);
2263 char *myarg, *value;
2264 command_option_t *server_option;
2266 server_options = alloc((size_t)(parse_argc+1) * SIZEOF(*server_options));
2267 server_option = server_options;
2268 server_option->name = NULL;
2270 my_argv = alloc((size_t)parse_argc * SIZEOF(char *));
2271 *new_argv = my_argv;
2274 while(i<parse_argc) {
2275 if(strncmp(parse_argv[i],"-o",2) == 0) {
2276 if(strlen(parse_argv[i]) > 2)
2277 myarg = &parse_argv[i][2];
2281 error("expect something after -o");
2282 myarg = parse_argv[i];
2284 value = index(myarg,'=');
2285 if (value == NULL) {
2286 conf_parserror("Must specify a value for %s.\n", myarg);
2290 server_option->used = 0;
2291 server_option->name = stralloc(myarg);
2292 server_option->value = stralloc(value);
2294 server_option->name = NULL;
2298 my_argv[*new_argc] = stralloc(parse_argv[i]);
2306 report_bad_conf_arg(void)
2308 command_option_t *command_option;
2310 for(command_option = server_options; command_option->name != NULL;
2312 if(command_option->used == 0) {
2313 fprintf(stderr,"argument -o%s=%s not used\n",
2314 command_option->name, command_option->value);
2320 free_server_config(void)
2322 holdingdisk_t *hp, *hpnext;
2323 dumptype_t *dp, *dpnext;
2324 tapetype_t *tp, *tpnext;
2325 interface_t *ip, *ipnext;
2326 command_option_t *server_option;
2329 for(hp=holdingdisks; hp != NULL; hp = hpnext) {
2331 for(i=0; i<HOLDING_HOLDING-1; i++) {
2332 free_val_t(&hp->value[i]);
2338 for(dp=dumplist; dp != NULL; dp = dpnext) {
2340 for(i=0; i<DUMPTYPE_DUMPTYPE-1; i++) {
2341 free_val_t(&dp->value[i]);
2347 for(tp=tapelist; tp != NULL; tp = tpnext) {
2349 for(i=0; i<TAPETYPE_TAPETYPE-1; i++) {
2350 free_val_t(&tp->value[i]);
2356 for(ip=interface_list; ip != NULL; ip = ipnext) {
2358 for(i=0; i<INTER_INTER-1; i++) {
2359 free_val_t(&ip->value[i]);
2365 if(server_options) {
2366 for(server_option = server_options; server_option->name != NULL;
2368 amfree(server_option->name);
2369 amfree(server_option->value);
2371 amfree(server_options);
2374 for(i=0; i<CNF_CNF-1; i++)
2375 free_val_t(&server_conf[i]);