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