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.2.9 2007/01/11 13:06:10 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_INT , read_int , CNF_ETIMEOUT , NULL },
297 { CONF_DTIMEOUT , CONFTYPE_INT , read_int , CNF_DTIMEOUT , validate_positive1 },
298 { CONF_CTIMEOUT , CONFTYPE_INT , read_int , 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 t_conf_var tapetype_var [] = {
318 { CONF_COMMENT , CONFTYPE_STRING, read_string, TAPETYPE_COMMENT , NULL },
319 { CONF_LBL_TEMPL, CONFTYPE_STRING, read_string, TAPETYPE_LBL_TEMPL, NULL },
320 { CONF_BLOCKSIZE, CONFTYPE_SIZE , read_size , TAPETYPE_BLOCKSIZE, validate_blocksize },
321 { CONF_LENGTH , CONFTYPE_AM64 , read_am64 , TAPETYPE_LENGTH , validate_positive0 },
322 { CONF_FILEMARK , CONFTYPE_AM64 , read_am64 , TAPETYPE_FILEMARK , NULL },
323 { CONF_SPEED , CONFTYPE_INT , read_int , TAPETYPE_SPEED , validate_positive0 },
324 { CONF_FILE_PAD , CONFTYPE_BOOL , read_bool , TAPETYPE_FILE_PAD , NULL },
325 { CONF_UNKNOWN , CONFTYPE_INT , NULL , TAPETYPE_TAPETYPE , NULL }
328 t_conf_var dumptype_var [] = {
329 { CONF_COMMENT , CONFTYPE_STRING , read_string , DUMPTYPE_COMMENT , NULL },
330 { CONF_AUTH , CONFTYPE_STRING , read_string , DUMPTYPE_SECURITY_DRIVER , NULL },
331 { CONF_BUMPDAYS , CONFTYPE_INT , read_int , DUMPTYPE_BUMPDAYS , NULL },
332 { CONF_BUMPMULT , CONFTYPE_REAL , read_real , DUMPTYPE_BUMPMULT , NULL },
333 { CONF_BUMPSIZE , CONFTYPE_AM64 , read_am64 , DUMPTYPE_BUMPSIZE , NULL },
334 { CONF_BUMPPERCENT , CONFTYPE_INT , read_int , DUMPTYPE_BUMPPERCENT , NULL },
335 { CONF_COMPRATE , CONFTYPE_REAL , get_comprate, DUMPTYPE_COMPRATE , NULL },
336 { CONF_COMPRESS , CONFTYPE_INT , get_compress, DUMPTYPE_COMPRESS , NULL },
337 { CONF_ENCRYPT , CONFTYPE_INT , get_encrypt , DUMPTYPE_ENCRYPT , NULL },
338 { CONF_DUMPCYCLE , CONFTYPE_INT , read_int , DUMPTYPE_DUMPCYCLE , validate_positive0 },
339 { CONF_EXCLUDE , CONFTYPE_EXINCLUDE, get_exclude , DUMPTYPE_EXCLUDE , NULL },
340 { CONF_INCLUDE , CONFTYPE_EXINCLUDE, get_exclude , DUMPTYPE_INCLUDE , NULL },
341 { CONF_IGNORE , CONFTYPE_BOOL , read_bool , DUMPTYPE_IGNORE , NULL },
342 { CONF_HOLDING , CONFTYPE_HOLDING , get_holding , DUMPTYPE_HOLDINGDISK , NULL },
343 { CONF_INDEX , CONFTYPE_BOOL , read_bool , DUMPTYPE_INDEX , NULL },
344 { CONF_KENCRYPT , CONFTYPE_BOOL , read_bool , DUMPTYPE_KENCRYPT , NULL },
345 { CONF_MAXDUMPS , CONFTYPE_INT , read_int , DUMPTYPE_MAXDUMPS , validate_positive1 },
346 { CONF_MAXPROMOTEDAY , CONFTYPE_INT , read_int , DUMPTYPE_MAXPROMOTEDAY , validate_positive0 },
347 { CONF_PRIORITY , CONFTYPE_PRIORITY , get_priority, DUMPTYPE_PRIORITY , NULL },
348 { CONF_PROGRAM , CONFTYPE_STRING , read_string , DUMPTYPE_PROGRAM , NULL },
349 { CONF_RECORD , CONFTYPE_BOOL , read_bool , DUMPTYPE_RECORD , NULL },
350 { CONF_SKIP_FULL , CONFTYPE_BOOL , read_bool , DUMPTYPE_SKIP_FULL , NULL },
351 { CONF_SKIP_INCR , CONFTYPE_BOOL , read_bool , DUMPTYPE_SKIP_INCR , NULL },
352 { CONF_STARTTIME , CONFTYPE_TIME , read_time , DUMPTYPE_STARTTIME , NULL },
353 { CONF_STRATEGY , CONFTYPE_INT , get_strategy, DUMPTYPE_STRATEGY , NULL },
354 { CONF_TAPE_SPLITSIZE , CONFTYPE_AM64 , read_am64 , DUMPTYPE_TAPE_SPLITSIZE , validate_positive0 },
355 { CONF_SPLIT_DISKBUFFER , CONFTYPE_STRING , read_string , DUMPTYPE_SPLIT_DISKBUFFER , NULL },
356 { CONF_ESTIMATE , CONFTYPE_INT , get_estimate, DUMPTYPE_ESTIMATE , NULL },
357 { CONF_SRV_ENCRYPT , CONFTYPE_STRING , read_string , DUMPTYPE_SRV_ENCRYPT , NULL },
358 { CONF_CLNT_ENCRYPT , CONFTYPE_STRING , read_string , DUMPTYPE_CLNT_ENCRYPT , NULL },
359 { CONF_AMANDAD_PATH , CONFTYPE_STRING , read_string , DUMPTYPE_AMANDAD_PATH , NULL },
360 { CONF_CLIENT_USERNAME , CONFTYPE_STRING , read_string , DUMPTYPE_CLIENT_USERNAME , NULL },
361 { CONF_SSH_KEYS , CONFTYPE_STRING , read_string , DUMPTYPE_SSH_KEYS , NULL },
362 { CONF_SRVCOMPPROG , CONFTYPE_STRING , read_string , DUMPTYPE_SRVCOMPPROG , NULL },
363 { CONF_CLNTCOMPPROG , CONFTYPE_STRING , read_string , DUMPTYPE_CLNTCOMPPROG , NULL },
364 { CONF_FALLBACK_SPLITSIZE, CONFTYPE_AM64 , read_am64 , DUMPTYPE_FALLBACK_SPLITSIZE, NULL },
365 { CONF_SRV_DECRYPT_OPT , CONFTYPE_STRING , read_string , DUMPTYPE_SRV_DECRYPT_OPT , NULL },
366 { CONF_CLNT_DECRYPT_OPT , CONFTYPE_STRING , read_string , DUMPTYPE_CLNT_DECRYPT_OPT , NULL },
367 { CONF_UNKNOWN , CONFTYPE_INT , NULL , DUMPTYPE_DUMPTYPE , NULL }
370 t_conf_var holding_var [] = {
371 { CONF_DIRECTORY, CONFTYPE_STRING, read_string, HOLDING_DISKDIR , NULL },
372 { CONF_COMMENT , CONFTYPE_STRING, read_string, HOLDING_COMMENT , NULL },
373 { CONF_USE , CONFTYPE_AM64 , read_am64 , HOLDING_DISKSIZE , validate_use },
374 { CONF_CHUNKSIZE, CONFTYPE_AM64 , read_am64 , HOLDING_CHUNKSIZE, validate_chunksize },
375 { CONF_UNKNOWN , CONFTYPE_INT , NULL , HOLDING_HOLDING , NULL }
379 ** ------------------------
380 ** External entry points
381 ** ------------------------
392 /* We assume that conf_confname & conf are initialized to NULL above */
393 read_conffile_recursively(filename);
395 /* overwrite with command line option */
396 command_overwrite(server_options, server_var, server_keytab, server_conf,
399 if(got_parserror != -1 ) {
400 if(lookup_tapetype(server_conf[CNF_TAPETYPE].v.s) == NULL) {
401 char *save_confname = conf_confname;
403 conf_confname = filename;
404 if(!server_conf[CNF_TAPETYPE].seen)
405 conf_parserror("default tapetype %s not defined", server_conf[CNF_TAPETYPE].v.s);
407 conf_line_num = server_conf[CNF_TAPETYPE].seen;
408 conf_parserror("tapetype %s not defined", server_conf[CNF_TAPETYPE].v.s);
410 conf_confname = save_confname;
414 ip = alloc(SIZEOF(interface_t));
415 ip->name = stralloc("default");
416 ip->seen = server_conf[CNF_NETUSAGE].seen;
417 conf_init_string(&ip->value[INTER_COMMENT], "implicit from NETUSAGE");
418 conf_init_int(&ip->value[INTER_MAXUSAGE], server_conf[CNF_NETUSAGE].v.i);
420 ip->next = interface_list;
423 return got_parserror;
428 struct s_conf_var *np,
434 conf_parserror("%s must be positive", get_token_name(np->token));
438 conf_parserror("%s must be positive", get_token_name(np->token));
442 conf_parserror("%s must be positive", get_token_name(np->token));
445 conf_parserror("validate_positive0 invalid type %d\n", val->type);
451 struct s_conf_var *np,
457 conf_parserror("%s must be positive", get_token_name(np->token));
461 conf_parserror("%s must be positive", get_token_name(np->token));
465 conf_parserror("%s must be positive", get_token_name(np->token));
469 conf_parserror("%s must be positive", get_token_name(np->token));
472 conf_parserror("validate_positive1 invalid type %d\n", val->type);
477 validate_runspercycle(
478 struct s_conf_var *np,
483 conf_parserror("runspercycle must be >= -1");
487 validate_bumppercent(
488 struct s_conf_var *np,
492 if(val->v.i < 0 || val->v.i > 100)
493 conf_parserror("bumppercent must be between 0 and 100");
498 struct s_conf_var *np,
502 if(val->v.i < 1 || val->v.i >MAX_DUMPERS)
503 conf_parserror("inparallel must be between 1 and MAX_DUMPERS (%d)",
509 struct s_conf_var *np,
513 if(val->v.r < 0.999) {
514 conf_parserror("bumpmult must be positive");
519 validate_displayunit(
520 struct s_conf_var *np,
524 if(strcmp(val->v.s, "k") == 0 ||
525 strcmp(val->v.s, "K") == 0) {
526 val->v.s[0] = (char)toupper(val->v.s[0]);
529 else if(strcmp(val->v.s, "m") == 0 ||
530 strcmp(val->v.s, "M") == 0) {
531 val->v.s[0] = (char)toupper(val->v.s[0]);
534 else if(strcmp(val->v.s, "g") == 0 ||
535 strcmp(val->v.s, "G") == 0) {
536 val->v.s[0] = (char)toupper(val->v.s[0]);
537 unit_divisor=1024*1024;
539 else if(strcmp(val->v.s, "t") == 0 ||
540 strcmp(val->v.s, "T") == 0) {
541 val->v.s[0] = (char)toupper(val->v.s[0]);
542 unit_divisor=1024*1024*1024;
545 conf_parserror("displayunit must be k,m,g or t.");
551 struct s_conf_var *np,
555 if(val->v.i < 0 || val->v.i > 100)
556 conf_parserror("reserve must be between 0 and 100");
561 struct s_conf_var *np,
565 val->v.am64 = am_floor(val->v.am64, DISK_BLOCK_KB);
570 struct s_conf_var *np,
574 if(val->v.am64 == 0) {
575 val->v.am64 = ((AM64_MAX / 1024) - (2 * DISK_BLOCK_KB));
577 else if(val->v.am64 < 0) {
578 conf_parserror("Negative chunksize ("OFF_T_FMT") is no longer supported",
581 val->v.am64 = am_floor(val->v.am64, (off_t)DISK_BLOCK_KB);
582 if (val->v.am64 < 2*DISK_BLOCK_KB) {
583 conf_parserror("chunksize must be at least %dkb", 2*DISK_BLOCK_KB);
589 struct s_conf_var *np,
593 if(val->v.l < DISK_BLOCK_KB) {
594 conf_parserror("Tape blocksize must be at least %d KBytes",
596 } else if(val->v.l > MAX_TAPE_BLOCK_KB) {
597 conf_parserror("Tape blocksize must not be larger than %d KBytes",
618 tmpstr = stralloc(str);
620 while((ch = *s++) != '\0') {
622 s[-1] = (char)toupper(ch);
625 first_delim = strchr(tmpstr, ':');
629 second_delim = strchr(first_delim,':');
634 *second_delim = '\0';
637 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++) {
638 if(kt->keyword && strcmp(kt->keyword, second_delim) == 0)
642 if(kt->token == CONF_UNKNOWN)
645 if (strcmp(tmpstr, "TAPETYPE") == 0) {
646 tp = lookup_tapetype(first_delim);
651 for(np = tapetype_var; np->token != CONF_UNKNOWN; np++) {
652 if(np->token == kt->token)
655 if (np->token == CONF_UNKNOWN) return NULL;
656 tmpstr = stralloc(conf_print(&tp->value[np->parm], 0));
657 } else if (strcmp(tmpstr, "DUMPTYPE") == 0) {
658 dp = lookup_dumptype(first_delim);
663 for(np = dumptype_var; np->token != CONF_UNKNOWN; np++) {
664 if(np->token == kt->token)
667 if (np->token == CONF_UNKNOWN) return NULL;
668 tmpstr = stralloc(conf_print(&dp->value[np->parm], 0));
669 } else if (strcmp(tmpstr, "HOLDINGDISK") == 0) {
670 hp = lookup_holdingdisk(first_delim);
675 for(np = holding_var; np->token != CONF_UNKNOWN; np++) {
676 if(np->token == kt->token)
679 if (np->token == CONF_UNKNOWN) return NULL;
680 tmpstr = stralloc(conf_print(&hp->value[np->parm], 0));
681 } else if (strcmp(tmpstr, "INTERFACE") == 0) {
682 ip = lookup_interface(first_delim);
687 for(np = holding_var; np->token != CONF_UNKNOWN; np++) {
688 if(np->token == kt->token)
691 if (np->token == CONF_UNKNOWN) return NULL;
692 tmpstr = stralloc(conf_print(&ip->value[np->parm], 0));
698 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++) {
699 if(kt->keyword && strcmp(kt->keyword, tmpstr) == 0)
703 if(kt->token == CONF_UNKNOWN)
706 for(np = server_var; np->token != CONF_UNKNOWN; np++) {
707 if(np->token == kt->token)
711 if(np->token == CONF_UNKNOWN) return NULL;
713 tmpstr = stralloc(conf_print(&server_conf[np->parm], 0));
730 if (strcasecmp(listname,"tapetype") == 0) {
731 result = stralloc("");
732 for(tp = tapelist; tp != NULL; tp=tp->next) {
733 result = vstrextend(&result, tp->name, "\n", NULL);
735 } else if (strcasecmp(listname,"dumptype") == 0) {
736 result = stralloc("");
737 for(dp = dumplist; dp != NULL; dp=dp->next) {
738 result = vstrextend(&result, dp->name, "\n", NULL);
740 } else if (strcasecmp(listname,"holdingdisk") == 0) {
741 result = stralloc("");
742 for(hp = holdingdisks; hp != NULL; hp=hp->next) {
743 result = vstrextend(&result, hp->name, "\n", NULL);
745 } else if (strcasecmp(listname,"interface") == 0) {
746 result = stralloc("");
747 for(ip = interface_list; ip != NULL; ip=ip->next) {
748 result = vstrextend(&result, ip->name, "\n", NULL);
760 np = get_np(server_var, parm);
761 return(server_conf[np->parm].seen);
769 np = get_np(server_var, parm);
770 if (np->type != CONFTYPE_BOOL) {
771 error("getconf_boolean: np is not a CONFTYPE_BOOL");
774 return(server_conf[np->parm].v.i != 0);
782 np = get_np(server_var, parm);
783 if (np->type != CONFTYPE_INT) {
784 error("getconf_int: np is not a CONFTYPE_INT");
787 return(server_conf[np->parm].v.i);
795 np = get_np(server_var, parm);
796 if (np->type != CONFTYPE_LONG) {
797 error("getconf_long: np is not a CONFTYPE_LONG");
800 return(server_conf[np->parm].v.l);
808 np = get_np(server_var, parm);
809 if (np->type != CONFTYPE_TIME) {
810 error("getconf_time: np is not a CONFTYPE_TIME");
813 return(server_conf[np->parm].v.t);
821 np = get_np(server_var, parm);
822 if (np->type != CONFTYPE_SIZE) {
823 error("getconf_size: np is not a CONFTYPE_SIZE");
826 return(server_conf[np->parm].v.size);
834 np = get_np(server_var, parm);
835 if (np->type != CONFTYPE_AM64) {
836 error("getconf_am64: np is not a CONFTYPE_AM64");
839 return(server_conf[np->parm].v.am64);
847 np = get_np(server_var, parm);
848 if (np->type != CONFTYPE_REAL) {
849 error("getconf_real: np is not a CONFTYPE_REAL");
852 return(server_conf[np->parm].v.r);
860 np = get_np(server_var, parm);
861 if (np->type != CONFTYPE_STRING && np->type != CONFTYPE_IDENT) {
862 error("getconf_str: np is not a CONFTYPE_STRING|CONFTYPE_IDENT: %d", parm);
865 return(server_conf[np->parm].v.s);
873 np = get_np(server_var, parm);
874 if (np->type != CONFTYPE_TAPERALGO) {
875 error("getconf_taperalgo: np is not a CONFTYPE_TAPERALGO");
878 return(server_conf[np->parm].v.i);
882 getconf_holdingdisks(
894 for(p = dumplist; p != NULL; p = p->next) {
895 if(strcasecmp(p->name, str) == 0) return p;
906 for(p = tapelist; p != NULL; p = p->next) {
907 if(strcasecmp(p->name, str) == 0) return p;
918 for(p = holdingdisks; p != NULL; p = p->next) {
919 if(strcasecmp(p->name, str) == 0) return p;
933 return interface_list;
936 for (p = interface_list; p != NULL; p = p->next) {
937 if (strcasecmp(p->name, str) == 0)
946 ** ------------------------
948 ** ------------------------
958 /* defaults for exported variables */
960 #ifdef DEFAULT_CONFIG
965 conf_init_string(&server_conf[CNF_ORG], s);
966 conf_init_string(&server_conf[CNF_MAILTO], "operators");
967 conf_init_string(&server_conf[CNF_DUMPUSER], CLIENT_LOGIN);
968 #ifdef DEFAULT_TAPE_DEVICE
969 s = DEFAULT_TAPE_DEVICE;
973 conf_init_string(&server_conf[CNF_TAPEDEV], s);
974 #ifdef DEFAULT_CHANGER_DEVICE
975 s = DEFAULT_CHANGER_DEVICE;
979 conf_init_string(&server_conf[CNF_CHNGRDEV], s);
980 conf_init_string(&server_conf[CNF_CHNGRFILE], "/usr/adm/amanda/changer-status");
981 #ifdef DEFAULT_RAW_TAPE_DEVICE
982 s = DEFAULT_RAW_TAPE_DEVICE;
986 conf_init_string (&server_conf[CNF_LABELSTR] , ".*");
987 conf_init_string (&server_conf[CNF_TAPELIST] , "tapelist");
988 conf_init_string (&server_conf[CNF_DISKFILE] , "disklist");
989 conf_init_string (&server_conf[CNF_INFOFILE] , "/usr/adm/amanda/curinfo");
990 conf_init_string (&server_conf[CNF_LOGDIR] , "/usr/adm/amanda");
991 conf_init_string (&server_conf[CNF_INDEXDIR] , "/usr/adm/amanda/index");
992 conf_init_ident (&server_conf[CNF_TAPETYPE] , "EXABYTE");
993 conf_init_int (&server_conf[CNF_DUMPCYCLE] , 10);
994 conf_init_int (&server_conf[CNF_RUNSPERCYCLE] , 0);
995 conf_init_int (&server_conf[CNF_TAPECYCLE] , 15);
996 conf_init_int (&server_conf[CNF_NETUSAGE] , 300);
997 conf_init_int (&server_conf[CNF_INPARALLEL] , 10);
998 conf_init_string (&server_conf[CNF_DUMPORDER] , "ttt");
999 conf_init_int (&server_conf[CNF_BUMPPERCENT] , 0);
1000 conf_init_am64 (&server_conf[CNF_BUMPSIZE] , (off_t)10*1024);
1001 conf_init_real (&server_conf[CNF_BUMPMULT] , 1.5);
1002 conf_init_int (&server_conf[CNF_BUMPDAYS] , 2);
1003 conf_init_string (&server_conf[CNF_TPCHANGER] , "");
1004 conf_init_int (&server_conf[CNF_RUNTAPES] , 1);
1005 conf_init_int (&server_conf[CNF_MAXDUMPS] , 1);
1006 conf_init_int (&server_conf[CNF_ETIMEOUT] , 300);
1007 conf_init_int (&server_conf[CNF_DTIMEOUT] , 1800);
1008 conf_init_int (&server_conf[CNF_CTIMEOUT] , 30);
1009 conf_init_int (&server_conf[CNF_TAPEBUFS] , 20);
1010 conf_init_string (&server_conf[CNF_RAWTAPEDEV] , s);
1011 conf_init_string (&server_conf[CNF_PRINTER] , "");
1012 conf_init_bool (&server_conf[CNF_AUTOFLUSH] , 0);
1013 conf_init_int (&server_conf[CNF_RESERVE] , 100);
1014 conf_init_am64 (&server_conf[CNF_MAXDUMPSIZE] , (off_t)-1);
1015 conf_init_string (&server_conf[CNF_COLUMNSPEC] , "");
1016 conf_init_bool (&server_conf[CNF_AMRECOVER_DO_FSF] , 1);
1017 conf_init_string (&server_conf[CNF_AMRECOVER_CHANGER] , "");
1018 conf_init_bool (&server_conf[CNF_AMRECOVER_CHECK_LABEL], 1);
1019 conf_init_taperalgo(&server_conf[CNF_TAPERALGO] , 0);
1020 conf_init_string (&server_conf[CNF_DISPLAYUNIT] , "k");
1021 conf_init_string (&server_conf[CNF_KRB5KEYTAB] , "/.amanda-v5-keytab");
1022 conf_init_string (&server_conf[CNF_KRB5PRINCIPAL] , "service/amanda");
1023 conf_init_string (&server_conf[CNF_LABEL_NEW_TAPES] , "");
1024 conf_init_bool (&server_conf[CNF_USETIMESTAMPS] , 0);
1026 /* defaults for internal variables */
1028 conf_line_num = got_parserror = 0;
1029 allow_overwrites = 0;
1032 while(holdingdisks != NULL) {
1036 holdingdisks = holdingdisks->next;
1039 num_holdingdisks = 0;
1041 /* free any previously declared dump, tape and interface types */
1043 while(dumplist != NULL) {
1047 dumplist = dumplist->next;
1050 while(tapelist != NULL) {
1054 tapelist = tapelist->next;
1057 while(interface_list != NULL) {
1060 ip = interface_list;
1061 interface_list = interface_list->next;
1065 /* create some predefined dumptypes for backwards compatability */
1066 init_dumptype_defaults();
1067 dpcur.name = stralloc("NO-COMPRESS");
1069 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_NONE);
1072 init_dumptype_defaults();
1073 dpcur.name = stralloc("COMPRESS-FAST");
1075 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_FAST);
1078 init_dumptype_defaults();
1079 dpcur.name = stralloc("COMPRESS-BEST");
1081 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_BEST);
1084 init_dumptype_defaults();
1085 dpcur.name = stralloc("COMPRESS-CUST");
1087 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_CUST);
1090 init_dumptype_defaults();
1091 dpcur.name = stralloc("SRVCOMPRESS");
1093 conf_set_compress(&dpcur.value[DUMPTYPE_COMPRESS], COMP_SERV_FAST);
1096 init_dumptype_defaults();
1097 dpcur.name = stralloc("BSD-AUTH");
1099 conf_set_string(&dpcur.value[DUMPTYPE_SECURITY_DRIVER], "BSD");
1102 init_dumptype_defaults();
1103 dpcur.name = stralloc("KRB4-AUTH");
1105 conf_set_string(&dpcur.value[DUMPTYPE_SECURITY_DRIVER], "KRB4");
1108 init_dumptype_defaults();
1109 dpcur.name = stralloc("NO-RECORD");
1111 conf_set_bool(&dpcur.value[DUMPTYPE_RECORD], 0);
1114 init_dumptype_defaults();
1115 dpcur.name = stralloc("NO-HOLD");
1117 conf_set_holding(&dpcur.value[DUMPTYPE_HOLDINGDISK], HOLD_NEVER);
1120 init_dumptype_defaults();
1121 dpcur.name = stralloc("NO-FULL");
1123 conf_set_strategy(&dpcur.value[DUMPTYPE_STRATEGY], DS_NOFULL);
1128 read_conffile_recursively(
1131 /* Save globals used in read_confline(), elsewhere. */
1132 int save_line_num = conf_line_num;
1133 FILE *save_conf = conf_conf;
1134 char *save_confname = conf_confname;
1137 if (*filename == '/' || config_dir == NULL) {
1138 conf_confname = stralloc(filename);
1140 conf_confname = stralloc2(config_dir, filename);
1143 if((conf_conf = fopen(conf_confname, "r")) == NULL) {
1144 fprintf(stderr, "could not open conf file \"%s\": %s\n", conf_confname,
1146 amfree(conf_confname);
1153 /* read_confline() can invoke us recursively via "includefile" */
1155 rc = read_confline();
1159 amfree(conf_confname);
1161 /* Restore servers */
1162 conf_line_num = save_line_num;
1163 conf_conf = save_conf;
1164 conf_confname = save_confname;
1168 /* ------------------------ */
1177 keytable = server_keytab;
1180 get_conftoken(CONF_ANY);
1182 case CONF_INCLUDEFILE:
1187 get_conftoken(CONF_STRING);
1189 if (*fn == '/' || config_dir == NULL) {
1190 cname = stralloc(fn);
1192 cname = stralloc2(config_dir, fn);
1194 if ( cname != NULL && (access(cname, R_OK) == 0)) {
1195 read_conffile_recursively(cname);
1198 conf_parserror("cannot open %s: %s\n", fn, strerror(errno));
1210 get_conftoken(CONF_ANY);
1211 if(tok == CONF_DUMPTYPE) get_dumptype();
1212 else if(tok == CONF_TAPETYPE) get_tapetype();
1213 else if(tok == CONF_INTERFACE) get_interface();
1214 else conf_parserror("DUMPTYPE, INTERFACE or TAPETYPE expected");
1217 case CONF_NL: /* empty line */
1220 case CONF_END: /* end of file */
1225 for(np = server_var; np->token != CONF_UNKNOWN; np++)
1226 if(np->token == tok) break;
1228 if(np->token == CONF_UNKNOWN) {
1229 conf_parserror("configuration keyword expected");
1231 np->read_function(np, &server_conf[np->parm]);
1233 np->validate(np, &server_conf[np->parm]);
1238 get_conftoken(CONF_NL);
1247 int save_overwrites;
1249 save_overwrites = allow_overwrites;
1250 allow_overwrites = 1;
1252 init_holdingdisk_defaults();
1254 get_conftoken(CONF_IDENT);
1255 hdcur.name = stralloc(tokenval.v.s);
1256 hdcur.seen = conf_line_num;
1258 prefix = vstralloc( "HOLDINGDISK:", hdcur.name, ":", NULL);
1259 read_block(server_options, holding_var, server_keytab, hdcur.value, prefix,
1260 "holding disk parameter expected", 1, NULL);
1262 get_conftoken(CONF_NL);
1264 hdcur.disksize = holdingdisk_get_disksize(&hdcur);
1267 allow_overwrites = save_overwrites;
1271 init_holdingdisk_defaults(
1274 conf_init_string(&hdcur.value[HOLDING_COMMENT] , "");
1275 conf_init_string(&hdcur.value[HOLDING_DISKDIR] , "");
1276 conf_init_am64(&hdcur.value[HOLDING_DISKSIZE] , (off_t)0);
1277 /* 1 Gb = 1M counted in 1Kb blocks */
1278 conf_init_am64(&hdcur.value[HOLDING_CHUNKSIZE], (off_t)1024*1024);
1280 hdcur.up = (void *)0;
1281 hdcur.disksize = 0LL;
1290 hp = alloc(sizeof(holdingdisk_t));
1292 hp->next = holdingdisks;
1306 int save_overwrites;
1307 FILE *saved_conf = NULL;
1308 char *saved_fname = NULL;
1312 saved_conf = conf_conf;
1317 saved_fname = conf_confname;
1318 conf_confname = fname;
1322 conf_line_num = *linenum;
1324 save_overwrites = allow_overwrites;
1325 allow_overwrites = 1;
1327 init_dumptype_defaults();
1331 get_conftoken(CONF_IDENT);
1332 dpcur.name = stralloc(tokenval.v.s);
1334 dpcur.seen = conf_line_num;
1336 prefix = vstralloc( "DUMPTYPE:", dpcur.name, ":", NULL);
1337 read_block(server_options, dumptype_var, server_keytab, dpcur.value,
1338 prefix, "dumptype parameter expected",
1339 (name == NULL), *copy_dumptype);
1342 get_conftoken(CONF_NL);
1344 /* XXX - there was a stupidity check in here for skip-incr and
1345 ** skip-full. This check should probably be somewhere else. */
1349 allow_overwrites = save_overwrites;
1352 *linenum = conf_line_num;
1355 conf_confname = saved_fname;
1358 conf_conf = saved_conf;
1360 return lookup_dumptype(dpcur.name);
1366 read_dumptype(NULL, NULL, NULL, NULL);
1370 init_dumptype_defaults(void)
1373 conf_init_string (&dpcur.value[DUMPTYPE_COMMENT] , "");
1374 conf_init_string (&dpcur.value[DUMPTYPE_PROGRAM] , "DUMP");
1375 conf_init_string (&dpcur.value[DUMPTYPE_SRVCOMPPROG] , "");
1376 conf_init_string (&dpcur.value[DUMPTYPE_CLNTCOMPPROG] , "");
1377 conf_init_string (&dpcur.value[DUMPTYPE_SRV_ENCRYPT] , "");
1378 conf_init_string (&dpcur.value[DUMPTYPE_CLNT_ENCRYPT] , "");
1379 conf_init_string (&dpcur.value[DUMPTYPE_AMANDAD_PATH] , "X");
1380 conf_init_string (&dpcur.value[DUMPTYPE_CLIENT_USERNAME] , "X");
1381 conf_init_string (&dpcur.value[DUMPTYPE_SSH_KEYS] , "X");
1382 conf_init_string (&dpcur.value[DUMPTYPE_SECURITY_DRIVER] , "BSD");
1383 conf_init_exinclude(&dpcur.value[DUMPTYPE_EXCLUDE]);
1384 conf_init_exinclude(&dpcur.value[DUMPTYPE_INCLUDE]);
1385 conf_init_priority (&dpcur.value[DUMPTYPE_PRIORITY] , 1);
1386 conf_init_int (&dpcur.value[DUMPTYPE_DUMPCYCLE] , server_conf[CNF_DUMPCYCLE].v.i);
1387 conf_init_int (&dpcur.value[DUMPTYPE_MAXDUMPS] , server_conf[CNF_MAXDUMPS].v.i);
1388 conf_init_int (&dpcur.value[DUMPTYPE_MAXPROMOTEDAY] , 10000);
1389 conf_init_int (&dpcur.value[DUMPTYPE_BUMPPERCENT] , server_conf[CNF_BUMPPERCENT].v.i);
1390 conf_init_am64 (&dpcur.value[DUMPTYPE_BUMPSIZE] , server_conf[CNF_BUMPSIZE].v.am64);
1391 conf_init_int (&dpcur.value[DUMPTYPE_BUMPDAYS] , server_conf[CNF_BUMPDAYS].v.i);
1392 conf_init_real (&dpcur.value[DUMPTYPE_BUMPMULT] , server_conf[CNF_BUMPMULT].v.r);
1393 conf_init_time (&dpcur.value[DUMPTYPE_STARTTIME] , (time_t)0);
1394 conf_init_strategy (&dpcur.value[DUMPTYPE_STRATEGY] , DS_STANDARD);
1395 conf_init_estimate (&dpcur.value[DUMPTYPE_ESTIMATE] , ES_CLIENT);
1396 conf_init_compress (&dpcur.value[DUMPTYPE_COMPRESS] , COMP_FAST);
1397 conf_init_encrypt (&dpcur.value[DUMPTYPE_ENCRYPT] , ENCRYPT_NONE);
1398 conf_init_string (&dpcur.value[DUMPTYPE_SRV_DECRYPT_OPT] , "-d");
1399 conf_init_string (&dpcur.value[DUMPTYPE_CLNT_DECRYPT_OPT] , "-d");
1400 conf_init_rate (&dpcur.value[DUMPTYPE_COMPRATE] , 0.50, 0.50);
1401 conf_init_am64 (&dpcur.value[DUMPTYPE_TAPE_SPLITSIZE] , (off_t)0);
1402 conf_init_am64 (&dpcur.value[DUMPTYPE_FALLBACK_SPLITSIZE], (off_t)10 * 1024);
1403 conf_init_string (&dpcur.value[DUMPTYPE_SPLIT_DISKBUFFER] , NULL);
1404 conf_init_bool (&dpcur.value[DUMPTYPE_RECORD] , 1);
1405 conf_init_bool (&dpcur.value[DUMPTYPE_SKIP_INCR] , 0);
1406 conf_init_bool (&dpcur.value[DUMPTYPE_SKIP_FULL] , 0);
1407 conf_init_holding (&dpcur.value[DUMPTYPE_HOLDINGDISK] , HOLD_AUTO);
1408 conf_init_bool (&dpcur.value[DUMPTYPE_KENCRYPT] , 0);
1409 conf_init_bool (&dpcur.value[DUMPTYPE_IGNORE] , 0);
1410 conf_init_bool (&dpcur.value[DUMPTYPE_INDEX] , 1);
1416 dumptype_t *dp, *dp1;;
1418 dp = lookup_dumptype(dpcur.name);
1420 if(dp != (dumptype_t *)0) {
1421 conf_parserror("dumptype %s already defined on line %d", dp->name, dp->seen);
1425 dp = alloc(sizeof(dumptype_t));
1428 /* add at end of list */
1433 while (dp1->next != NULL) {
1446 dt = lookup_dumptype(tokenval.v.s);
1449 conf_parserror("dumptype parameter expected");
1453 for(i=0; i < DUMPTYPE_DUMPTYPE; i++) {
1454 if(dt->value[i].seen) {
1455 free_val_t(&dpcur.value[i]);
1456 copy_val_t(&dpcur.value[i], &dt->value[i]);
1464 int save_overwrites;
1467 save_overwrites = allow_overwrites;
1468 allow_overwrites = 1;
1470 init_tapetype_defaults();
1472 get_conftoken(CONF_IDENT);
1473 tpcur.name = stralloc(tokenval.v.s);
1474 tpcur.seen = conf_line_num;
1476 prefix = vstralloc( "TAPETYPE:", tpcur.name, ":", NULL);
1477 read_block(server_options, tapetype_var, server_keytab, tpcur.value,
1478 prefix, "tapetype parameter expected", 1, ©_tapetype);
1480 get_conftoken(CONF_NL);
1484 allow_overwrites = save_overwrites;
1488 init_tapetype_defaults(void)
1490 conf_init_string(&tpcur.value[TAPETYPE_COMMENT] , "");
1491 conf_init_string(&tpcur.value[TAPETYPE_LBL_TEMPL], "");
1492 conf_init_size (&tpcur.value[TAPETYPE_BLOCKSIZE], DISK_BLOCK_KB);
1493 conf_init_am64 (&tpcur.value[TAPETYPE_LENGTH] , (off_t)2000);
1494 conf_init_am64 (&tpcur.value[TAPETYPE_FILEMARK] , (off_t)1);
1495 conf_init_int (&tpcur.value[TAPETYPE_SPEED] , 200);
1496 conf_init_bool (&tpcur.value[TAPETYPE_FILE_PAD] , 1);
1502 tapetype_t *tp, *tp1;
1504 tp = lookup_tapetype(tpcur.name);
1506 if(tp != (tapetype_t *)0) {
1508 conf_parserror("tapetype %s already defined on line %d", tp->name, tp->seen);
1512 tp = alloc(sizeof(tapetype_t));
1514 /* add at end of list */
1519 while (tp1->next != NULL) {
1532 tp = lookup_tapetype(tokenval.v.s);
1535 conf_parserror("tape type parameter expected");
1539 for(i=0; i < TAPETYPE_TAPETYPE; i++) {
1540 if(tp->value[i].seen) {
1541 free_val_t(&tpcur.value[i]);
1542 copy_val_t(&tpcur.value[i], &tp->value[i]);
1547 t_conf_var interface_var [] = {
1548 { CONF_COMMENT, CONFTYPE_STRING, read_string, INTER_COMMENT , NULL },
1549 { CONF_USE , CONFTYPE_INT , read_int , INTER_MAXUSAGE, validate_positive1 },
1550 { CONF_UNKNOWN, CONFTYPE_INT , NULL , INTER_INTER , NULL }
1556 int save_overwrites;
1559 save_overwrites = allow_overwrites;
1560 allow_overwrites = 1;
1562 init_interface_defaults();
1564 get_conftoken(CONF_IDENT);
1565 ifcur.name = stralloc(tokenval.v.s);
1566 ifcur.seen = conf_line_num;
1568 prefix = vstralloc( "INTERFACE:", ifcur.name, ":", NULL);
1569 read_block(server_options, interface_var, server_keytab, ifcur.value,
1570 prefix, "interface parameter expected", 1, ©_interface);
1572 get_conftoken(CONF_NL);
1576 allow_overwrites = save_overwrites;
1582 init_interface_defaults(void)
1584 conf_init_string(&ifcur.value[INTER_COMMENT] , "");
1585 conf_init_int (&ifcur.value[INTER_MAXUSAGE], 300);
1591 save_interface(void)
1593 interface_t *ip, *ip1;
1595 ip = lookup_interface(ifcur.name);
1597 if(ip != (interface_t *)0) {
1598 conf_parserror("interface %s already defined on line %d", ip->name,
1603 ip = alloc(sizeof(interface_t));
1605 /* add at end of list */
1606 if(!interface_list) {
1607 interface_list = ip;
1609 ip1 = interface_list;
1610 while (ip1->next != NULL) {
1618 copy_interface(void)
1630 ip = lookup_interface(tokenval.v.s);
1633 conf_parserror("interface parameter expected");
1637 for(i=0; i < INTER_INTER; i++) {
1638 if(ip->value[i].seen) {
1639 free_val_t(&ifcur.value[i]);
1640 copy_val_t(&ifcur.value[i], &ip->value[i]);
1651 get_conftoken(CONF_REAL);
1652 val->v.rate[0] = tokenval.v.r;
1653 val->v.rate[1] = tokenval.v.r;
1654 val->seen = tokenval.seen;
1655 if(tokenval.v.r < 0) {
1656 conf_parserror("full compression rate must be >= 0");
1659 get_conftoken(CONF_ANY);
1674 get_conftoken(CONF_REAL);
1675 val->v.rate[1] = tokenval.v.r;
1676 if(tokenval.v.r < 0) {
1677 conf_parserror("incremental compression rate must be >= 0");
1686 int serv, clie, none, fast, best, custom;
1693 serv = clie = none = fast = best = custom = 0;
1697 get_conftoken(CONF_ANY);
1699 case CONF_NONE: none = 1; break;
1700 case CONF_FAST: fast = 1; break;
1701 case CONF_BEST: best = 1; break;
1702 case CONF_CLIENT: clie = 1; break;
1703 case CONF_SERVER: serv = 1; break;
1704 case CONF_CUSTOM: custom=1; break;
1705 case CONF_NL: done = 1; break;
1706 case CONF_END: done = 1; break;
1709 serv = clie = 1; /* force an error */
1713 if(serv + clie == 0) clie = 1; /* default to client */
1714 if(none + fast + best + custom == 0) fast = 1; /* default to fast */
1719 if(none && !fast && !best && !custom) comp = COMP_NONE;
1720 if(!none && fast && !best && !custom) comp = COMP_FAST;
1721 if(!none && !fast && best && !custom) comp = COMP_BEST;
1722 if(!none && !fast && !best && custom) comp = COMP_CUST;
1726 if(none && !fast && !best && !custom) comp = COMP_NONE;
1727 if(!none && fast && !best && !custom) comp = COMP_SERV_FAST;
1728 if(!none && !fast && best && !custom) comp = COMP_SERV_BEST;
1729 if(!none && !fast && !best && custom) comp = COMP_SERV_CUST;
1732 if((int)comp == -1) {
1733 conf_parserror("NONE, CLIENT FAST, CLIENT BEST, CLIENT CUSTOM, SERVER FAST, SERVER BEST or SERVER CUSTOM expected");
1737 val->v.i = (int)comp;
1750 get_conftoken(CONF_ANY);
1753 encrypt = ENCRYPT_NONE;
1757 encrypt = ENCRYPT_CUST;
1761 encrypt = ENCRYPT_SERV_CUST;
1765 conf_parserror("NONE, CLIENT or SERVER expected");
1766 encrypt = ENCRYPT_NONE;
1770 val->v.i = (int)encrypt;
1778 dump_holdingdisk_t holding;
1783 get_conftoken(CONF_ANY);
1786 holding = HOLD_NEVER;
1790 holding = HOLD_AUTO;
1794 holding = HOLD_REQUIRED;
1797 default: /* can be a BOOLEAN */
1799 holding = (dump_holdingdisk_t)get_bool();
1801 holding = HOLD_NEVER;
1802 else if (holding == 1 || holding == 2)
1803 holding = HOLD_AUTO;
1805 conf_parserror("NEVER, AUTO or REQUIRED expected");
1809 val->v.i = (int)holding;
1820 get_conftoken(CONF_ANY);
1822 case CONF_FIRST: val->v.i = ALGO_FIRST; break;
1823 case CONF_FIRSTFIT: val->v.i = ALGO_FIRSTFIT; break;
1824 case CONF_LARGEST: val->v.i = ALGO_LARGEST; break;
1825 case CONF_LARGESTFIT: val->v.i = ALGO_LARGESTFIT; break;
1826 case CONF_SMALLEST: val->v.i = ALGO_SMALLEST; break;
1827 case CONF_LAST: val->v.i = ALGO_LAST; break;
1829 conf_parserror("FIRST, FIRSTFIT, LARGEST, LARGESTFIT, SMALLEST or LAST expected");
1843 get_conftoken(CONF_ANY);
1845 case CONF_LOW: pri = 0; break;
1846 case CONF_MEDIUM: pri = 1; break;
1847 case CONF_HIGH: pri = 2; break;
1848 case CONF_INT: pri = tokenval.v.i; break;
1850 conf_parserror("LOW, MEDIUM, HIGH or integer expected");
1866 get_conftoken(CONF_ANY);
1872 strat = DS_STANDARD;
1884 strat = DS_INCRONLY;
1887 conf_parserror("STANDARD or NOFULL expected");
1888 strat = DS_STANDARD;
1903 get_conftoken(CONF_ANY);
1912 estime = ES_CALCSIZE;
1915 conf_parserror("CLIENT, SERVER or CALCSIZE expected");
1926 int file, got_one = 0;
1931 get_conftoken(CONF_ANY);
1932 if(tok == CONF_LIST) {
1934 get_conftoken(CONF_ANY);
1935 exclude = val->v.exinclude.sl_list;
1939 if(tok == CONF_EFILE) get_conftoken(CONF_ANY);
1940 exclude = val->v.exinclude.sl_file;
1944 if(tok == CONF_OPTIONAL) {
1945 get_conftoken(CONF_ANY);
1949 if(tok == CONF_APPEND) {
1950 get_conftoken(CONF_ANY);
1957 while(tok == CONF_STRING) {
1958 exclude = append_sl(exclude, tokenval.v.s);
1960 get_conftoken(CONF_ANY);
1964 if(got_one == 0) { free_sl(exclude); exclude = NULL; }
1967 val->v.exinclude.sl_list = exclude;
1969 val->v.exinclude.sl_file = exclude;
1970 val->v.exinclude.optional = optional;
1974 static void get_include(np, val)
1978 int list, got_one = 0;
1983 get_conftoken(CONF_ANY);
1984 if(tok == CONF_LIST) {
1986 include = dpcur.value[DUMPTYPE_INCLUDE_LIST].v.sl;
1987 ckseen(&dpcur.value[DUMPTYPE_INCLUDE_LIST].seen);
1988 get_conftoken(CONF_ANY);
1992 include = dpcur.value[DUMPTYPE_INCLUDE_FILE].v.sl;
1993 ckseen(&dpcur.value[DUMPTYPE_INCLUDE_FILE].seen);
1994 if(tok == CONF_EFILE) get_conftoken(CONF_ANY);
1997 if(tok == CONF_OPTIONAL) {
1998 get_conftoken(CONF_ANY);
2002 if(tok == CONF_APPEND) {
2003 get_conftoken(CONF_ANY);
2012 while(tok == CONF_STRING) {
2013 include = append_sl(include, tokenval.v.s);
2015 get_conftoken(CONF_ANY);
2019 if(got_one == 0) { free_sl(include); include = NULL; }
2022 dpcur.value[DUMPTYPE_INCLUDE_FILE].v.sl = include;
2024 dpcur.value[DUMPTYPE_INCLUDE_LIST].v.sl = include;
2025 if(!append || optional)
2026 dpcur.value[DUMPTYPE_INCLUDE_OPTIONAL].v.i = optional;
2031 /* ------------------------ */
2034 ColumnDataCount(void )
2036 return (int)(SIZEOF(ColumnData) / SIZEOF(ColumnData[0]));
2039 /* conversion from string to table index
2047 for (cn=0; ColumnData[cn].Name != NULL; cn++) {
2048 if (strcasecmp(s, ColumnData[cn].Name) == 0) {
2059 return s[strlen(s)-1];
2063 SetColumDataFromString(
2069 char *myname= "SetColumDataFromString";
2073 /* Convert from a Columspec string to our internal format
2074 * of columspec. The purpose is to provide this string
2075 * as configuration paramter in the amanda.conf file or
2076 * (maybe) as environment variable.
2078 * This text should go as comment into the sample amanda.conf
2080 * The format for such a ColumnSpec string s is a ',' seperated
2081 * list of triples. Each triple consists of
2082 * -the name of the column (as in ColumnData.Name)
2083 * -prefix before the column
2084 * -the width of the column
2085 * if set to -1 it will be recalculated
2086 * to the maximum length of a line to print.
2088 * "Disk=1:17,HostName=1:10,OutKB=1:7"
2090 * "Disk=1:-1,HostName=1:10,OutKB=1:7"
2092 * You need only specify those colums that should be changed from
2093 * the default. If nothing is specified in the configfile, the
2094 * above compiled in values will be in effect, resulting in an
2095 * output as it was all the time.
2102 char *eon= strchr(s, '=');
2105 *errstr = stralloc2("invalid columnspec: ", s);
2107 fprintf(stderr, "%s: %s\n", myname, *errstr);
2112 cn=StringToColumn(s);
2113 if (ColumnData[cn].Name == NULL) {
2114 *errstr = stralloc2("invalid column name: ", s);
2116 fprintf(stderr, "%s: %s\n", myname, *errstr);
2120 if (sscanf(eon+1, "%d:%d", &Space, &Width) != 2) {
2121 *errstr = stralloc2("invalid format: ", eon + 1);
2123 fprintf(stderr, "%s: %s\n", myname, *errstr);
2127 ColumnData[cn].Width= Width;
2128 ColumnData[cn].PrefixSpace = Space;
2129 if (LastChar(ColumnData[cn].Format) == 's') {
2131 ColumnData[cn].MaxWidth= 1;
2133 if (Width > ColumnData[cn].Precision)
2134 ColumnData[cn].Precision= Width;
2136 else if (Width < ColumnData[cn].Precision)
2137 ColumnData[cn].Precision = Width;
2138 s= strchr(eon+1, ',');
2147 getconf_unit_divisor(void)
2149 return unit_divisor;
2152 /* ------------------------ */
2168 printf("AMANDA CONFIGURATION FROM FILE \"%s\":\n\n", filename);
2170 for(i=0; i < CNF_CNF; i++) {
2171 for(np=server_var; np->token != CONF_UNKNOWN; np++) {
2175 if(np->token == CONF_UNKNOWN)
2176 error("server bad value");
2178 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2179 if(kt->token == np->token) break;
2180 if(kt->token == CONF_UNKNOWN)
2181 error("server bad token");
2183 printf("%-21s %s\n", kt->keyword, conf_print(&server_conf[i], 1));
2186 for(hp = holdingdisks; hp != NULL; hp = hp->next) {
2187 printf("\nHOLDINGDISK %s {\n", hp->name);
2188 for(i=0; i < HOLDING_HOLDING; i++) {
2189 for(np=holding_var; np->token != CONF_UNKNOWN; np++) {
2193 if(np->token == CONF_UNKNOWN)
2194 error("holding bad value");
2196 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++) {
2197 if(kt->token == np->token)
2200 if(kt->token == CONF_UNKNOWN)
2201 error("holding bad token");
2203 printf(" %-9s %s\n", kt->keyword, conf_print(&hp->value[i], 1));
2208 for(tp = tapelist; tp != NULL; tp = tp->next) {
2209 printf("\nDEFINE TAPETYPE %s {\n", tp->name);
2210 for(i=0; i < TAPETYPE_TAPETYPE; i++) {
2211 for(np=tapetype_var; np->token != CONF_UNKNOWN; np++)
2212 if(np->parm == i) break;
2213 if(np->token == CONF_UNKNOWN)
2214 error("tapetype bad value");
2216 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2217 if(kt->token == np->token) break;
2218 if(kt->token == CONF_UNKNOWN)
2219 error("tapetype bad token");
2221 printf(" %-9s %s\n", kt->keyword, conf_print(&tp->value[i], 1));
2226 for(dp = dumplist; dp != NULL; dp = dp->next) {
2227 if (strncmp(dp->name, "custom(", 7) != 0) {
2232 printf("\n%sDEFINE DUMPTYPE %s {\n", prefix, dp->name);
2233 for(i=0; i < DUMPTYPE_DUMPTYPE; i++) {
2234 for(np=dumptype_var; np->token != CONF_UNKNOWN; np++)
2235 if(np->parm == i) break;
2236 if(np->token == CONF_UNKNOWN)
2237 error("dumptype bad value");
2239 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2240 if(kt->token == np->token) break;
2241 if(kt->token == CONF_UNKNOWN)
2242 error("dumptype bad token");
2244 if (dp->value[i].type == CONFTYPE_EXINCLUDE) {
2245 printf("%s %-19s %s\n", prefix, kt->keyword,
2246 conf_print_exinclude(&dp->value[i], 1, 0));
2247 printf("%s %-19s %s\n", prefix, kt->keyword,
2248 conf_print_exinclude(&dp->value[i], 1, 1));
2250 printf("%s %-19s %s\n", prefix, kt->keyword,
2251 conf_print(&dp->value[i], 1));
2254 printf("%s}\n", prefix);
2258 for(ip = interface_list; ip != NULL; ip = ip->next) {
2259 if(strcmp(ip->name,"default") == 0)
2263 printf("\n%sDEFINE INTERFACE %s {\n", prefix, ip->name);
2264 for(i=0; i < INTER_INTER; i++) {
2265 for(np=interface_var; np->token != CONF_UNKNOWN; np++)
2266 if(np->parm == i) break;
2267 if(np->token == CONF_UNKNOWN)
2268 error("interface bad value");
2270 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2271 if(kt->token == np->token) break;
2272 if(kt->token == CONF_UNKNOWN)
2273 error("interface bad token");
2275 printf("%s %-9s %s\n", prefix, kt->keyword, conf_print(&ip->value[i], 1));
2277 printf("%s}\n",prefix);
2293 unsigned long malloc_hist_1, malloc_size_1;
2294 unsigned long malloc_hist_2, malloc_size_2;
2298 set_pname("conffile");
2300 /* Don't die when child closes pipe */
2301 signal(SIGPIPE, SIG_IGN);
2303 malloc_size_1 = malloc_inuse(&malloc_hist_1);
2308 if (argv[1][0] == '/') {
2309 config_dir = stralloc(argv[1]);
2310 config_name = strrchr(config_dir, '/') + 1;
2311 config_name[-1] = '\0';
2312 config_dir = newstralloc2(config_dir, config_dir, "/");
2314 config_name = stralloc(argv[1]);
2315 config_dir = vstralloc(CONFIG_DIR, "/", config_name, "/", NULL);
2318 char my_cwd[STR_SIZE];
2320 if (getcwd(my_cwd, sizeof(my_cwd)) == NULL) {
2321 error("cannot determine current working directory");
2323 config_dir = stralloc2(my_cwd, "/");
2324 if ((config_name = strrchr(my_cwd, '/')) != NULL) {
2325 config_name = stralloc(config_name + 1);
2329 conffile = stralloc2(config_dir, CONFFILE_NAME);
2330 result = read_conffile(conffile);
2332 diskfile = getconf_str(CNF_DISKFILE);
2333 if (diskfile != NULL && access(diskfile, R_OK) == 0) {
2334 result = read_diskfile(diskfile, &lst);
2337 dump_configuration(CONFFILE_NAME);
2340 malloc_size_2 = malloc_inuse(&malloc_hist_2);
2342 if(malloc_size_1 != malloc_size_2) {
2343 malloc_list(fileno(stderr), malloc_hist_1, malloc_hist_2);
2352 generic_get_security_conf(
2357 if(!string || !*string)
2360 if(strcmp(string, "krb5principal")==0) {
2361 return(getconf_str(CNF_KRB5PRINCIPAL));
2362 } else if(strcmp(string, "krb5keytab")==0) {
2363 return(getconf_str(CNF_KRB5KEYTAB));
2374 for(kt = server_keytab; kt->token != CONF_UNKNOWN; kt++)
2375 if(kt->token == token) break;
2377 if(kt->token == CONF_UNKNOWN)
2379 return(kt->keyword);
2391 char *myarg, *value;
2392 command_option_t *server_option;
2394 server_options = alloc((size_t)(parse_argc+1) * SIZEOF(*server_options));
2395 server_option = server_options;
2396 server_option->name = NULL;
2398 my_argv = alloc((size_t)parse_argc * SIZEOF(char *));
2399 *new_argv = my_argv;
2402 while(i<parse_argc) {
2403 if(strncmp(parse_argv[i],"-o",2) == 0) {
2404 if(strlen(parse_argv[i]) > 2)
2405 myarg = &parse_argv[i][2];
2409 error("expect something after -o");
2410 myarg = parse_argv[i];
2412 value = index(myarg,'=');
2413 if (value == NULL) {
2414 conf_parserror("Must specify a value for %s.\n", myarg);
2418 server_option->used = 0;
2419 server_option->name = stralloc(myarg);
2420 server_option->value = stralloc(value);
2422 server_option->name = NULL;
2426 my_argv[*new_argc] = stralloc(parse_argv[i]);
2437 char **config_options;
2438 char **config_option;
2439 command_option_t *command_options;
2440 int nb_server_options = 0;
2442 for(command_options = server_options; command_options->name != NULL;
2443 command_options++) {
2444 nb_server_options++;
2446 config_options = alloc((first+nb_server_options+1)*SIZEOF(char *));
2447 for(command_options = server_options,
2448 config_option = config_options + first;
2449 command_options->name != NULL; command_options++) {
2450 *config_option = vstralloc("-o", command_options->name, "=",
2451 command_options->value, NULL);
2454 *config_option = NULL;
2455 return(config_options);
2459 report_bad_conf_arg(void)
2461 command_option_t *command_option;
2463 for(command_option = server_options; command_option->name != NULL;
2465 if(command_option->used == 0) {
2466 fprintf(stderr,"argument -o%s=%s not used\n",
2467 command_option->name, command_option->value);
2473 free_server_config(void)
2475 holdingdisk_t *hp, *hpnext;
2476 dumptype_t *dp, *dpnext;
2477 tapetype_t *tp, *tpnext;
2478 interface_t *ip, *ipnext;
2479 command_option_t *server_option;
2482 for(hp=holdingdisks; hp != NULL; hp = hpnext) {
2484 for(i=0; i<HOLDING_HOLDING-1; i++) {
2485 free_val_t(&hp->value[i]);
2491 for(dp=dumplist; dp != NULL; dp = dpnext) {
2493 for(i=0; i<DUMPTYPE_DUMPTYPE-1; i++) {
2494 free_val_t(&dp->value[i]);
2500 for(tp=tapelist; tp != NULL; tp = tpnext) {
2502 for(i=0; i<TAPETYPE_TAPETYPE-1; i++) {
2503 free_val_t(&tp->value[i]);
2509 for(ip=interface_list; ip != NULL; ip = ipnext) {
2511 for(i=0; i<INTER_INTER-1; i++) {
2512 free_val_t(&ip->value[i]);
2518 if(server_options) {
2519 for(server_option = server_options; server_option->name != NULL;
2521 amfree(server_option->name);
2522 amfree(server_option->value);
2524 amfree(server_options);
2527 for(i=0; i<CNF_CNF-1; i++)
2528 free_val_t(&server_conf[i]);