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