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