1 #include "burp.h"
2 #include "strlist.h"
3 #include "conf.h"
4 #include "log.h"
5 #include "alloc.h"
6 #include "cntr.h"
7 #include "prepend.h"
8 #include "server/dpth.h"
9 
10 #include <assert.h>
11 
str_to_burp_mode(const char * str)12 enum burp_mode str_to_burp_mode(const char *str)
13 {
14 	if(!strcmp(str, "server"))
15 		return BURP_MODE_SERVER;
16 	else if(!strcmp(str, "client"))
17 		return BURP_MODE_CLIENT;
18 	logp("Unknown mode setting: %s\n", str);
19 	return BURP_MODE_UNSET;
20 }
21 
burp_mode_to_str(enum burp_mode bm)22 static const char *burp_mode_to_str(enum burp_mode bm)
23 {
24 	switch(bm)
25 	{
26 		case BURP_MODE_UNSET: return "unset";
27 		case BURP_MODE_SERVER: return "server";
28 		case BURP_MODE_CLIENT: return "client";
29 		default: return "unknown";
30 	}
31 }
32 
str_to_recovery_method(const char * str)33 enum recovery_method str_to_recovery_method(const char *str)
34 {
35 	if(!strcmp(str, "delete"))
36 		return RECOVERY_METHOD_DELETE;
37 	else if(!strcmp(str, "resume"))
38 		return RECOVERY_METHOD_RESUME;
39 	logp("Unknown working_dir_recovery_method setting: %s\n", str);
40 	return RECOVERY_METHOD_UNSET;
41 }
42 
recovery_method_to_str(enum recovery_method r)43 const char *recovery_method_to_str(enum recovery_method r)
44 {
45 	switch(r)
46 	{
47 		case RECOVERY_METHOD_DELETE: return "delete";
48 		case RECOVERY_METHOD_RESUME: return "resume";
49 		default: return "unknown";
50 	}
51 }
52 
rshash_to_str(enum rshash r)53 const char *rshash_to_str(enum rshash r)
54 {
55 	switch(r)
56 	{
57 		case RSHASH_UNSET: return "unset";
58 		case RSHASH_MD4: return "md4";
59 		case RSHASH_BLAKE2: return "blake2";
60 		default: return "unknown";
61 	}
62 }
63 
str_to_protocol(const char * str)64 enum protocol str_to_protocol(const char *str)
65 {
66 	if(!strcmp(str, "0"))
67 		return PROTO_AUTO;
68 	else if(!strcmp(str, "1"))
69 		return PROTO_1;
70 	else if(!strcmp(str, "2"))
71 		return PROTO_2;
72 	logp("Unknown protocol setting: %s\n", str);
73 	return PROTO_AUTO;
74 }
75 
get_strlist(struct conf * conf)76 struct strlist *get_strlist(struct conf *conf)
77 {
78 	assert(conf->conf_type==CT_STRLIST);
79 	return conf->data.sl;
80 }
81 
get_string(struct conf * conf)82 char *get_string(struct conf *conf)
83 {
84 	assert(conf->conf_type==CT_STRING);
85 	return conf->data.s;
86 }
87 
get_int(struct conf * conf)88 int get_int(struct conf *conf)
89 {
90 	assert(conf->conf_type==CT_UINT);
91 	return conf->data.i;
92 }
93 
get_uint64_t(struct conf * conf)94 uint64_t get_uint64_t(struct conf *conf)
95 {
96 	assert(conf->conf_type==CT_SSIZE_T);
97 	return conf->data.uint64;
98 }
99 
get_float(struct conf * conf)100 float get_float(struct conf *conf)
101 {
102 	assert(conf->conf_type==CT_FLOAT);
103 	return conf->data.f;
104 }
105 
get_mode_t(struct conf * conf)106 mode_t get_mode_t(struct conf *conf)
107 {
108 	assert(conf->conf_type==CT_MODE_T);
109 	return conf->data.mode;
110 }
111 
get_e_burp_mode(struct conf * conf)112 enum burp_mode get_e_burp_mode(struct conf *conf)
113 {
114 	assert(conf->conf_type==CT_E_BURP_MODE);
115 	return conf->data.burp_mode;
116 }
117 
get_e_protocol(struct conf * conf)118 enum protocol get_e_protocol(struct conf *conf)
119 {
120 	assert(conf->conf_type==CT_E_PROTOCOL);
121 	return conf->data.protocol;
122 }
123 
get_protocol(struct conf ** confs)124 enum protocol get_protocol(struct conf **confs)
125 {
126 	return get_e_protocol(confs[OPT_PROTOCOL]);
127 }
128 
get_e_recovery_method(struct conf * conf)129 enum recovery_method get_e_recovery_method(struct conf *conf)
130 {
131 	assert(conf->conf_type==CT_E_RECOVERY_METHOD);
132 	return conf->data.recovery_method;
133 }
134 
get_e_rshash(struct conf * conf)135 enum rshash get_e_rshash(struct conf *conf)
136 {
137 	assert(conf->conf_type==CT_E_RSHASH);
138 	return conf->data.rshash;
139 }
140 
get_cntr(struct conf ** confs)141 struct cntr *get_cntr(struct conf **confs)
142 {
143 	return confs[OPT_CNTR]->data.cntr;
144 }
145 
set_string(struct conf * conf,const char * s)146 int set_string(struct conf *conf, const char *s)
147 {
148 	assert(conf->conf_type==CT_STRING);
149 	if(conf->data.s) free_w(&(conf->data.s));
150 	if(s && !(conf->data.s=strdup_w(s, __func__)))
151 		return -1;
152 	return 0;
153 }
154 
set_int(struct conf * conf,unsigned int i)155 int set_int(struct conf *conf, unsigned int i)
156 {
157 	assert(conf->conf_type==CT_UINT);
158 	conf->data.i=i;
159 	return 0;
160 }
161 
set_strlist(struct conf * conf,struct strlist * s)162 int set_strlist(struct conf *conf, struct strlist *s)
163 {
164 	assert(conf->conf_type==CT_STRLIST);
165 	if(conf->data.sl) strlists_free(&conf->data.sl);
166 	conf->data.sl=s;
167 	return 0;
168 }
169 
set_float(struct conf * conf,float f)170 int set_float(struct conf *conf, float f)
171 {
172 	assert(conf->conf_type==CT_FLOAT);
173 	conf->data.f=f;
174 	return 0;
175 }
176 
set_e_burp_mode(struct conf * conf,enum burp_mode bm)177 int set_e_burp_mode(struct conf *conf, enum burp_mode bm)
178 {
179 	assert(conf->conf_type==CT_E_BURP_MODE);
180 	conf->data.burp_mode=bm;
181 	return 0;
182 }
183 
set_e_protocol(struct conf * conf,enum protocol p)184 int set_e_protocol(struct conf *conf, enum protocol p)
185 {
186 	assert(conf->conf_type==CT_E_PROTOCOL);
187 	conf->data.protocol=p;
188 	return 0;
189 }
190 
set_protocol(struct conf ** confs,enum protocol p)191 int set_protocol(struct conf **confs, enum protocol p)
192 {
193 	return set_e_protocol(confs[OPT_PROTOCOL], p);
194 }
195 
set_e_recovery_method(struct conf * conf,enum recovery_method r)196 int set_e_recovery_method(struct conf *conf, enum recovery_method r)
197 {
198 	assert(conf->conf_type==CT_E_RECOVERY_METHOD);
199 	conf->data.recovery_method=r;
200 	return 0;
201 }
202 
set_e_rshash(struct conf * conf,enum rshash r)203 int set_e_rshash(struct conf *conf, enum rshash r)
204 {
205 	assert(conf->conf_type==CT_E_RSHASH);
206 	conf->data.rshash=r;
207 	return 0;
208 }
209 
set_mode_t(struct conf * conf,mode_t m)210 int set_mode_t(struct conf *conf, mode_t m)
211 {
212 	assert(conf->conf_type==CT_MODE_T);
213 	conf->data.mode=m;
214 	return 0;
215 }
216 
set_uint64_t(struct conf * conf,uint64_t s)217 int set_uint64_t(struct conf *conf, uint64_t s)
218 {
219 	assert(conf->conf_type==CT_SSIZE_T);
220 	conf->data.uint64=s;
221 	return 0;
222 }
223 
set_cntr(struct conf * conf,struct cntr * cntr)224 int set_cntr(struct conf *conf, struct cntr *cntr)
225 {
226 	assert(conf->conf_type==CT_CNTR);
227 	conf->data.cntr=cntr;
228 	return 0;
229 }
230 
add_to_strlist(struct conf * conf,const char * value,int include)231 int add_to_strlist(struct conf *conf, const char *value, int include)
232 {
233 	assert(conf->conf_type==CT_STRLIST);
234 	if(conf->flags & CONF_FLAG_STRLIST_SORTED)
235 		return strlist_add_sorted(&(conf->data.sl), value, include);
236 	else
237 		return strlist_add(&(conf->data.sl), value, include);
238 }
239 
add_to_strlist_include_uniq(struct conf * conf,const char * value)240 int add_to_strlist_include_uniq(struct conf *conf, const char *value)
241 {
242 	return strlist_add_sorted_uniq(&(conf->data.sl), value, 1);
243 }
244 
conf_free_content(struct conf * c)245 void conf_free_content(struct conf *c)
246 {
247 	if(!c) return;
248 	switch(c->conf_type)
249 	{
250 		case CT_STRING:
251 			free_w(&c->data.s);
252 			break;
253 		case CT_STRLIST:
254 			strlists_free(&c->data.sl);
255 			break;
256 		case CT_CNTR:
257 			cntr_free(&c->data.cntr);
258 			break;
259 		case CT_FLOAT:
260 		case CT_E_BURP_MODE:
261 		case CT_E_PROTOCOL:
262 		case CT_E_RECOVERY_METHOD:
263 		case CT_E_RSHASH:
264 		case CT_UINT:
265 		case CT_MODE_T:
266 		case CT_SSIZE_T:
267 			memset(&c->data, 0, sizeof(c->data));
268 			break;
269 	}
270 }
271 
confs_memcpy(struct conf ** dst,struct conf ** src)272 void confs_memcpy(struct conf **dst, struct conf **src)
273 {
274 	int i=0;
275 	for(i=0; i<OPT_MAX; i++)
276 	{
277 		free_v((void **)&(dst[i]));
278 		dst[i]=src[i];
279 	}
280 }
281 
confs_null(struct conf ** confs)282 void confs_null(struct conf **confs)
283 {
284 	int i=0;
285 	if(!confs) return;
286 	for(i=0; i<OPT_MAX; i++) confs[i]=NULL;
287 }
288 
confs_free_content(struct conf ** confs)289 void confs_free_content(struct conf **confs)
290 {
291 	int i=0;
292 	if(!confs) return;
293 	for(i=0; i<OPT_MAX; i++) conf_free_content(confs[i]);
294 }
295 
296 /* Free only stuff related to includes/excludes.
297    This is so that the server can override them all on the client. */
free_incexcs(struct conf ** confs)298 void free_incexcs(struct conf **confs)
299 {
300 	int i=0;
301 	if(!confs) return;
302 	for(i=0; i<OPT_MAX; i++)
303 		if(confs[i]->flags & CONF_FLAG_INCEXC)
304 			conf_free_content(confs[i]);
305 }
306 
sc(struct conf * conf,uint8_t flags,enum conf_type conf_type,const char * field)307 static void sc(struct conf *conf, uint8_t flags,
308 	enum conf_type conf_type, const char *field)
309 {
310 	conf->conf_type=conf_type;
311 	conf->field=field;
312 	conf->flags=flags;
313 	memset(&conf->data, 0, sizeof(conf->data));
314 }
315 
sc_str(struct conf * conf,const char * def,uint8_t flags,const char * field)316 static int sc_str(struct conf *conf, const char *def,
317 	uint8_t flags, const char *field)
318 {
319 	sc(conf, flags, CT_STRING, field);
320 	return set_string(conf, def);
321 }
322 
sc_int(struct conf * conf,unsigned int def,uint8_t flags,const char * field)323 static int sc_int(struct conf *conf, unsigned int def,
324 	uint8_t flags, const char *field)
325 {
326 	sc(conf, flags, CT_UINT, field);
327 	return set_int(conf, def);
328 }
329 
sc_lst(struct conf * conf,struct strlist * def,uint8_t flags,const char * field)330 static int sc_lst(struct conf *conf, struct strlist *def,
331 	uint8_t flags, const char *field)
332 {
333 	sc(conf, flags, CT_STRLIST, field);
334 	return set_strlist(conf, def);
335 }
336 
sc_flt(struct conf * conf,float def,uint8_t flags,const char * field)337 static int sc_flt(struct conf *conf, float def,
338 	uint8_t flags, const char *field)
339 {
340 	sc(conf, flags, CT_FLOAT, field);
341 	return set_float(conf, def);
342 }
343 
sc_ebm(struct conf * conf,enum burp_mode def,uint8_t flags,const char * field)344 static int sc_ebm(struct conf *conf, enum burp_mode def,
345 	uint8_t flags, const char *field)
346 {
347 	sc(conf, flags, CT_E_BURP_MODE, field);
348 	return set_e_burp_mode(conf, def);
349 }
350 
sc_epr(struct conf * conf,enum protocol def,uint8_t flags,const char * field)351 static int sc_epr(struct conf *conf, enum protocol def,
352 	uint8_t flags, const char *field)
353 {
354 	sc(conf, flags, CT_E_PROTOCOL, field);
355 	return set_e_protocol(conf, def);
356 }
357 
sc_rec(struct conf * conf,enum recovery_method def,uint8_t flags,const char * field)358 static int sc_rec(struct conf *conf, enum recovery_method def,
359 	uint8_t flags, const char *field)
360 {
361 	sc(conf, flags, CT_E_RECOVERY_METHOD, field);
362 	return set_e_recovery_method(conf, def);
363 }
364 
sc_rsh(struct conf * conf,enum rshash def,uint8_t flags,const char * field)365 static int sc_rsh(struct conf *conf, enum rshash def,
366 	uint8_t flags, const char *field)
367 {
368 	sc(conf, flags, CT_E_RSHASH, field);
369 	return set_e_rshash(conf, def);
370 }
371 
sc_mod(struct conf * conf,mode_t def,uint8_t flags,const char * field)372 static int sc_mod(struct conf *conf, mode_t def,
373 	uint8_t flags, const char *field)
374 {
375 	sc(conf, flags, CT_MODE_T, field);
376 	return set_mode_t(conf, def);
377 }
378 
sc_u64(struct conf * conf,uint64_t def,uint8_t flags,const char * field)379 static int sc_u64(struct conf *conf, uint64_t def,
380 	uint8_t flags, const char *field)
381 {
382 	sc(conf, flags, CT_SSIZE_T, field);
383 	return set_uint64_t(conf, def);
384 }
385 
sc_cntr(struct conf * conf,struct cntr * def,uint8_t flags,const char * field)386 static int sc_cntr(struct conf *conf, struct cntr *def,
387 	uint8_t flags, const char *field)
388 {
389 	sc(conf, flags, CT_CNTR, field);
390 	return set_cntr(conf, def);
391 }
392 
reset_conf(struct conf ** c,enum conf_opt o)393 static int reset_conf(struct conf **c, enum conf_opt o)
394 {
395 	// Do this with a switch statement, so that we get compiler warnings
396 	// if anything is missed.
397 	switch(o)
398 	{
399 	case OPT_BURP_MODE:
400 	  return sc_ebm(c[o], BURP_MODE_UNSET, 0, "mode");
401 	case OPT_LOCKFILE:
402 	  return sc_str(c[o], 0, 0, "lockfile");
403 	case OPT_PIDFILE:
404 	  return sc_str(c[o], 0, 0, "pidfile");
405 	case OPT_SSL_CERT_CA:
406 	  return sc_str(c[o], 0, 0, "ssl_cert_ca");
407 	case OPT_SSL_CERT:
408 	  return sc_str(c[o], 0, 0, "ssl_cert");
409 	case OPT_SSL_KEY:
410 	  return sc_str(c[o], 0, 0, "ssl_key");
411 	case OPT_SSL_KEY_PASSWORD:
412 	  // FIX THIS: synonym: ssl_cert_password
413 	  return sc_str(c[o], 0, 0, "ssl_key_password");
414 	case OPT_SSL_PEER_CN:
415 	  return sc_str(c[o], 0, 0, "ssl_peer_cn");
416 	case OPT_SSL_CIPHERS:
417 	  return sc_str(c[o], 0, 0, "ssl_ciphers");
418 	case OPT_SSL_COMPRESSION:
419 	  return sc_int(c[o], 5, 0, "ssl_compression");
420 	case OPT_SSL_VERIFY_PEER_EARLY:
421 	  return sc_int(c[o], 0, 0, "ssl_verify_peer_early");
422 	case OPT_RATELIMIT:
423 	  return sc_flt(c[o], 0, 0, "ratelimit");
424 	case OPT_NETWORK_TIMEOUT:
425 	  return sc_int(c[o], 60*60*2, 0, "network_timeout");
426 	case OPT_CLIENT_IS_WINDOWS:
427 	  return sc_int(c[o], 0, 0, "client_is_windows");
428 	case OPT_PEER_VERSION:
429 	  return sc_str(c[o], 0, 0, "peer_version");
430 	case OPT_PORT:
431 	  return sc_lst(c[o], 0, 0, "port");
432 	case OPT_STATUS_PORT:
433 	  return sc_lst(c[o], 0, 0, "status_port");
434 	case OPT_LISTEN:
435 	  return sc_lst(c[o], 0, 0, "listen");
436 	case OPT_LISTEN_STATUS:
437 	  return sc_lst(c[o], 0, 0, "listen_status");
438 	case OPT_NETWORK_ALLOW:
439 	  return sc_lst(c[o], 0,
440 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "network_allow");
441 	case OPT_NETWORK_ALLOW_STATUS:
442 	  return sc_lst(c[o], 0,
443 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "network_allow_status");
444 	case OPT_PORT_BACKUP:
445 	  return sc_int(c[o], 0, 0, "port_backup");
446 	case OPT_PORT_RESTORE:
447 	  return sc_int(c[o], 0, 0, "port_restore");
448 	case OPT_PORT_VERIFY:
449 	  return sc_int(c[o], 0, 0, "port_verify");
450 	case OPT_PORT_LIST:
451 	  return sc_int(c[o], 0, 0, "port_list");
452 	case OPT_PORT_DELETE:
453 	  return sc_int(c[o], 0, 0, "port_delete");
454 	case OPT_SSL_DHFILE:
455 	  return sc_str(c[o], 0, 0, "ssl_dhfile");
456 	case OPT_MAX_CHILDREN:
457 	  return sc_lst(c[o], 0, 0, "max_children");
458 	case OPT_MAX_STATUS_CHILDREN:
459 	  return sc_lst(c[o], 0, 0, "max_status_children");
460 	case OPT_MAX_PARALLEL_BACKUPS:
461 	  return sc_int(c[o], 0, CONF_FLAG_CC_OVERRIDE, "max_parallel_backups");
462 	case OPT_CLIENT_LOCKDIR:
463 	  return sc_str(c[o], 0, CONF_FLAG_CC_OVERRIDE, "client_lockdir");
464 	case OPT_UMASK:
465 	  return sc_mod(c[o], 0022, 0, "umask");
466 	case OPT_MAX_HARDLINKS:
467 	  return sc_int(c[o], 10000, 0, "max_hardlinks");
468 	case OPT_MAX_STORAGE_SUBDIRS:
469 	  return sc_int(c[o], MAX_STORAGE_SUBDIRS, 0, "max_storage_subdirs");
470 	case OPT_DAEMON:
471 	  return sc_int(c[o], 1, 0, "daemon");
472 	case OPT_CA_CONF:
473 	  return sc_str(c[o], 0, 0, "ca_conf");
474 	case OPT_CA_NAME:
475 	  return sc_str(c[o], 0, 0, "ca_name");
476 	case OPT_CA_SERVER_NAME:
477 	  return sc_str(c[o], 0, 0, "ca_server_name");
478 	case OPT_CA_BURP_CA:
479 	  return sc_str(c[o], 0, 0, "ca_" PACKAGE_TARNAME "_ca");
480         case OPT_CA_CRL:
481           return sc_str(c[o], 0, 0, "ca_crl");
482         case OPT_CA_CRL_CHECK:
483           return sc_int(c[o], 0, 0, "ca_crl_check");
484 	case OPT_RBLK_MEMORY_MAX:
485 	  return sc_u64(c[o], 256*1024*1024, // 256 Mb.
486 		CONF_FLAG_CC_OVERRIDE, "rblk_memory_max");
487 	case OPT_SPARSE_SIZE_MAX:
488 	  return sc_u64(c[o], 256*1024*1024, // 256 Mb.
489 		CONF_FLAG_CC_OVERRIDE, "sparse_size_max");
490 	case OPT_MONITOR_LOGFILE:
491 	  return sc_str(c[o], 0, 0, "monitor_logfile");
492 	case OPT_MONITOR_EXE:
493 	  return sc_str(c[o], 0, 0, "monitor_exe");
494 	case OPT_BACKUP_FAILOVERS_LEFT:
495 	  return sc_int(c[o], 0, 0, "");
496 	case OPT_CNAME:
497 	  return sc_str(c[o], 0, 0, "cname");
498 	case OPT_CNAME_LOWERCASE:
499 	  return sc_int(c[o], 0, 0, "cname_lowercase");
500 	case OPT_CNAME_FQDN:
501 	  return sc_int(c[o], 1, 0, "cname_fqdn");
502 	case OPT_PASSWORD:
503 	  return sc_str(c[o], 0, 0, "password");
504 	case OPT_PASSWD:
505 	  return sc_str(c[o], 0, 0, "passwd");
506 	case OPT_SERVER:
507 	  return sc_str(c[o], 0, 0, "server");
508 	case OPT_SERVER_FAILOVER:
509 	  return sc_lst(c[o], 0, 0, "server_failover");
510 	case OPT_FAILOVER_ON_BACKUP_ERROR:
511 	  return sc_int(c[o], 0, 0, "failover_on_backup_error");
512 	case OPT_ENCRYPTION_PASSWORD:
513 	  return sc_str(c[o], 0, 0, "encryption_password");
514 	case OPT_AUTOUPGRADE_OS:
515 	  return sc_str(c[o], 0, 0, "autoupgrade_os");
516 	case OPT_AUTOUPGRADE_DIR:
517 	  return sc_str(c[o], 0, 0, "autoupgrade_dir");
518 	case OPT_CA_CSR_DIR:
519 	  return sc_str(c[o], 0, 0, "ca_csr_dir");
520 	case OPT_RANDOMISE:
521 	  return sc_int(c[o], 0, 0, "randomise");
522 	case OPT_RESTORE_LIST:
523 	  return sc_str(c[o], 0, 0, "restore_list");
524 	case OPT_ENABLED:
525 	  return sc_int(c[o], 1, CONF_FLAG_CC_OVERRIDE, "enabled");
526 	case OPT_SERVER_CAN_OVERRIDE_INCLUDES:
527 	  return sc_int(c[o], 1, 0, "server_can_override_includes");
528 	case OPT_BACKUP:
529 	  return sc_str(c[o], 0, CONF_FLAG_INCEXC_RESTORE, "backup");
530 	case OPT_BACKUP2:
531 	  return sc_str(c[o], 0, 0, "backup2");
532 	case OPT_RESTOREPREFIX:
533 	  return sc_str(c[o], 0, CONF_FLAG_INCEXC_RESTORE, "restoreprefix");
534 	case OPT_STRIP_FROM_PATH:
535 	  return sc_str(c[o], 0, CONF_FLAG_INCEXC_RESTORE, "stripfrompath");
536 	case OPT_BROWSEFILE:
537 	  return sc_str(c[o], 0, 0, "browsefile");
538 	case OPT_BROWSEDIR:
539 	  return sc_str(c[o], 0, 0, "browsedir");
540 	case OPT_GLOB_AFTER_SCRIPT_PRE:
541 	  return sc_int(c[o], 1, 0, "glob_after_script_pre");
542 	case OPT_B_SCRIPT_PRE:
543 	  return sc_str(c[o], 0, 0, "backup_script_pre");
544 	case OPT_B_SCRIPT_PRE_ARG:
545 	  return sc_lst(c[o], 0, 0, "backup_script_pre_arg");
546 	case OPT_B_SCRIPT_POST:
547 	  return sc_str(c[o], 0, 0, "backup_script_post");
548 	case OPT_B_SCRIPT_POST_ARG:
549 	  return sc_lst(c[o], 0, 0, "backup_script_post_arg");
550 	case OPT_B_SCRIPT_POST_RUN_ON_FAIL:
551 	  return sc_int(c[o], 0, 0, "backup_script_post_run_on_fail");
552 	case OPT_B_SCRIPT_RESERVED_ARGS:
553 	  return sc_int(c[o], 1, 0, "backup_script_reserved_args");
554 	case OPT_R_SCRIPT_PRE:
555 	  return sc_str(c[o], 0, 0, "restore_script_pre");
556 	case OPT_R_SCRIPT_PRE_ARG:
557 	  return sc_lst(c[o], 0, 0, "restore_script_pre_arg");
558 	case OPT_R_SCRIPT_POST:
559 	  return sc_str(c[o], 0, 0, "restore_script_post");
560 	case OPT_R_SCRIPT_POST_ARG:
561 	  return sc_lst(c[o], 0, 0, "restore_script_post_arg");
562 	case OPT_R_SCRIPT_POST_RUN_ON_FAIL:
563 	  return sc_int(c[o], 0, 0, "restore_script_post_run_on_fail");
564 	case OPT_B_SCRIPT:
565 	  return sc_str(c[o], 0, 0, "backup_script");
566 	case OPT_B_SCRIPT_ARG:
567 	  return sc_lst(c[o], 0, 0, "backup_script_arg");
568 	case OPT_R_SCRIPT:
569 	  return sc_str(c[o], 0, 0, "restore_script");
570 	case OPT_R_SCRIPT_ARG:
571 	  return sc_lst(c[o], 0, 0, "restore_script_arg");
572 	case OPT_R_SCRIPT_RESERVED_ARGS:
573 	  return sc_int(c[o], 1, 0, "restore_script_reserved_args");
574 	case OPT_SEND_CLIENT_CNTR:
575 	  return sc_int(c[o], 0, 0, "send_client_cntr");
576 	case OPT_SUPER_CLIENT:
577 	  return sc_str(c[o], 0, 0, "");
578 	case OPT_RESTORE_PATH:
579 	  return sc_str(c[o], 0, 0, "restore_path");
580 	case OPT_ORIG_CLIENT:
581 	  return sc_str(c[o], 0, CONF_FLAG_INCEXC_RESTORE, "orig_client");
582 	case OPT_CONNECT_CLIENT:
583 	  return sc_str(c[o], 0, 0, "");
584 	case OPT_CNTR:
585 	  return sc_cntr(c[o], 0, 0, "");
586 	case OPT_VSS_RESTORE:
587 	  return sc_int(c[o], VSS_RESTORE_ON, 0, "");
588 	case OPT_READALL:
589 	  return sc_int(c[o], 0, CONF_FLAG_CC_OVERRIDE, "readall");
590 	case OPT_BREAKPOINT:
591 	  return sc_int(c[o], 0,
592 		CONF_FLAG_CC_OVERRIDE, "breakpoint");
593 	case OPT_CONFFILE:
594 	  return sc_str(c[o], 0,
595 		CONF_FLAG_CC_OVERRIDE, "conffile");
596 	case OPT_SYSLOG:
597 	  return sc_int(c[o], 0,
598 		CONF_FLAG_CC_OVERRIDE, "syslog");
599 	case OPT_STDOUT:
600 	  return sc_int(c[o], 1,
601 		CONF_FLAG_CC_OVERRIDE, "stdout");
602 	case OPT_PROGRESS_COUNTER:
603 	  return sc_int(c[o], 0,
604 		CONF_FLAG_CC_OVERRIDE, "progress_counter");
605 	case OPT_USER:
606 	  return sc_str(c[o], 0,
607 		CONF_FLAG_CC_OVERRIDE, "user");
608 	case OPT_GROUP:
609 	  return sc_str(c[o], 0,
610 		CONF_FLAG_CC_OVERRIDE, "group");
611 	case OPT_PROTOCOL:
612 	  return sc_epr(c[o], PROTO_AUTO,
613 		CONF_FLAG_CC_OVERRIDE, "protocol");
614 	case OPT_DIRECTORY:
615 	  return sc_str(c[o], 0,
616 		CONF_FLAG_CC_OVERRIDE, "directory");
617 	case OPT_TIMESTAMP_FORMAT:
618 	  return sc_str(c[o], 0,
619 		CONF_FLAG_CC_OVERRIDE, "timestamp_format");
620 	case OPT_CLIENTCONFDIR:
621 	  return sc_str(c[o], 0,
622 		CONF_FLAG_CC_OVERRIDE, "clientconfdir");
623 	case OPT_FORK:
624 	  return sc_int(c[o], 1, 0, "fork");
625 	case OPT_DIRECTORY_TREE:
626 	  return sc_int(c[o], 1,
627 		CONF_FLAG_CC_OVERRIDE, "directory_tree");
628 	case OPT_PASSWORD_CHECK:
629 	  return sc_int(c[o], 1,
630 		CONF_FLAG_CC_OVERRIDE, "password_check");
631 	case OPT_MANUAL_DELETE:
632 	  return sc_str(c[o], 0,
633 		CONF_FLAG_CC_OVERRIDE, "manual_delete");
634 	case OPT_MONITOR_BROWSE_CACHE:
635 	  return sc_int(c[o], 0,
636 		CONF_FLAG_CC_OVERRIDE, "monitor_browse_cache");
637 	case OPT_S_SCRIPT_PRE:
638 	  return sc_str(c[o], 0,
639 		CONF_FLAG_CC_OVERRIDE, "server_script_pre");
640 	case OPT_S_SCRIPT_PRE_ARG:
641 	  return sc_lst(c[o], 0,
642 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "server_script_pre_arg");
643 	case OPT_S_SCRIPT_PRE_NOTIFY:
644 	  return sc_int(c[o], 0,
645 		CONF_FLAG_CC_OVERRIDE, "server_script_pre_notify");
646 	case OPT_S_SCRIPT_POST:
647 	  return sc_str(c[o], 0,
648 		CONF_FLAG_CC_OVERRIDE, "server_script_post");
649 	case OPT_S_SCRIPT_POST_ARG:
650 	  return sc_lst(c[o], 0,
651 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "server_script_post_arg");
652 	case OPT_S_SCRIPT_POST_RUN_ON_FAIL:
653 	  return sc_int(c[o], 0,
654 		CONF_FLAG_CC_OVERRIDE, "server_script_post_run_on_fail");
655 	case OPT_S_SCRIPT_POST_NOTIFY:
656 	  return sc_int(c[o], 0,
657 		CONF_FLAG_CC_OVERRIDE, "server_script_post_notify");
658 	case OPT_S_SCRIPT:
659 	  return sc_str(c[o], 0,
660 		CONF_FLAG_CC_OVERRIDE, "server_script");
661 	case OPT_S_SCRIPT_ARG:
662 	  return sc_lst(c[o], 0,
663 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "server_script_arg");
664 	case OPT_S_SCRIPT_NOTIFY:
665 	  return sc_int(c[o], 0,
666 		CONF_FLAG_CC_OVERRIDE, "server_script_notify");
667 	case OPT_HARDLINKED_ARCHIVE:
668 	  return sc_int(c[o], 0,
669 		CONF_FLAG_CC_OVERRIDE, "hardlinked_archive");
670 	case OPT_KEEP:
671 	  return sc_lst(c[o], 0,
672 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "keep");
673 	case OPT_LIBRSYNC:
674 	  return sc_int(c[o], 1,
675 		CONF_FLAG_CC_OVERRIDE, "librsync");
676 	case OPT_LIBRSYNC_MAX_SIZE:
677 	  return sc_u64(c[o], 0,
678 		CONF_FLAG_CC_OVERRIDE, "librsync_max_size");
679 	case OPT_COMPRESSION:
680 	  return sc_int(c[o], 9,
681 		CONF_FLAG_CC_OVERRIDE, "compression");
682 	case OPT_VERSION_WARN:
683 	  return sc_int(c[o], 1,
684 		CONF_FLAG_CC_OVERRIDE, "version_warn");
685 	case OPT_PATH_LENGTH_WARN:
686 	  return sc_int(c[o], 1,
687 		CONF_FLAG_CC_OVERRIDE, "path_length_warn");
688 	case OPT_HARD_QUOTA:
689 	  return sc_u64(c[o], 0,
690 		CONF_FLAG_CC_OVERRIDE, "hard_quota");
691 	case OPT_SOFT_QUOTA:
692 	  return sc_u64(c[o], 0,
693 		CONF_FLAG_CC_OVERRIDE, "soft_quota");
694 	case OPT_TIMER_SCRIPT:
695 	  return sc_str(c[o], 0,
696 		CONF_FLAG_CC_OVERRIDE, "timer_script");
697 	case OPT_TIMER_ARG:
698 	  return sc_lst(c[o], 0,
699 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "timer_arg");
700 	case OPT_TIMER_REPEAT_INTERVAL:
701 	  return sc_int(c[o], 0,
702 		CONF_FLAG_CC_OVERRIDE, "timer_repeat_interval");
703 	case OPT_LABEL:
704 	  return sc_lst(c[o], 0,
705 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "label");
706 	case OPT_N_SUCCESS_SCRIPT:
707 	  return sc_str(c[o], 0,
708 		CONF_FLAG_CC_OVERRIDE, "notify_success_script");
709 	case OPT_N_SUCCESS_ARG:
710 	  return sc_lst(c[o], 0,
711 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "notify_success_arg");
712 	case OPT_N_SUCCESS_WARNINGS_ONLY:
713 	  return sc_int(c[o], 0,
714 		CONF_FLAG_CC_OVERRIDE, "notify_success_warnings_only");
715 	case OPT_N_SUCCESS_CHANGES_ONLY:
716 	  return sc_int(c[o], 0,
717 		CONF_FLAG_CC_OVERRIDE, "notify_success_changes_only");
718 	case OPT_N_FAILURE_SCRIPT:
719 	  return sc_str(c[o], 0,
720 		CONF_FLAG_CC_OVERRIDE, "notify_failure_script");
721 	case OPT_N_FAILURE_ARG:
722 	  return sc_lst(c[o], 0,
723 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_REPLACE, "notify_failure_arg");
724 	case OPT_N_FAILURE_BACKUP_FAILOVERS_LEFT:
725 	  return sc_int(c[o], 1,
726 		CONF_FLAG_CC_OVERRIDE, "notify_failure_on_backup_with_failovers_left");
727 	case OPT_N_FAILURE_BACKUP_WORKING_DELETION:
728 	  return sc_int(c[o], 0,
729 		CONF_FLAG_CC_OVERRIDE, "notify_failure_on_backup_working_dir_deletion");
730 	case OPT_RESTORE_CLIENTS:
731 	  return sc_lst(c[o], 0,
732 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_SORTED, "restore_client");
733 	case OPT_SUPER_CLIENTS:
734 	  return sc_lst(c[o], 0,
735 		CONF_FLAG_CC_OVERRIDE|CONF_FLAG_STRLIST_SORTED, "super_client");
736 	case OPT_DEDUP_GROUP:
737 	  return sc_str(c[o], 0,
738 		CONF_FLAG_CC_OVERRIDE, "dedup_group");
739 	case OPT_CLIENT_CAN_DELETE:
740 	  return sc_int(c[o], 1,
741 		CONF_FLAG_CC_OVERRIDE, "client_can_delete");
742 	case OPT_CLIENT_CAN_DIFF:
743 	  return sc_int(c[o], 1,
744 		CONF_FLAG_CC_OVERRIDE, "client_can_diff");
745 	case OPT_CLIENT_CAN_FORCE_BACKUP:
746 	  return sc_int(c[o], 1,
747 		CONF_FLAG_CC_OVERRIDE, "client_can_force_backup");
748 	case OPT_CLIENT_CAN_LIST:
749 	  return sc_int(c[o], 1,
750 		CONF_FLAG_CC_OVERRIDE, "client_can_list");
751 	case OPT_CLIENT_CAN_MONITOR:
752 	  return sc_int(c[o], 1,
753 		CONF_FLAG_CC_OVERRIDE, "client_can_monitor");
754 	case OPT_CLIENT_CAN_RESTORE:
755 	  return sc_int(c[o], 1,
756 		CONF_FLAG_CC_OVERRIDE, "client_can_restore");
757 	case OPT_CLIENT_CAN_VERIFY:
758 	  return sc_int(c[o], 1,
759 		CONF_FLAG_CC_OVERRIDE, "client_can_verify");
760 	case OPT_SERVER_CAN_RESTORE:
761 	  return sc_int(c[o], 1,
762 		CONF_FLAG_CC_OVERRIDE, "server_can_restore");
763 	case OPT_WORKING_DIR_RECOVERY_METHOD:
764 	  return sc_rec(c[o], RECOVERY_METHOD_DELETE,
765 		CONF_FLAG_CC_OVERRIDE, "working_dir_recovery_method");
766 	case OPT_MAX_RESUME_ATTEMPTS:
767 	  return sc_int(c[o], 0,
768 		CONF_FLAG_CC_OVERRIDE, "max_resume_attempts");
769 	case OPT_FAIL_ON_WARNING:
770 	  return sc_int(c[o], 0,
771 		CONF_FLAG_CC_OVERRIDE, "fail_on_warning");
772 	case OPT_RSHASH:
773 	  return sc_rsh(c[o], RSHASH_UNSET,
774 		CONF_FLAG_CC_OVERRIDE, "");
775 	case OPT_MESSAGE:
776 	  return sc_int(c[o], 0,
777 		CONF_FLAG_CC_OVERRIDE, "");
778 	case OPT_INCEXCDIR:
779 	  // This is a combination of OPT_INCLUDE and OPT_EXCLUDE, so
780 	  // no field name set for now.
781 	  return sc_lst(c[o], 0, CONF_FLAG_STRLIST_SORTED, "incexcdir");
782 	case OPT_STARTDIR:
783 	  // This is a combination of OPT_INCLUDE and OPT_EXCLUDE, so
784 	  // no field name set for now.
785 	  // Deliberately not using CONF_FLAG_STRLIST_SORTED because of the
786 	  // way finalise_start_dirs() works.
787 	  return sc_lst(c[o], 0, 0, "startdir");
788 	case OPT_INCLUDE:
789 	  // Combines with OPT_EXCLUDE to make OPT_INCEXCDIR and OPT_STARTDIR.
790 	  return sc_lst(c[o], 0,
791 		CONF_FLAG_INCEXC|CONF_FLAG_INCEXC_RESTORE|CONF_FLAG_STRLIST_SORTED, "include");
792 	case OPT_EXCLUDE:
793 	  // Combines with OPT_INCLUDE to make OPT_INCEXCDIR and OPT_STARTDIR.
794 	  return sc_lst(c[o], 0,
795 		CONF_FLAG_INCEXC|CONF_FLAG_INCEXC_RESTORE|CONF_FLAG_STRLIST_SORTED, "exclude");
796 	case OPT_FSCHGDIR:
797 	  return sc_lst(c[o], 0,
798 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "cross_filesystem");
799 	case OPT_NOBACKUP:
800 	  return sc_lst(c[o], 0,
801 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "nobackup");
802 	case OPT_INCEXT:
803 	  return sc_lst(c[o], 0,
804 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "include_ext");
805 	case OPT_EXCEXT:
806 	  return sc_lst(c[o], 0,
807 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "exclude_ext");
808 	case OPT_INCREG:
809 	  return sc_lst(c[o], 0,
810 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "include_regex");
811 	case OPT_EXCREG:
812 	  return sc_lst(c[o], 0,
813 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "exclude_regex");
814 	case OPT_INCLOGIC:
815 	  return sc_lst(c[o], 0,
816 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "include_logic");
817 	 case OPT_EXCLOGIC:
818 	  return sc_lst(c[o], 0,
819 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "exclude_logic");
820 	case OPT_EXCFS:
821 	  return sc_lst(c[o], 0,
822 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "exclude_fs");
823 	case OPT_INCFS:
824 	  return sc_lst(c[o], 0,
825 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "include_fs");
826 	case OPT_EXCOM:
827 	  return sc_lst(c[o], 0,
828 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "exclude_comp");
829 	case OPT_INCGLOB:
830 	  return sc_lst(c[o], 0,
831 		CONF_FLAG_INCEXC|CONF_FLAG_STRLIST_SORTED, "include_glob");
832 	case OPT_SEED_SRC:
833 	  return sc_str(c[o], 0, 0, "seed_src");
834 	case OPT_SEED_DST:
835 	  return sc_str(c[o], 0, 0, "seed_dst");
836 	case OPT_CROSS_ALL_FILESYSTEMS:
837 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "cross_all_filesystems");
838 	case OPT_READ_ALL_FIFOS:
839 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "read_all_fifos");
840 	case OPT_FIFOS:
841 	  return sc_lst(c[o], 0, CONF_FLAG_INCEXC, "read_fifo");
842 	case OPT_READ_ALL_BLOCKDEVS:
843 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "read_all_blockdevs");
844 	case OPT_BLOCKDEVS:
845 	  return sc_lst(c[o], 0, CONF_FLAG_INCEXC, "read_blockdev");
846 	case OPT_MIN_FILE_SIZE:
847 	  return sc_u64(c[o], 0, CONF_FLAG_INCEXC, "min_file_size");
848 	case OPT_MAX_FILE_SIZE:
849 	  return sc_u64(c[o], 0, CONF_FLAG_INCEXC, "max_file_size");
850 	case OPT_SPLIT_VSS:
851 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "split_vss");
852 	case OPT_STRIP_VSS:
853 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "strip_vss");
854 	case OPT_VSS_DRIVES:
855 	  return sc_str(c[o], 0, CONF_FLAG_INCEXC, "vss_drives");
856 	case OPT_ACL:
857 	  return sc_int(c[o], 1, CONF_FLAG_INCEXC, "acl");
858 	case OPT_XATTR:
859 	  return sc_int(c[o], 1, CONF_FLAG_INCEXC, "xattr");
860 	case OPT_ATIME:
861 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "atime");
862 	case OPT_SCAN_PROBLEM_RAISES_ERROR:
863 	  return sc_int(c[o], 0, CONF_FLAG_INCEXC, "scan_problem_raises_error");
864 	case OPT_OVERWRITE:
865 	  return sc_int(c[o], 0,
866 		CONF_FLAG_INCEXC|CONF_FLAG_INCEXC_RESTORE, "overwrite");
867 	case OPT_STRIP:
868 	  return sc_int(c[o], 0,
869 		CONF_FLAG_INCEXC|CONF_FLAG_INCEXC_RESTORE, "strip");
870 	case OPT_REGEX:
871 	  return sc_str(c[o], 0,
872 		CONF_FLAG_INCEXC|CONF_FLAG_INCEXC_RESTORE, "regex");
873 	case OPT_REGEX_CASE_INSENSITIVE:
874 	  return sc_int(c[o], 0,
875 		CONF_FLAG_INCEXC|CONF_FLAG_INCEXC_RESTORE, "regex_case_insensitive");
876 	case OPT_MAX:
877 	  return 0;
878 	// No default, so we get compiler warnings if something was missed.
879 	}
880 	return -1;
881 }
882 
set_conf(struct conf * c,const char * value)883 static int set_conf(struct conf *c, const char *value)
884 {
885 	switch(c->conf_type)
886 	{
887 		case CT_STRING:
888 			if(set_string(c, value)) return 1;
889 			break;
890 		case CT_FLOAT:
891 			if(set_float(c, atof(value))) return 1;
892 			break;
893 		case CT_E_BURP_MODE:
894 		{
895 			enum burp_mode bm;
896 			bm=str_to_burp_mode(value);
897 			if(bm==BURP_MODE_UNSET
898 			  || set_e_burp_mode(c, bm))
899 				return 1;
900 			break;
901 		}
902 		case CT_E_RECOVERY_METHOD:
903 		{
904 			enum recovery_method rm;
905 			rm=str_to_recovery_method(value);
906 			if(rm==RECOVERY_METHOD_UNSET
907 			  || set_e_recovery_method(c, rm))
908 				return 1;
909 			break;
910 		}
911 	// FIX THIS
912 		case CT_E_RSHASH:
913 		case CT_UINT:
914 		case CT_MODE_T:
915 		case CT_SSIZE_T:
916 		case CT_E_PROTOCOL:
917 		case CT_STRLIST:
918 		case CT_CNTR:
919 			break;
920 	}
921 	return 0;
922 }
923 
conf_set(struct conf ** confs,const char * field,const char * value)924 int conf_set(struct conf **confs, const char *field, const char *value)
925 {
926 	int i=0;
927 	int r=0;
928 	for(i=0; i<OPT_MAX; i++)
929 	{
930 		if(strcmp(confs[i]->field, field)) continue;
931 		r+=set_conf(confs[i], value);
932 	}
933 	return r;
934 }
935 
conf_data_to_str(struct conf * conf)936 static char *conf_data_to_str(struct conf *conf)
937 {
938 	size_t l=256;
939 	char *ret=NULL;
940 	if(!conf->field || !*conf->field)
941 		return NULL;
942 	if(!(ret=(char *)calloc_w(1, l, __func__))) return ret;
943 	*ret='\0';
944 	switch(conf->conf_type)
945 	{
946 		case CT_STRING:
947 			snprintf(ret, l, "%32s: %s\n", conf->field,
948 				get_string(conf)?get_string(conf):"");
949 			break;
950 		case CT_FLOAT:
951 			snprintf(ret, l, "%32s: %g\n", conf->field,
952 				get_float(conf));
953 			break;
954 		case CT_E_BURP_MODE:
955 			snprintf(ret, l, "%32s: %s\n", conf->field,
956 				burp_mode_to_str(get_e_burp_mode(conf)));
957 			break;
958 		case CT_E_PROTOCOL:
959 			snprintf(ret, l, "%32s: %d\n", conf->field,
960 				get_e_protocol(conf));
961 			break;
962 		case CT_E_RECOVERY_METHOD:
963 			snprintf(ret, l, "%32s: %s\n", conf->field,
964 				recovery_method_to_str(
965 					get_e_recovery_method(conf)));
966 			break;
967 		case CT_E_RSHASH:
968 			snprintf(ret, l, "%32s: %s\n", conf->field,
969 				rshash_to_str(get_e_rshash(conf)));
970 			break;
971 		case CT_UINT:
972 			snprintf(ret, l, "%32s: %u\n", conf->field,
973 				get_int(conf));
974 			break;
975 		case CT_STRLIST:
976 		{
977 			int count=0;
978 			char piece[256]="";
979 			struct strlist *s;
980 			for(s=get_strlist(conf); s; s=s->next)
981 			{
982 				snprintf(piece, sizeof(piece),
983 					"%32s: %s\n", conf->field, s->path);
984 				if(astrcat(&ret, piece, __func__))
985 					return ret;
986 				count++;
987 			}
988 			if(!count)
989 			snprintf(ret, l, "%32s:\n", conf->field);
990 			break;
991 		}
992 		case CT_MODE_T:
993 			snprintf(ret, l, "%32s: %o\n", conf->field,
994 				get_mode_t(conf));
995 			break;
996 		case CT_SSIZE_T:
997 			snprintf(ret, l, "%32s: %" PRIu64 "\n", conf->field,
998 				get_uint64_t(conf));
999 			break;
1000 		case CT_CNTR:
1001 			break;
1002 	}
1003 	return ret;
1004 
1005 }
1006 
confs_alloc(void)1007 struct conf **confs_alloc(void)
1008 {
1009 	int i=0;
1010 	struct conf **confs=NULL;
1011 	if(!(confs=(struct conf **)
1012 		calloc_w(OPT_MAX, sizeof(struct conf *), __func__)))
1013 			return NULL;
1014 	for(i=0; i<OPT_MAX; i++)
1015 	{
1016 		struct conf *c;
1017 		if(!(c=(struct conf *)
1018 			calloc_w(1, sizeof(struct conf), __func__)))
1019 				return NULL;
1020 		confs[i]=c;
1021 	}
1022 	return confs;
1023 };
1024 
confs_free(struct conf *** confs)1025 void confs_free(struct conf ***confs)
1026 {
1027 	int i=0;
1028 	if(!confs || !*confs) return;
1029 	confs_free_content(*confs);
1030 	for(i=0; i<OPT_MAX; i++)
1031 		free_v((void **)&((*confs)[i]));
1032 	free_v((void **)confs);
1033 	*confs=NULL;
1034 }
1035 
confs_init(struct conf ** confs)1036 int confs_init(struct conf **confs)
1037 {
1038 	int i=0;
1039 	for(i=0; i<OPT_MAX; i++)
1040 		if(reset_conf(confs, (enum conf_opt)i))
1041 			return -1;
1042 	return 0;
1043 }
1044 
confs_dump(struct conf ** confs,int flags)1045 int confs_dump(struct conf **confs, int flags)
1046 {
1047 	int i=0;
1048 	char *str=NULL;
1049 	for(i=0; i<OPT_MAX; i++)
1050 	{
1051 		if(flags && !(flags & confs[i]->flags)) continue;
1052 	//	if(!*(confs[i]->field)) continue;
1053 		str=conf_data_to_str(confs[i]);
1054 		if(str && *str) printf("%s", str);
1055 		free_w(&str);
1056 	}
1057 	return 0;
1058 }
1059