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