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