Line data Source code
1 : #include "burp.h"
2 : #include "alloc.h"
3 : #include "conf.h"
4 : #include "fsops.h"
5 : #include "handy.h"
6 : #include "lock.h"
7 : #include "log.h"
8 : #include "msg.h"
9 : #include "pathcmp.h"
10 : #include "prepend.h"
11 : #include "strlist.h"
12 : #include "times.h"
13 : #include "client/glob_windows.h"
14 : #include "conffile.h"
15 :
16 : static struct strlist *cli_overrides=NULL;
17 :
18 0 : void conf_set_cli_overrides(struct strlist *overrides)
19 : {
20 0 : cli_overrides=overrides;
21 0 : }
22 :
23 : // This will strip off everything after the last quote. So, configs like this
24 : // should work:
25 : // exclude_regex = "[A-Z]:/pagefile.sys" # swap file (Windows XP, 7, 8)
26 : // Return 1 for quotes removed, -1 for error, 0 for OK.
27 3344 : static int remove_quotes(const char *f, char **v, char quote)
28 : {
29 3344 : char *dp=NULL;
30 3344 : char *sp=NULL;
31 3344 : char *copy=NULL;
32 3344 : int ret=1;
33 :
34 : // If it does not start with a quote, leave it alone.
35 3344 : if(**v!=quote) return 0;
36 :
37 4 : if(!(copy=strdup_w(*v, __func__)))
38 : {
39 : ret=-1;
40 : goto end;
41 : }
42 :
43 8 : for(dp=*v, sp=copy+1; *sp; sp++)
44 : {
45 6 : if(*sp==quote)
46 : {
47 : // Found a matching quote. Stop here.
48 2 : *dp='\0';
49 2 : for(sp++; *sp && isspace(*sp); sp++) { }
50 : // Do not complain about trailing comments.
51 2 : if(*sp && *sp!='#')
52 0 : logp("ignoring trailing characters after quote in config '%s = %s'\n", f, copy);
53 : goto end;
54 : }
55 4 : else if(*sp=='\\')
56 : {
57 0 : sp++;
58 0 : *dp=*sp;
59 0 : dp++;
60 0 : if(*sp!=quote
61 0 : && *sp!='\\')
62 0 : logp("unknown escape sequence '\\%c' in config '%s = %s' - treating it as '%c'\n", *sp, f, copy, *sp);
63 : }
64 : else
65 : {
66 4 : *dp=*sp;
67 4 : dp++;
68 : }
69 : }
70 2 : logp("Did not find closing quote in config '%s = %s'\n", f, copy);
71 2 : *dp='\0';
72 : end:
73 4 : free_w(©);
74 4 : return ret;
75 : }
76 :
77 : // Get field and value pair.
78 1705 : int conf_get_pair(char buf[], char **f, char **v, int *r)
79 : {
80 1705 : char *cp=NULL;
81 1705 : char *eq=NULL;
82 :
83 : // strip leading space
84 1705 : for(cp=buf; *cp && isspace(*cp); cp++) { }
85 1705 : if(!*cp || *cp=='#')
86 : {
87 31 : *f=NULL;
88 31 : *v=NULL;
89 31 : return 0;
90 : }
91 1674 : *f=cp;
92 1674 : if(!(eq=strchr(*f, '='))) return -1;
93 1673 : *eq='\0';
94 :
95 : // Strip white space from before the equals sign.
96 1709 : for(cp=eq-1; *cp && (isspace(*cp) || *cp == ':'); cp--)
97 : {
98 36 : if(*cp == ':') *r=1;
99 36 : *cp='\0';
100 : }
101 : // Skip white space after the equals sign.
102 1673 : for(cp=eq+1; *cp && isspace(*cp); cp++) { }
103 1673 : *v=cp;
104 : // Strip white space at the end of the line.
105 1673 : for(cp+=strlen(cp)-1; *cp && isspace(*cp); cp--) { *cp='\0'; }
106 :
107 : // FIX THIS: Make this more sophisticated - it should understand
108 : // escapes, for example.
109 :
110 1673 : switch(remove_quotes(*f, v, '\''))
111 : {
112 : case -1: return -1;
113 : case 1: break;
114 : default:
115 : // If single quotes were not removed, try to remove
116 : // double quotes.
117 1671 : if(remove_quotes(*f, v, '\"')<0) return -1;
118 : break;
119 : }
120 :
121 1673 : if(!*f || !**f || !*v || !**v) return -1;
122 :
123 1673 : return 0;
124 : }
125 :
126 : static int conf_error(const char *conf_path, int line)
127 : {
128 1 : logp("%s: parse error on line %d\n", conf_path, line);
129 : return -1;
130 : }
131 :
132 53 : int get_file_size(const char *v, uint64_t *dest, const char *conf_path, int line)
133 : {
134 : // Store in bytes, allow k/m/g.
135 53 : const char *cp=NULL;
136 53 : *dest=strtoul(v, NULL, 10);
137 53 : for(cp=v; *cp && (isspace(*cp) || isdigit(*cp)); cp++) { }
138 53 : if(tolower(*cp)=='k') *dest*=1024;
139 53 : else if(tolower(*cp)=='m') *dest*=1024*1024;
140 52 : else if(tolower(*cp)=='g') *dest*=1024*1024*1024;
141 52 : else if(!*cp || *cp=='b')
142 : { }
143 : else
144 : {
145 0 : logp("Unknown file size type '%s' - please use b/kb/mb/gb\n",
146 : cp);
147 0 : return conf_error(conf_path, line);
148 : }
149 : return 0;
150 : }
151 :
152 528 : static int pre_post_override(struct conf *c,
153 : struct conf *pre, struct conf *post)
154 : {
155 528 : const char *override=get_string(c);
156 528 : if(!override) return 0;
157 5 : if(set_string(pre, override)
158 5 : || set_string(post, override))
159 : return -1;
160 : return 0;
161 : }
162 :
163 : #ifdef HAVE_LINUX_OS
164 : struct fstype
165 : {
166 : const char *str;
167 : uint64_t flag;
168 : };
169 :
170 : // Sorted in magic number order.
171 : static struct fstype fstypes[]={
172 : { "devfs", 0x00001373 },
173 : { "devpts", 0x00001CD1 },
174 : { "smbfs", 0x0000517B },
175 : { "nfs", 0x00006969 },
176 : { "romfs", 0x00007275 },
177 : { "iso9660", 0x00009660 },
178 : { "devtmpfs", 0x00009FA0 },
179 : { "proc", 0x00009FA0 },
180 : { "usbdevfs", 0x00009FA2 },
181 : { "ext2", 0x0000EF53 },
182 : { "ext3", 0x0000EF53 },
183 : { "ext4", 0x0000EF53 },
184 : { "ecryptfs", 0x0000F15F },
185 : { "cgroup", 0x0027E0EB },
186 : { "ceph", 0x00C36400 },
187 : { "tmpfs", 0x01021994 },
188 : { "zfs", 0x2FC12FC1 },
189 : { "jfs", 0x3153464A },
190 : { "autofs", 0x42494E4D },
191 : { "reiserfs", 0x52654973 },
192 : { "ntfs", 0x5346544E },
193 : { "xfs", 0x58465342 },
194 : { "sysfs", 0x62656572 },
195 : { "debugfs", 0x64626720 },
196 : { "fusectl", 0x65735543 },
197 : { "fuse.lxcfs", 0x65735546 },
198 : { "securityfs", 0x73636673 },
199 : { "ramfs", 0x858458F6 },
200 : { "btrfs", 0x9123683E },
201 : { "hugetlbfs", 0x958458F6 },
202 : { "smb2", 0xFE534D42 },
203 : { "cifs", 0xFF534D42 },
204 : { NULL, 0 },
205 : };
206 : /* Use this C code to figure out what f_type gets set to.
207 : #include <stdio.h>
208 : #include <sys/vfs.h>
209 :
210 : int main(int argc, char *argv[])
211 : {
212 : int i=0;
213 : struct statfs buf;
214 : if(argc<1)
215 : {
216 : printf("not enough args\n");
217 : return -1;
218 : }
219 : if(statfs(argv[1], &buf))
220 : {
221 : printf("error\n");
222 : return -1;
223 : }
224 : printf("0x%08X\n", buf.f_type);
225 : return 0;
226 : }
227 : */
228 :
229 : #endif
230 :
231 0 : static int fstype_to_flag(const char *fstype, long *flag)
232 : {
233 : #ifdef HAVE_LINUX_OS
234 0 : int i=0;
235 0 : for(i=0; fstypes[i].str; i++)
236 : {
237 0 : if(!strcmp(fstypes[i].str, fstype))
238 : {
239 0 : *flag=fstypes[i].flag;
240 0 : return 0;
241 : }
242 : }
243 : #else
244 : return 0;
245 : #endif
246 : return -1;
247 : }
248 :
249 2 : static int get_compression(const char *v)
250 : {
251 2 : const char *cp=v;
252 2 : if(!strncmp(v, "gzip", strlen("gzip"))
253 2 : || !(strncmp(v, "zlib", strlen("zlib"))))
254 0 : cp=v+strlen("gzip"); // Or "zlib".
255 2 : if(strlen(cp)==1 && isdigit(*cp))
256 2 : return atoi(cp);
257 : return -1;
258 : }
259 :
260 1659 : static int load_conf_field_and_value(struct conf **c,
261 : const char *f, // field
262 : const char *v, // value
263 : int reset, // reset flag
264 : const char *conf_path,
265 : int line)
266 : {
267 1659 : if(!strcmp(f, "compression"))
268 : {
269 2 : int compression=get_compression(v);
270 2 : if(compression<0) return -1;
271 2 : set_int(c[OPT_COMPRESSION], compression);
272 : }
273 1657 : else if(!strcmp(f, "ssl_compression"))
274 : {
275 0 : int compression=get_compression(v);
276 0 : if(compression<0) return -1;
277 0 : set_int(c[OPT_SSL_COMPRESSION], compression);
278 : }
279 1657 : else if(!strcmp(f, "ratelimit"))
280 : {
281 0 : float f=0;
282 0 : f=atof(v);
283 : // User is specifying Mega bits per second.
284 : // Need to convert to bytes per second.
285 0 : f=(f*1024*1024)/8;
286 0 : if(!f)
287 : {
288 0 : logp("ratelimit should be greater than zero\n");
289 0 : return -1;
290 : }
291 0 : set_float(c[OPT_RATELIMIT], f);
292 : }
293 : else
294 : {
295 : int i=0;
296 104236 : for(i=0; i<OPT_MAX; i++)
297 : {
298 105888 : if(strcmp(c[i]->field, f)) continue;
299 1652 : switch(c[i]->conf_type)
300 : {
301 : case CT_STRING:
302 881 : return set_string(c[i], v);
303 : case CT_UINT:
304 167 : return set_int(c[i], atoi(v));
305 : case CT_FLOAT:
306 0 : return set_float(c[i], atof(v));
307 : break;
308 : case CT_MODE_T:
309 0 : return set_mode_t(c[i],
310 0 : strtol(v, NULL, 8));
311 : case CT_SSIZE_T:
312 : {
313 3 : uint64_t s=0;
314 : return
315 3 : get_file_size(v, &s, conf_path, line)
316 3 : || set_uint64_t(c[i], s);
317 : }
318 : case CT_E_BURP_MODE:
319 118 : return set_e_burp_mode(c[i],
320 : str_to_burp_mode(v));
321 : case CT_E_RECOVERY_METHOD:
322 1 : return set_e_recovery_method(c[i],
323 : str_to_recovery_method(v));
324 : case CT_STRLIST:
325 482 : if (reset) set_strlist(c[i], 0);
326 482 : return add_to_strlist(c[i], v,
327 482 : !strcmp(c[i]->field, "include"));
328 : case CT_E_RSHASH:
329 : break;
330 : case CT_CNTR:
331 : break;
332 : // No default so we get a warning if something
333 : // was missed;
334 : }
335 : }
336 : }
337 : return 0;
338 : }
339 :
340 : // Recursing, so need to define this ahead of conf_parse_line.
341 : static int conf_load_lines_from_file(const char *conf_path,
342 : struct conf **confs);
343 :
344 0 : static int deal_with_dot_inclusion(const char *conf_path,
345 : char **extrafile, struct conf **confs)
346 : {
347 0 : int ret=-1;
348 0 : char *copy=NULL;
349 : #ifndef HAVE_WIN32
350 0 : int i=0;
351 : glob_t globbuf;
352 0 : if(**extrafile!='/')
353 : #else
354 : if(strlen(*extrafile)>2
355 : && (*extrafile)[1]!=':')
356 : #endif
357 : {
358 : // It is relative to the directory that the
359 : // current conf file is in.
360 0 : char *cp=NULL;
361 0 : char *tmp=NULL;
362 0 : if(!(copy=strdup_w(conf_path, __func__)))
363 : goto end;
364 0 : if((cp=strrchr(copy, '/'))) *cp='\0';
365 0 : if(!(tmp=prepend_s(copy, *extrafile)))
366 : {
367 0 : log_out_of_memory(__func__);
368 0 : goto end;
369 : }
370 0 : free_w(extrafile);
371 0 : *extrafile=tmp;
372 : }
373 : #ifndef HAVE_WIN32
374 : // Treat it is a glob expression.
375 0 : memset(&globbuf, 0, sizeof(globbuf));
376 0 : glob(*extrafile, 0, NULL, &globbuf);
377 0 : for(i=0; (unsigned int)i<globbuf.gl_pathc; i++)
378 0 : if((ret=conf_load_lines_from_file(globbuf.gl_pathv[i], confs)))
379 : goto end;
380 :
381 0 : globfree(&globbuf);
382 : #else
383 : ret=conf_load_lines_from_file(*extrafile, confs);
384 : #endif
385 :
386 : end:
387 0 : free_w(©);
388 0 : return ret;
389 : }
390 :
391 1689 : static int conf_parse_line(struct conf **confs, const char *conf_path,
392 : char buf[], int line)
393 : {
394 1689 : int ret=-1;
395 1689 : int r=0;
396 1689 : char *f=NULL; // field
397 1689 : char *v=NULL; // value
398 1689 : char *extrafile=NULL;
399 :
400 1689 : if(!strncmp(buf, ". ", 2))
401 : {
402 : // The conf file specifies another file to include.
403 0 : char *np=NULL;
404 :
405 0 : if(!(extrafile=strdup_w(buf+2, __func__))) goto end;
406 :
407 0 : if((np=strrchr(extrafile, '\n'))) *np='\0';
408 0 : if(!*extrafile) goto end;
409 :
410 0 : ret=deal_with_dot_inclusion(conf_path, &extrafile, confs);
411 0 : goto end;
412 : }
413 :
414 1689 : if(conf_get_pair(buf, &f, &v, &r)) goto end;
415 1688 : if(f && v
416 1659 : && load_conf_field_and_value(confs, f, v, r, conf_path, line))
417 : goto end;
418 : ret=0;
419 : end:
420 1689 : free_w(&extrafile);
421 1689 : return ret;
422 : }
423 :
424 : static void conf_problem(const char *conf_path, const char *msg, int *r)
425 : {
426 6 : logp("%s: %s\n", conf_path, msg);
427 6 : (*r)--;
428 : }
429 :
430 4 : static void burp_ca_conf_problem(const char *conf_path,
431 : const char *field, int *r)
432 : {
433 4 : char msg[128]="";
434 4 : snprintf(msg, sizeof(msg), "ca_%s_ca set, but %s not set\n",
435 : PACKAGE_TARNAME, field);
436 4 : conf_problem(conf_path, msg, r);
437 4 : }
438 :
439 51 : static int server_conf_checks(struct conf **c, const char *path, int *r)
440 : {
441 : // FIX THIS: Most of this could be done by flags.
442 51 : if(!get_string(c[OPT_DIRECTORY]))
443 : conf_problem(path, "directory unset", r);
444 51 : if(!get_string(c[OPT_DEDUP_GROUP]))
445 : conf_problem(path, "dedup_group unset", r);
446 51 : if(!get_string(c[OPT_CLIENTCONFDIR]))
447 : conf_problem(path, "clientconfdir unset", r);
448 51 : if(get_e_recovery_method(c[OPT_WORKING_DIR_RECOVERY_METHOD])==RECOVERY_METHOD_UNSET)
449 : conf_problem(path, "working_dir_recovery_method unset", r);
450 51 : if(!get_string(c[OPT_SSL_DHFILE]))
451 : conf_problem(path, "ssl_dhfile unset", r);
452 51 : if(get_string(c[OPT_ENCRYPTION_PASSWORD]))
453 : conf_problem(path,
454 : "encryption_password should not be set on the server!", r);
455 51 : if(!get_strlist(c[OPT_KEEP]))
456 : conf_problem(path, "keep unset", r);
457 51 : if(get_int(c[OPT_MAX_HARDLINKS])<2)
458 : conf_problem(path, "max_hardlinks too low", r);
459 :
460 51 : if(get_int(c[OPT_MAX_STORAGE_SUBDIRS])<=1000)
461 : conf_problem(path, "max_storage_subdirs too low", r);
462 51 : if(!get_string(c[OPT_TIMESTAMP_FORMAT])
463 51 : && set_string(c[OPT_TIMESTAMP_FORMAT], DEFAULT_TIMESTAMP_FORMAT))
464 : return -1;
465 51 : if(get_string(c[OPT_CA_CONF]))
466 : {
467 1 : int ca_err=0;
468 1 : const char *ca_name=get_string(c[OPT_CA_NAME]);
469 1 : const char *ca_server_name=get_string(c[OPT_CA_SERVER_NAME]);
470 1 : if(!ca_name)
471 : {
472 0 : logp("ca_conf set, but ca_name not set\n");
473 0 : ca_err++;
474 : }
475 1 : if(!ca_server_name)
476 : {
477 0 : logp("ca_conf set, but ca_server_name not set\n");
478 0 : ca_err++;
479 : }
480 2 : if(ca_name
481 1 : && ca_server_name
482 1 : && !strcmp(ca_name, ca_server_name))
483 : {
484 0 : logp("ca_name and ca_server_name cannot be the same\n");
485 0 : ca_err++;
486 : }
487 1 : if(!get_string(c[OPT_CA_BURP_CA]))
488 : {
489 0 : logp("ca_conf set, but ca_%s_ca not set\n",
490 : PACKAGE_TARNAME);
491 0 : ca_err++;
492 : }
493 1 : if(!get_string(c[OPT_SSL_DHFILE]))
494 : {
495 0 : logp("ca_conf set, but ssl_dhfile not set\n");
496 0 : ca_err++;
497 : }
498 1 : if(!get_string(c[OPT_SSL_CERT_CA]))
499 : {
500 0 : logp("ca_conf set, but ssl_cert_ca not set\n");
501 0 : ca_err++;
502 : }
503 1 : if(!get_string(c[OPT_SSL_CERT]))
504 : {
505 0 : logp("ca_conf set, but ssl_cert not set\n");
506 0 : ca_err++;
507 : }
508 1 : if(!get_string(c[OPT_SSL_KEY]))
509 : {
510 0 : logp("ca_conf set, but ssl_key not set\n");
511 0 : ca_err++;
512 : }
513 1 : if(ca_err) return -1;
514 : }
515 51 : if(get_string(c[OPT_MANUAL_DELETE]))
516 : {
517 0 : if(!is_absolute(get_string(c[OPT_MANUAL_DELETE])))
518 : {
519 0 : logp("ERROR: Please use an absolute manual_delete path.\n");
520 0 : return -1;
521 : }
522 : }
523 :
524 : return 0;
525 : }
526 :
527 : #ifdef HAVE_WIN32
528 : #undef X509_NAME
529 : #include <openssl/x509.h>
530 : #endif
531 :
532 0 : static char *extract_cn(X509_NAME *subj)
533 : {
534 : int nid;
535 : int index;
536 : ASN1_STRING *d;
537 : X509_NAME_ENTRY *e;
538 :
539 0 : nid=OBJ_txt2nid("CN");
540 0 : if((index=X509_NAME_get_index_by_NID(subj, nid, -1))<0
541 0 : || !(e=X509_NAME_get_entry(subj, index))
542 0 : || !(d=X509_NAME_ENTRY_get_data(e)))
543 : return NULL;
544 : #if OPENSSL_VERSION_NUMBER < 0x1010000fL || defined(LIBRESSL_VERSION_NUMBER)
545 : return (char *)ASN1_STRING_data(d);
546 : #else
547 0 : return (char *)ASN1_STRING_get0_data(d);
548 : #endif
549 : }
550 :
551 48 : static void mangle_cname(char **cname, struct conf **c)
552 : {
553 48 : if(!get_int(c[OPT_CNAME_FQDN]))
554 0 : strip_fqdn(cname);
555 48 : if(get_int(c[OPT_CNAME_LOWERCASE]))
556 0 : strlwr(*cname);
557 48 : }
558 :
559 48 : static int get_cname_from_ssl_cert(struct conf **c)
560 : {
561 48 : int ret=-1;
562 48 : struct fzp *fzp=NULL;
563 48 : X509 *cert=NULL;
564 48 : X509_NAME *subj=NULL;
565 48 : char *path=get_string(c[OPT_SSL_CERT]);
566 48 : const char *cn=NULL;
567 48 : char *copy=NULL;
568 :
569 48 : if(!path || !(fzp=fzp_open(path, "rb"))) return 0;
570 :
571 0 : if(!(cert=fzp_PEM_read_X509(fzp)))
572 : {
573 0 : logp("unable to parse %s in: %s\n", path, __func__);
574 0 : goto end;
575 : }
576 0 : if(!(subj=X509_get_subject_name(cert)))
577 : {
578 0 : logp("unable to get subject from %s in: %s\n", path, __func__);
579 0 : goto end;
580 : }
581 :
582 0 : if(!(cn=extract_cn(subj)))
583 : {
584 0 : logp("could not get CN from %s\n", path);
585 0 : goto end;
586 : }
587 0 : if(!(copy=strdup_w(cn, __func__)))
588 : goto end;
589 0 : mangle_cname(©, c);
590 0 : if(set_string(c[OPT_CNAME], copy))
591 : goto end;
592 0 : logp("cname from cert: %s\n", cn);
593 0 : if(strcmp(copy, cn))
594 0 : logp("cname mangled to: %s\n", copy);
595 :
596 : ret=0;
597 : end:
598 0 : if(cert) X509_free(cert);
599 0 : fzp_close(&fzp);
600 0 : free_w(©);
601 0 : return ret;
602 : }
603 :
604 : #ifdef HAVE_WIN32
605 : #include <winsock2.h>
606 : #include <ws2tcpip.h>
607 : #endif
608 :
609 48 : static int get_fqdn(struct conf **c)
610 : {
611 48 : int ret=-1;
612 : int gai_result;
613 : struct addrinfo hints;
614 48 : struct addrinfo *info=NULL;
615 48 : char hostname[1024]="";
616 48 : char *fqdn=NULL;
617 48 : hostname[1023] = '\0';
618 48 : if(gethostname(hostname, 1023))
619 : {
620 0 : logp("gethostname() failed: %s\n", strerror(errno));
621 0 : goto end;
622 : }
623 :
624 48 : memset(&hints, 0, sizeof hints);
625 : hints.ai_family=AF_UNSPEC;
626 48 : hints.ai_socktype=SOCK_STREAM;
627 48 : hints.ai_flags=AI_CANONNAME;
628 :
629 48 : if((gai_result=getaddrinfo(hostname, NULL, &hints, &info)))
630 : {
631 0 : logp("getaddrinfo in %s: %s\n", __func__,
632 : gai_strerror(gai_result));
633 0 : logp("Using %s\n", hostname);
634 0 : if(!(fqdn=strdup_w(hostname, __func__)))
635 : goto end;
636 : }
637 : else
638 : {
639 : //for(p=info; p; p=p->ai_next)
640 : // Just use the first one.
641 48 : if(!info)
642 : {
643 0 : logp("Got no hostname in %s\n", __func__);
644 0 : goto end;
645 : }
646 48 : if(!(fqdn=strdup_w(info->ai_canonname, __func__)))
647 : goto end;
648 : }
649 :
650 48 : mangle_cname(&fqdn, c);
651 :
652 48 : if(set_string(c[OPT_CNAME], fqdn))
653 : goto end;
654 48 : logp("cname from hostname: %s\n", get_string(c[OPT_CNAME]));
655 :
656 48 : ret=0;
657 : end:
658 48 : if(info) freeaddrinfo(info);
659 48 : free_w(&fqdn);
660 48 : return ret;
661 : }
662 :
663 99 : const char *confs_get_lockfile(struct conf **confs)
664 : {
665 99 : const char *lockfile=get_string(confs[OPT_LOCKFILE]);
666 99 : if(!lockfile) lockfile=get_string(confs[OPT_PIDFILE]);
667 99 : return lockfile;
668 : }
669 :
670 99 : static int general_conf_checks(struct conf **c, const char *path, int *r)
671 : {
672 99 : if(!confs_get_lockfile(c))
673 : conf_problem(path, "lockfile unset", r);
674 99 : if(!get_string(c[OPT_SSL_CERT]))
675 : conf_problem(path, "ssl_cert unset", r);
676 99 : if(!get_string(c[OPT_SSL_CERT_CA]))
677 : conf_problem(path, "ssl_cert_ca unset", r);
678 99 : return 0;
679 : }
680 :
681 48 : static int client_conf_checks(struct conf **c, const char *path, int *r)
682 : {
683 48 : int ret=-1;
684 48 : char *copy=NULL;
685 48 : const char *autoupgrade_os=get_string(c[OPT_AUTOUPGRADE_OS]);
686 :
687 48 : if(!get_string(c[OPT_CNAME]))
688 : {
689 48 : if(get_cname_from_ssl_cert(c))
690 : goto end;
691 : // There was no error. This is probably a new install.
692 : // Try getting the fqdn and using that.
693 48 : if(!get_string(c[OPT_CNAME]))
694 : {
695 48 : if(get_fqdn(c))
696 : goto end;
697 48 : if(!get_string(c[OPT_CNAME]))
698 : conf_problem(path, "client name unset", r);
699 : }
700 : }
701 48 : if(!get_string(c[OPT_PASSWORD]))
702 : {
703 48 : logp("password not set, falling back to \"password\"\n");
704 48 : if(set_string(c[OPT_PASSWORD], "password"))
705 : goto end;
706 : }
707 48 : if(!get_string(c[OPT_SERVER]))
708 : conf_problem(path, "server unset", r);
709 48 : if(!get_string(c[OPT_SSL_PEER_CN]))
710 : {
711 1 : const char *server=get_string(c[OPT_SERVER]);
712 1 : logp("ssl_peer_cn unset\n");
713 1 : if(server)
714 : {
715 1 : char *cp=NULL;
716 1 : if(!(copy=strdup_w(server, __func__)))
717 : goto end;
718 :
719 1 : if((cp=strchr(copy, ':')))
720 0 : *cp='\0';
721 1 : logp("falling back to '%s'\n", copy);
722 1 : if(set_string(c[OPT_SSL_PEER_CN], copy))
723 : goto end;
724 : }
725 : }
726 48 : if(autoupgrade_os
727 0 : && strstr(autoupgrade_os, ".."))
728 : conf_problem(path,
729 : "autoupgrade_os must not contain a '..' component", r);
730 48 : if(get_string(c[OPT_CA_BURP_CA]))
731 : {
732 1 : if(!get_string(c[OPT_CA_CSR_DIR]))
733 1 : burp_ca_conf_problem(path, "ca_csr_dir", r);
734 1 : if(!get_string(c[OPT_SSL_CERT_CA]))
735 1 : burp_ca_conf_problem(path, "ssl_cert_ca", r);
736 1 : if(!get_string(c[OPT_SSL_CERT]))
737 1 : burp_ca_conf_problem(path, "ssl_cert", r);
738 1 : if(!get_string(c[OPT_SSL_KEY]))
739 1 : burp_ca_conf_problem(path, "ssl_key", r);
740 : }
741 :
742 48 : if(!r)
743 : {
744 : struct strlist *l;
745 0 : logp("Listing configured paths:\n");
746 0 : for(l=get_strlist(c[OPT_INCEXCDIR]); l; l=l->next)
747 0 : logp("%s: %s\n", l->flag?"include":"exclude", l->path);
748 0 : logp("Listing starting paths:\n");
749 0 : for(l=get_strlist(c[OPT_STARTDIR]); l; l=l->next)
750 0 : if(l->flag) logp("%s\n", l->path);
751 : }
752 :
753 : ret=0;
754 : end:
755 48 : free_w(©);
756 48 : return ret;
757 : }
758 :
759 177 : static int finalise_keep_args(struct conf **c)
760 : {
761 : struct strlist *k;
762 177 : struct strlist *last=NULL;
763 177 : uint64_t mult=1;
764 294 : for(k=get_strlist(c[OPT_KEEP]); k; k=k->next)
765 : {
766 234 : if(!(k->flag=atoi(k->path)))
767 : {
768 0 : logp("'keep' value cannot be set to '%s'\n", k->path);
769 0 : return -1;
770 : }
771 117 : mult*=k->flag;
772 :
773 : // An error if you try to keep backups every second
774 : // for 100 years.
775 117 : if(mult>52560000)
776 : {
777 0 : logp("Your 'keep' values are far too high. High enough to keep a backup every second for 10 years. Please lower them to something sensible.\n");
778 0 : return -1;
779 : }
780 117 : last=k;
781 : }
782 : // If more than one keep value is set, add one to the last one.
783 : // This is so that, for example, having set 7, 4, 6, then
784 : // a backup of age 7*4*6=168 or more is guaranteed to be kept.
785 : // Otherwise, only 7*4*5=140 would be guaranteed to be kept.
786 177 : k=get_strlist(c[OPT_KEEP]);
787 177 : if(k && k->next) last->flag++;
788 : return 0;
789 : }
790 :
791 48 : static int incexc_munge(struct conf **c, struct strlist *s)
792 : {
793 : #ifdef HAVE_WIN32
794 : convert_backslashes(&s->path);
795 : #endif
796 48 : if(!is_absolute(s->path))
797 : {
798 1 : logp("ERROR: Please use absolute include/exclude paths: %s\n",
799 : s->path);
800 : return -1;
801 : }
802 47 : if(add_to_strlist_sorted_uniq(c[OPT_INCEXCDIR], s->path, s->flag))
803 : return -1;
804 : return 0;
805 : }
806 :
807 359 : static const char *sanity_check_no_dupes(struct strlist *sl)
808 : {
809 359 : struct strlist *s=NULL;
810 359 : struct strlist *prev=NULL;
811 :
812 436 : for(s=sl; s; s=s->next)
813 : {
814 78 : if(!prev)
815 : {
816 49 : prev=s;
817 49 : continue;
818 : }
819 29 : if(!strcmp(s->path, prev->path))
820 : {
821 : return s->path;
822 : }
823 : prev=s;
824 : }
825 : return NULL;
826 : }
827 :
828 181 : static int finalise_incexc_dirs(struct conf **c)
829 : {
830 181 : const char *dupe=NULL;
831 181 : struct strlist *s=NULL;
832 :
833 222 : for(s=get_strlist(c[OPT_INCLUDE]); s; s=s->next)
834 42 : if(incexc_munge(c, s)) return -1;
835 186 : for(s=get_strlist(c[OPT_EXCLUDE]); s; s=s->next)
836 6 : if(incexc_munge(c, s)) return -1;
837 181 : if(get_strlist(c[OPT_INCREG]) &&
838 1 : !(get_strlist(c[OPT_INCLUDE]) || get_strlist(c[OPT_INCGLOB])))
839 : {
840 0 : logp("Need at least one 'include' or 'include_glob' for the 'include_regex' to work.\n");
841 0 : return -1;
842 : }
843 :
844 180 : if((dupe=sanity_check_no_dupes(get_strlist(c[OPT_INCEXCDIR])))) {
845 1 : logp("ERROR: Duplicate include/exclude path: %s\n", dupe);
846 1 : return -1;
847 : }
848 :
849 : return 0;
850 : }
851 :
852 6 : static int add_to_cross_filesystem(struct conf **c, const char *path)
853 : {
854 6 : if(strlist_find(get_strlist(c[OPT_FSCHGDIR]), path, 0))
855 : return 0;
856 6 : return add_to_strlist(c[OPT_FSCHGDIR], path, 0);
857 : }
858 :
859 179 : static int check_start_dirs_and_seed(struct conf **c)
860 : {
861 179 : int errors=0;
862 179 : struct strlist *s=NULL;
863 179 : const char *src=get_string(c[OPT_SEED_SRC]);
864 179 : if(!src)
865 : return 0;
866 :
867 0 : for(s=get_strlist(c[OPT_STARTDIR]); s; s=s->next)
868 : {
869 0 : if(!is_subdir(src, s->path))
870 : {
871 0 : logp("ERROR: Starting directories need to be within %s:%s: %s\n",
872 0 : c[OPT_SEED_SRC]->field, src, s->path);
873 0 : errors++;
874 : }
875 : }
876 :
877 : return errors;
878 : }
879 :
880 : // This decides which directories to start backing up, and which
881 : // are subdirectories which don't need to be started separately.
882 179 : static int finalise_start_dirs(struct conf **c)
883 : {
884 179 : struct strlist *s=NULL;
885 179 : struct strlist *last_sd=NULL;
886 179 : const char *dupe=NULL;
887 :
888 : // Make sure that the startdir list starts empty, or chaos will ensue.
889 179 : conf_free_content(c[OPT_STARTDIR]);
890 :
891 217 : for(s=get_strlist(c[OPT_INCLUDE]); s; s=s->next)
892 : {
893 : #ifdef HAVE_WIN32
894 : convert_backslashes(&s->path);
895 : #endif
896 38 : if(!is_absolute(s->path))
897 : {
898 0 : logp("ERROR: Please use absolute include/exclude paths.\n");
899 0 : return -1;
900 : }
901 :
902 : // If it is not a subdirectory of the most recent start point,
903 : // we have found another start point.
904 38 : if(!get_strlist(c[OPT_STARTDIR])
905 14 : || !last_sd || !is_subdir(last_sd->path, s->path))
906 : {
907 : // Do not use strlist_add_sorted, because last_sd is
908 : // relying on incexcdir already being sorted.
909 32 : if(add_to_strlist(c[OPT_STARTDIR], s->path, s->flag))
910 : return -1;
911 : last_sd=s;
912 : }
913 : else
914 : {
915 : // If it is not a starting directory, it should at
916 : // least be included as a cross_filesystem entry.
917 6 : if(add_to_cross_filesystem(c, s->path))
918 : return -1;
919 : }
920 : }
921 :
922 179 : if((dupe=sanity_check_no_dupes(get_strlist(c[OPT_STARTDIR])))) {
923 0 : logp("ERROR: Directory appears twice in conf: %s\n", dupe);
924 0 : return -1;
925 : }
926 :
927 179 : if(check_start_dirs_and_seed(c))
928 : return -1;
929 :
930 179 : return 0;
931 : }
932 :
933 179 : static int finalise_fschg_dirs(struct conf **c)
934 : {
935 : struct strlist *s;
936 187 : for(s=get_strlist(c[OPT_FSCHGDIR]); s; s=s->next)
937 8 : strip_trailing_slashes(&s->path);
938 179 : return 0;
939 : }
940 :
941 : #ifdef HAVE_WIN32
942 : static void finalise_remote_drives(struct conf **c) {
943 : char *drives=NULL;
944 : if((drives=get_string(c[OPT_REMOTE_DRIVES])) && *drives) {
945 : logp("remote drives configured: %s\n", drives);
946 : return;
947 : }
948 : if((drives=get_remote_drives()) && *drives) {
949 : logp("remote drives detected: %s\n", drives);
950 : set_string(c[OPT_REMOTE_DRIVES], drives);
951 : }
952 : }
953 : #endif
954 :
955 : // The glob stuff should only run on the client side.
956 52 : static int finalise_glob(struct conf **c)
957 : {
958 52 : int ret=-1;
959 : #ifdef HAVE_WIN32
960 : if(glob_windows(c)) goto end;
961 : #else
962 : int i;
963 : glob_t globbuf;
964 : struct strlist *l;
965 52 : struct strlist *last=NULL;
966 52 : memset(&globbuf, 0, sizeof(globbuf));
967 55 : for(l=get_strlist(c[OPT_INCGLOB]); l; l=l->next)
968 : {
969 3 : glob(l->path, last?GLOB_APPEND:0, NULL, &globbuf);
970 3 : last=l;
971 : }
972 :
973 3 : for(i=0; (unsigned int)i<globbuf.gl_pathc; i++)
974 3 : if(add_to_strlist_sorted_uniq(c[OPT_INCLUDE], globbuf.gl_pathv[i], 1/*flag*/))
975 : goto end;
976 :
977 52 : globfree(&globbuf);
978 : #endif
979 52 : ret=0;
980 : end:
981 52 : return ret;
982 : }
983 :
984 : // Reeval the glob after script pre
985 2 : int reeval_glob(struct conf **c)
986 : {
987 2 : if(finalise_glob(c))
988 : return -1;
989 :
990 2 : if(finalise_incexc_dirs(c)
991 2 : || finalise_start_dirs(c)
992 2 : || finalise_fschg_dirs(c))
993 : return -1;
994 :
995 : return 0;
996 : }
997 :
998 : // Set the flag of the first item in a list that looks at extensions to the
999 : // maximum number of characters that need to be checked, plus one. This is for
1000 : // a bit of added efficiency.
1001 537 : static void set_max_ext(struct strlist *list)
1002 : {
1003 537 : int max=0;
1004 537 : struct strlist *l=NULL;
1005 541 : for(l=list; l; l=l->next)
1006 : {
1007 4 : int s=strlen(l->path);
1008 4 : if(s>max) max=s;
1009 : }
1010 537 : if(list) list->flag=max+1;
1011 537 : }
1012 :
1013 358 : static int finalise_fstypes(struct conf **c, int opt)
1014 : {
1015 : struct strlist *l;
1016 : // Set the strlist flag for the excluded fstypes
1017 358 : for(l=get_strlist(c[opt]); l; l=l->next)
1018 : {
1019 0 : l->flag=0;
1020 0 : if(!strncasecmp(l->path, "0x", 2))
1021 : {
1022 0 : l->flag=strtol((l->path)+2, NULL, 16);
1023 0 : logp("Excluding file system type 0x%08lX\n", l->flag);
1024 : }
1025 : else
1026 : {
1027 0 : if(fstype_to_flag(l->path, &(l->flag)))
1028 : {
1029 0 : logp("Unknown exclude fs type: %s\n", l->path);
1030 0 : l->flag=0;
1031 : }
1032 : }
1033 : }
1034 358 : return 0;
1035 : }
1036 :
1037 10 : static int setup_script_arg_override(struct conf *c, struct conf *args)
1038 : {
1039 : struct strlist *s;
1040 10 : set_strlist(args, NULL);
1041 30 : for(s=get_strlist(c); s; s=s->next)
1042 20 : if(add_to_strlist(args, s->path, s->flag))
1043 : return -1;
1044 : return 0;
1045 : }
1046 :
1047 528 : static int setup_script_arg_overrides(struct conf *c,
1048 : struct conf *pre_args, struct conf *post_args)
1049 : {
1050 528 : if(!get_strlist(c)) return 0;
1051 5 : return setup_script_arg_override(c, pre_args)
1052 5 : || setup_script_arg_override(c, post_args);
1053 : }
1054 :
1055 139 : static int listen_config_ok(const char *l)
1056 : {
1057 : int port;
1058 139 : const char *c=NULL;
1059 139 : const char *cp=NULL;
1060 :
1061 1875 : for(c=l; *c; c++)
1062 1736 : if(!isalnum(*c) && *c!=':' && *c!='.')
1063 : return 0;
1064 :
1065 139 : if(!(cp=strrchr(l, ':')))
1066 : return 0;
1067 139 : if(l==cp)
1068 : return 0;
1069 139 : cp++;
1070 139 : if(!strlen(cp) || strlen(cp)>5)
1071 : return 0;
1072 139 : port=atoi(cp);
1073 139 : if(port<=0 || port>65535)
1074 : return 0;
1075 :
1076 139 : return 1;
1077 : }
1078 :
1079 134 : static int finalise_server_max_children(struct conf **c,
1080 : enum conf_opt listen_opt, enum conf_opt max_children_opt)
1081 : {
1082 : struct strlist *l;
1083 : struct strlist *mc;
1084 134 : long max_children=5;
1085 :
1086 541 : for(l=get_strlist(c[listen_opt]),
1087 273 : mc=get_strlist(c[max_children_opt]); l; l=l->next)
1088 : {
1089 139 : if(!listen_config_ok(l->path))
1090 : {
1091 0 : logp("Could not parse %s config '%s'\n",
1092 0 : c[listen_opt]->field, l->path);
1093 0 : return -1;
1094 : }
1095 139 : if(mc)
1096 : {
1097 20 : if((max_children=atol(mc->path))<=0)
1098 : {
1099 0 : logp("%s too low for %s %s\n",
1100 0 : c[max_children_opt]->field,
1101 0 : c[listen_opt]->field,
1102 : l->path);
1103 0 : return -1;
1104 : }
1105 10 : l->flag=max_children;
1106 :
1107 10 : mc=mc->next;
1108 : }
1109 : else
1110 : {
1111 258 : logp("%s %s defaulting to %s %lu\n",
1112 129 : c[listen_opt]->field,
1113 : l->path,
1114 129 : c[max_children_opt]->field,
1115 : max_children);
1116 129 : l->flag=max_children;
1117 : }
1118 : }
1119 :
1120 134 : if(mc)
1121 : {
1122 0 : logp("too many %s options\n", c[max_children_opt]->field);
1123 0 : return -1;
1124 : }
1125 :
1126 : return 0;
1127 : }
1128 :
1129 48 : static int finalise_client_ports(struct conf **c)
1130 : {
1131 48 : int port=0;
1132 : struct strlist *p;
1133 :
1134 95 : for(p=get_strlist(c[OPT_PORT]); p; p=p->next)
1135 94 : port=atoi(p->path);
1136 :
1137 48 : if(!port)
1138 : return 0;
1139 :
1140 47 : if(!get_int(c[OPT_PORT_BACKUP]))
1141 46 : set_int(c[OPT_PORT_BACKUP], port);
1142 47 : if(!get_int(c[OPT_PORT_RESTORE]))
1143 45 : set_int(c[OPT_PORT_RESTORE], port);
1144 47 : if(!get_int(c[OPT_PORT_VERIFY]))
1145 46 : set_int(c[OPT_PORT_VERIFY], get_int(c[OPT_PORT_RESTORE]));
1146 47 : if(!get_int(c[OPT_PORT_LIST]))
1147 46 : set_int(c[OPT_PORT_LIST], port);
1148 47 : if(!get_int(c[OPT_PORT_DELETE]))
1149 46 : set_int(c[OPT_PORT_DELETE], port);
1150 :
1151 : return 0;
1152 : }
1153 :
1154 179 : static int apply_cli_overrides(struct conf **confs)
1155 : {
1156 179 : int ret=-1;
1157 179 : int line=0;
1158 179 : char *opt=NULL;
1159 179 : struct strlist *oo=NULL;
1160 :
1161 179 : for(oo=cli_overrides; oo; oo=oo->next)
1162 : {
1163 0 : line++;
1164 0 : free_w(&opt);
1165 0 : if(!(opt=strdup_w(oo->path, __func__)))
1166 : goto end;
1167 0 : if((ret=conf_parse_line(confs, "", opt, line)))
1168 : {
1169 0 : logp("Unable to parse cli option %d '%s'\n",
1170 : line, oo->path);
1171 0 : goto end;
1172 : }
1173 : }
1174 : ret=0;
1175 : end:
1176 179 : free_w(&opt);
1177 179 : return ret;
1178 : }
1179 :
1180 179 : static int conf_finalise(struct conf **c)
1181 : {
1182 : enum burp_mode burp_mode;
1183 179 : int s_script_notify=0;
1184 :
1185 179 : if(apply_cli_overrides(c))
1186 : return -1;
1187 :
1188 179 : burp_mode=get_e_burp_mode(c[OPT_BURP_MODE]);
1189 :
1190 179 : if(finalise_fstypes(c, OPT_EXCFS)
1191 179 : || finalise_fstypes(c, OPT_INCFS))
1192 : return -1;
1193 :
1194 179 : strlist_compile_regexes(get_strlist(c[OPT_INCREG]));
1195 179 : strlist_compile_regexes(get_strlist(c[OPT_EXCREG]));
1196 :
1197 179 : set_max_ext(get_strlist(c[OPT_INCEXT]));
1198 179 : set_max_ext(get_strlist(c[OPT_EXCEXT]));
1199 179 : set_max_ext(get_strlist(c[OPT_EXCOM]));
1200 :
1201 179 : if(burp_mode==BURP_MODE_CLIENT
1202 50 : && finalise_glob(c))
1203 : return -1;
1204 : #ifdef HAVE_WIN32
1205 : finalise_remote_drives(c);
1206 : #endif
1207 :
1208 179 : if(finalise_incexc_dirs(c)
1209 177 : || finalise_start_dirs(c)
1210 177 : || finalise_fschg_dirs(c))
1211 : return -1;
1212 :
1213 177 : if(finalise_keep_args(c))
1214 : return -1;
1215 :
1216 177 : if(burp_mode==BURP_MODE_SERVER)
1217 : {
1218 68 : if(!get_strlist(c[OPT_LISTEN]))
1219 : {
1220 1 : logp("Need at least one 'listen' config.\n");
1221 1 : return -1;
1222 : }
1223 67 : if(finalise_server_max_children(c,
1224 : OPT_LISTEN, OPT_MAX_CHILDREN)
1225 67 : || finalise_server_max_children(c,
1226 : OPT_LISTEN_STATUS, OPT_MAX_STATUS_CHILDREN))
1227 : return -1;
1228 : }
1229 176 : if(burp_mode==BURP_MODE_CLIENT)
1230 : {
1231 48 : if(finalise_client_ports(c))
1232 : return -1;
1233 : }
1234 :
1235 176 : if((s_script_notify=get_int(c[OPT_S_SCRIPT_NOTIFY])))
1236 : {
1237 4 : set_int(c[OPT_S_SCRIPT_PRE_NOTIFY], s_script_notify);
1238 4 : set_int(c[OPT_S_SCRIPT_POST_NOTIFY], s_script_notify);
1239 : }
1240 :
1241 : // These override the specific pre/post script paths with the general
1242 : // one. For example, if 'server_script' is set, its value is used for
1243 : // 'server_script_pre' and 'server_script_post'.
1244 176 : if(pre_post_override(c[OPT_B_SCRIPT],
1245 : c[OPT_B_SCRIPT_PRE], c[OPT_B_SCRIPT_POST])
1246 176 : || pre_post_override(c[OPT_R_SCRIPT],
1247 : c[OPT_R_SCRIPT_PRE], c[OPT_R_SCRIPT_POST])
1248 176 : || pre_post_override(c[OPT_S_SCRIPT],
1249 : c[OPT_S_SCRIPT_PRE], c[OPT_S_SCRIPT_POST])
1250 : // And these do the same for the script arguments.
1251 176 : || setup_script_arg_overrides(c[OPT_B_SCRIPT_ARG],
1252 : c[OPT_B_SCRIPT_PRE_ARG], c[OPT_B_SCRIPT_POST_ARG])
1253 176 : || setup_script_arg_overrides(c[OPT_R_SCRIPT_ARG],
1254 : c[OPT_R_SCRIPT_PRE_ARG], c[OPT_R_SCRIPT_POST_ARG])
1255 176 : || setup_script_arg_overrides(c[OPT_S_SCRIPT_ARG],
1256 : c[OPT_S_SCRIPT_PRE_ARG], c[OPT_S_SCRIPT_POST_ARG]))
1257 : return -1;
1258 :
1259 : // We are now done with these. Clear them, otherwise they interfere.
1260 176 : set_string(c[OPT_S_SCRIPT], NULL);
1261 176 : set_strlist(c[OPT_S_SCRIPT_ARG], NULL);
1262 176 : return 0;
1263 : }
1264 :
1265 99 : static int conf_finalise_global_only(const char *conf_path, struct conf **confs)
1266 : {
1267 99 : int r=0;
1268 :
1269 : // Let the caller check the 'keep' value.
1270 :
1271 99 : if(!get_string(confs[OPT_SSL_KEY_PASSWORD])
1272 99 : && set_string(confs[OPT_SSL_KEY_PASSWORD], ""))
1273 0 : r--;
1274 :
1275 99 : if(general_conf_checks(confs, conf_path, &r)) r--;
1276 :
1277 99 : switch(get_e_burp_mode(confs[OPT_BURP_MODE]))
1278 : {
1279 : case BURP_MODE_SERVER:
1280 51 : if(server_conf_checks(confs, conf_path, &r)) r--;
1281 : break;
1282 : case BURP_MODE_CLIENT:
1283 48 : if(client_conf_checks(confs, conf_path, &r)) r--;
1284 : break;
1285 : case BURP_MODE_UNSET:
1286 : default:
1287 0 : logp("%s: mode unset - need 'server' or 'client'\n",
1288 : conf_path);
1289 0 : r--;
1290 0 : break;
1291 : }
1292 :
1293 99 : return r;
1294 : }
1295 :
1296 180 : static int conf_load_lines_from_file(const char *conf_path, struct conf **confs)
1297 : {
1298 180 : int ret=0;
1299 180 : int line=0;
1300 180 : FILE *fp=NULL;
1301 180 : char buf[4096]="";
1302 :
1303 180 : if(!(fp=fopen(conf_path, "r")))
1304 : {
1305 3 : logp("could not open '%s' for reading.\n", conf_path);
1306 3 : return -1;
1307 : }
1308 1858 : while(fgets(buf, sizeof(buf), fp))
1309 : {
1310 1681 : line++;
1311 1681 : if(conf_parse_line(confs, conf_path, buf, line))
1312 : {
1313 1 : conf_error(conf_path, line);
1314 1 : ret=-1;
1315 : }
1316 : }
1317 177 : if(fp) fclose(fp);
1318 177 : return ret;
1319 : }
1320 :
1321 : #ifndef UTEST
1322 : static
1323 : #endif
1324 3 : int conf_load_lines_from_buf(const char *buf, struct conf **c)
1325 : {
1326 3 : int ret=0;
1327 3 : int line=0;
1328 3 : char *tok=NULL;
1329 3 : char *copy=NULL;
1330 :
1331 3 : if(!buf) return 0;
1332 :
1333 3 : if(!(copy=strdup_w(buf, __func__))) return -1;
1334 3 : if(!(tok=strtok(copy, "\n")))
1335 : {
1336 0 : logp("unable to parse conf buffer\n");
1337 0 : free_w(©);
1338 0 : return -1;
1339 : }
1340 : do
1341 : {
1342 8 : line++;
1343 8 : if(conf_parse_line(c, "", tok, line))
1344 : {
1345 : ret=-1;
1346 : break;
1347 : }
1348 8 : } while((tok=strtok(NULL, "\n")));
1349 3 : free_w(©);
1350 :
1351 3 : return ret;
1352 : }
1353 :
1354 : /* The server runs this when parsing a restore file on the server. Called
1355 : elsewhere too. */
1356 6 : int conf_parse_incexcs_path(struct conf **c, const char *path)
1357 : {
1358 6 : free_incexcs(c);
1359 6 : if(conf_load_lines_from_file(path, c)
1360 6 : || conf_finalise(c))
1361 : return -1;
1362 : return 0;
1363 : }
1364 :
1365 : /* The client runs this when the server overrides the incexcs. */
1366 1 : int conf_parse_incexcs_buf(struct conf **c, const char *incexc)
1367 : {
1368 1 : free_incexcs(c);
1369 1 : if(conf_load_lines_from_buf(incexc, c)
1370 1 : || conf_finalise(c))
1371 : return -1;
1372 : return 0;
1373 : }
1374 :
1375 : /* The client runs this when the server overrides the incexcs for restore. */
1376 4 : int conf_parse_incexcs_srestore(struct conf **c, const char *incexc)
1377 : {
1378 4 : int ret=-1;
1379 4 : char *rp=NULL;
1380 4 : char *oldprefix=NULL;
1381 4 : char *srvprefix=NULL;
1382 4 : char *newprefix=NULL;
1383 4 : const char *rpfield=c[OPT_RESTOREPREFIX]->field;
1384 :
1385 4 : if(!(rp=get_string(c[OPT_RESTOREPREFIX])))
1386 : {
1387 2 : logp("The client side must specify a %s!\n", rpfield);
1388 2 : goto end;
1389 : }
1390 2 : if(!(oldprefix=strdup_w(rp, __func__)))
1391 : goto end;
1392 :
1393 2 : free_incexcs(c);
1394 2 : set_string(c[OPT_RESTOREPREFIX], NULL);
1395 2 : if(conf_load_lines_from_buf(incexc, c)
1396 2 : || conf_finalise(c))
1397 : goto end;
1398 :
1399 2 : if((srvprefix=get_string(c[OPT_RESTOREPREFIX])))
1400 : {
1401 0 : if(has_dot_component(srvprefix))
1402 : {
1403 0 : logp("The server gave %s '%s', which is not allowed!",
1404 : rpfield, srvprefix);
1405 0 : goto end;
1406 : }
1407 0 : if(!strcmp(oldprefix, "/"))
1408 : {
1409 : // Avoid double slash.
1410 0 : if(!(newprefix=prepend_s("", srvprefix)))
1411 : goto end;
1412 : }
1413 : else
1414 : {
1415 0 : if(!(newprefix=prepend_s(oldprefix, srvprefix)))
1416 : goto end;
1417 : }
1418 0 : if(set_string(c[OPT_RESTOREPREFIX], newprefix))
1419 : goto end;
1420 0 : if(build_path_w(newprefix))
1421 : goto end;
1422 : }
1423 : else
1424 : {
1425 2 : if(set_string(c[OPT_RESTOREPREFIX], oldprefix))
1426 : goto end;
1427 : }
1428 : ret=0;
1429 : end:
1430 4 : free_w(&oldprefix);
1431 4 : free_w(&newprefix);
1432 4 : return ret;
1433 : }
1434 :
1435 72 : static int conf_set_from_global(struct conf **globalc, struct conf **cc)
1436 : {
1437 72 : int i=0;
1438 13896 : for(i=0; i<OPT_MAX; i++)
1439 : {
1440 13824 : if(!(cc[i]->flags & CONF_FLAG_CC_OVERRIDE))
1441 8856 : continue;
1442 4968 : switch(cc[i]->conf_type)
1443 : {
1444 : case CT_STRING:
1445 1080 : set_string(cc[i], get_string(globalc[i]));
1446 1080 : break;
1447 : case CT_UINT:
1448 2520 : set_int(cc[i], get_int(globalc[i]));
1449 2520 : break;
1450 : case CT_FLOAT:
1451 0 : set_float(cc[i], get_float(globalc[i]));
1452 0 : break;
1453 : case CT_MODE_T:
1454 0 : set_mode_t(cc[i], get_mode_t(globalc[i]));
1455 0 : break;
1456 : case CT_SSIZE_T:
1457 360 : set_uint64_t(cc[i], get_uint64_t(globalc[i]));
1458 360 : break;
1459 : case CT_E_BURP_MODE:
1460 0 : set_e_burp_mode(cc[i], get_e_burp_mode(globalc[i]));
1461 0 : break;
1462 : case CT_E_RECOVERY_METHOD:
1463 72 : set_e_recovery_method(cc[i], get_e_recovery_method(globalc[i]));
1464 72 : break;
1465 : case CT_E_RSHASH:
1466 72 : set_e_rshash(cc[i], get_e_rshash(globalc[i]));
1467 72 : break;
1468 : case CT_STRLIST:
1469 : // Done later.
1470 : break;
1471 : case CT_CNTR:
1472 : break;
1473 : // No default so that there are warnings if anything
1474 : // was missed.
1475 : }
1476 : }
1477 :
1478 : // If ssl_peer_cn is not set, default it to the client name.
1479 72 : if(!get_string(globalc[OPT_SSL_PEER_CN])
1480 61 : && set_string(cc[OPT_SSL_PEER_CN], get_string(cc[OPT_CNAME])))
1481 : return -1;
1482 :
1483 : return 0;
1484 : }
1485 :
1486 918 : static int append_strlist(struct conf *dst, struct conf *src)
1487 : {
1488 : struct strlist *s;
1489 1016 : for(s=get_strlist(src); s; s=s->next)
1490 98 : if(add_to_strlist(dst, s->path, s->flag))
1491 : return -1;
1492 : return 0;
1493 : }
1494 :
1495 : // Instead of adding onto the end of the list, this replaces the list.
1496 68 : static int conf_set_from_global_arg_list_overrides(struct conf **globalc,
1497 : struct conf **cc)
1498 : {
1499 68 : int i=0;
1500 13124 : for(i=0; i<OPT_MAX; i++)
1501 : {
1502 13056 : if(cc[i]->conf_type!=CT_STRLIST) continue;
1503 2924 : if(!(cc[i]->flags & CONF_FLAG_CC_OVERRIDE)) continue;
1504 816 : if(cc[i]->flags & CONF_FLAG_STRLIST_REPLACE)
1505 : {
1506 : // If there was no cc[i] strlist set, use the global.
1507 680 : if(!get_strlist(cc[i])
1508 646 : && append_strlist(cc[i], globalc[i]))
1509 : return -1;
1510 : }
1511 : else
1512 : {
1513 : struct conf tmpconf;
1514 : // A bit painful.
1515 136 : tmpconf.conf_type=cc[i]->conf_type;
1516 136 : tmpconf.flags=cc[i]->flags;
1517 136 : memset(&tmpconf.data, 0, sizeof(tmpconf.data));
1518 136 : if(append_strlist(&tmpconf, globalc[i])
1519 136 : || append_strlist(&tmpconf, cc[i]))
1520 0 : return -1;
1521 136 : set_strlist(cc[i], get_strlist(&tmpconf));
1522 : }
1523 : }
1524 : return 0;
1525 : }
1526 :
1527 44 : static int conf_init_save_cname_and_version(struct conf **cconfs)
1528 : {
1529 44 : int ret=-1;
1530 44 : char *cname=NULL;
1531 44 : char *cversion=NULL;
1532 44 : char *orig_cname=get_string(cconfs[OPT_CNAME]);
1533 44 : char *orig_cversion=get_string(cconfs[OPT_PEER_VERSION]);
1534 :
1535 44 : if((orig_cname && !(cname=strdup_w(orig_cname, __func__)))
1536 44 : || (orig_cversion
1537 10 : && !(cversion=strdup_w(orig_cversion, __func__))))
1538 : goto end;
1539 :
1540 44 : set_string(cconfs[OPT_CNAME], NULL);
1541 44 : set_string(cconfs[OPT_PEER_VERSION], NULL);
1542 44 : if(confs_init(cconfs)) goto end;
1543 44 : set_string(cconfs[OPT_CNAME], cname);
1544 44 : set_string(cconfs[OPT_PEER_VERSION], cversion);
1545 44 : ret=0;
1546 : end:
1547 44 : free_w(&cname);
1548 44 : free_w(&cversion);
1549 44 : return ret;
1550 : }
1551 :
1552 72 : static int do_conf_load_overrides(struct conf **globalcs, struct conf **cconfs,
1553 : const char *path, const char *buf)
1554 : {
1555 : // Some client settings can be globally set in the server conf and
1556 : // overridden in the client specific conf.
1557 72 : if(conf_set_from_global(globalcs, cconfs)) return -1;
1558 72 : if(buf) { if(conf_load_lines_from_buf(buf, cconfs)) return -1; }
1559 72 : else { if(conf_load_lines_from_file(path, cconfs)) return -1; }
1560 68 : if(conf_set_from_global_arg_list_overrides(globalcs, cconfs)
1561 68 : || conf_finalise(cconfs))
1562 : return -1;
1563 : return 0;
1564 : }
1565 :
1566 : #ifndef UTEST
1567 : static
1568 : #endif
1569 28 : int conf_load_overrides(struct conf **globalcs, struct conf **cconfs,
1570 : const char *path)
1571 : {
1572 72 : return do_conf_load_overrides(globalcs, cconfs, path, NULL);
1573 : }
1574 :
1575 133 : int cname_valid(const char *cname)
1576 : {
1577 133 : if(!cname) return 0;
1578 133 : if(cname[0]=='.'
1579 127 : || strchr(cname, '/') // Avoid path attacks.
1580 123 : || strchr(cname, '\\') // Be cautious of backslashes too.
1581 : // I am told that emacs tmp files end with '~'.
1582 122 : || cname[strlen(cname)-1]=='~')
1583 : return 0;
1584 120 : return 1;
1585 : }
1586 :
1587 44 : int conf_load_clientconfdir(struct conf **globalcs, struct conf **cconfs)
1588 : {
1589 44 : int ret=-1;
1590 44 : char *path=NULL;
1591 44 : const char *cname=NULL;
1592 :
1593 44 : if(conf_init_save_cname_and_version(cconfs)) goto end;
1594 44 : cname=get_string(cconfs[OPT_CNAME]);
1595 44 : if(!cname_valid(cname))
1596 : {
1597 0 : logp("client name '%s' is not valid\n", cname);
1598 0 : goto end;
1599 : }
1600 :
1601 44 : if(!(path=prepend_s(get_string(globalcs[OPT_CLIENTCONFDIR]), cname)))
1602 : goto end;
1603 88 : ret=conf_load_overrides(globalcs, cconfs, path);
1604 : end:
1605 44 : free_w(&path);
1606 44 : return ret;
1607 : }
1608 :
1609 102 : static int do_load_global_only(struct conf **globalcs,
1610 : const char *path, const char *buf)
1611 : {
1612 102 : if(set_string(globalcs[OPT_CONFFILE], path)) return -1;
1613 102 : if(buf) { if(conf_load_lines_from_buf(buf, globalcs)) return -1; }
1614 102 : else { if(conf_load_lines_from_file(path, globalcs)) return -1; }
1615 102 : if(conf_finalise(globalcs)
1616 99 : || conf_finalise_global_only(path, globalcs))
1617 : return -1;
1618 : return 0;
1619 :
1620 : }
1621 :
1622 102 : int conf_load_global_only(const char *path, struct conf **globalcs)
1623 : {
1624 102 : return do_load_global_only(globalcs, path, NULL);
1625 : }
1626 :
1627 14 : static int restore_client_allowed(struct conf **cconfs, struct conf **sconfs)
1628 : {
1629 : struct strlist *r;
1630 17 : for(r=get_strlist(sconfs[OPT_SUPER_CLIENTS]); r; r=r->next)
1631 8 : if(!strcmp(r->path, get_string(cconfs[OPT_CNAME])))
1632 : return 2;
1633 12 : for(r=get_strlist(sconfs[OPT_RESTORE_CLIENTS]); r; r=r->next)
1634 10 : if(!strcmp(r->path, get_string(cconfs[OPT_CNAME])))
1635 : return 1;
1636 2 : logp("Access to client is not allowed: %s\n",
1637 : get_string(sconfs[OPT_CNAME]));
1638 2 : return 0;
1639 : }
1640 :
1641 15 : int conf_switch_to_orig_client(struct conf **globalcs,
1642 : struct conf **cconfs, const char *orig_client)
1643 : {
1644 15 : int ret=-1;
1645 15 : int is_super=0;
1646 15 : struct conf **sconfs=NULL;
1647 :
1648 : // If we are already the wanted client, no need to switch.
1649 15 : if(!strcmp(get_string(cconfs[OPT_CNAME]), orig_client))
1650 : return 0;
1651 :
1652 15 : if(!(sconfs=confs_alloc())
1653 15 : || confs_init(sconfs)) goto end;
1654 15 : if(set_string(sconfs[OPT_CNAME], orig_client))
1655 : goto end;
1656 15 : logp("Client wants to switch to client: %s\n",
1657 15 : get_string(sconfs[OPT_CNAME]));
1658 :
1659 15 : if(conf_load_clientconfdir(globalcs, sconfs))
1660 : {
1661 1 : logp("Could not load alternate config: %s",
1662 1 : get_string(sconfs[OPT_CNAME]));
1663 1 : goto end;
1664 : }
1665 14 : set_int(sconfs[OPT_SEND_CLIENT_CNTR],
1666 14 : get_int(cconfs[OPT_SEND_CLIENT_CNTR]));
1667 :
1668 14 : switch(restore_client_allowed(cconfs, sconfs))
1669 : {
1670 : case 1:
1671 : break;
1672 : case 2:
1673 5 : is_super=1;
1674 5 : break;
1675 : default:
1676 : goto end;
1677 : }
1678 :
1679 : // Restore client can never force backup.
1680 12 : set_int(sconfs[OPT_CLIENT_CAN_FORCE_BACKUP], 0);
1681 :
1682 12 : if(is_super)
1683 : {
1684 5 : set_int(sconfs[OPT_CLIENT_CAN_DELETE],
1685 5 : get_int(cconfs[OPT_CLIENT_CAN_DELETE]));
1686 5 : set_int(sconfs[OPT_CLIENT_CAN_DIFF],
1687 5 : get_int(cconfs[OPT_CLIENT_CAN_DIFF]));
1688 5 : set_int(sconfs[OPT_CLIENT_CAN_LIST],
1689 5 : get_int(cconfs[OPT_CLIENT_CAN_LIST]));
1690 5 : set_int(sconfs[OPT_CLIENT_CAN_MONITOR],
1691 5 : get_int(cconfs[OPT_CLIENT_CAN_MONITOR]));
1692 5 : set_int(sconfs[OPT_CLIENT_CAN_RESTORE],
1693 5 : get_int(cconfs[OPT_CLIENT_CAN_RESTORE]));
1694 5 : set_int(sconfs[OPT_CLIENT_CAN_VERIFY],
1695 5 : get_int(cconfs[OPT_CLIENT_CAN_VERIFY]));
1696 : }
1697 : else
1698 : {
1699 : // For the rest of the client_can things, do not allow them on
1700 : // orig_client if we do not have them ourselves.
1701 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_DELETE]))
1702 2 : set_int(sconfs[OPT_CLIENT_CAN_DELETE], 0);
1703 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_DIFF]))
1704 2 : set_int(sconfs[OPT_CLIENT_CAN_DIFF], 0);
1705 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_LIST]))
1706 2 : set_int(sconfs[OPT_CLIENT_CAN_LIST], 0);
1707 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_MONITOR]))
1708 2 : set_int(sconfs[OPT_CLIENT_CAN_MONITOR], 0);
1709 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_RESTORE]))
1710 2 : set_int(sconfs[OPT_CLIENT_CAN_RESTORE], 0);
1711 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_VERIFY]))
1712 2 : set_int(sconfs[OPT_CLIENT_CAN_VERIFY], 0);
1713 : }
1714 :
1715 12 : if(set_string(sconfs[OPT_CONNECT_CLIENT],
1716 12 : get_string(cconfs[OPT_CONNECT_CLIENT])))
1717 : goto end;
1718 12 : if(set_string(sconfs[OPT_RESTORE_PATH],
1719 12 : get_string(cconfs[OPT_RESTORE_PATH])))
1720 : goto end;
1721 12 : if(set_string(cconfs[OPT_RESTORE_PATH], NULL))
1722 : goto end;
1723 12 : set_cntr(sconfs[OPT_CNTR], get_cntr(cconfs));
1724 12 : set_cntr(cconfs[OPT_CNTR], NULL);
1725 12 : confs_free_content(cconfs);
1726 12 : confs_init(cconfs);
1727 12 : confs_memcpy(cconfs, sconfs);
1728 12 : confs_null(sconfs);
1729 12 : if(set_string(cconfs[OPT_SUPER_CLIENT],
1730 12 : get_string(cconfs[OPT_CNAME]))) goto end;
1731 12 : if(set_string(cconfs[OPT_ORIG_CLIENT],
1732 12 : get_string(cconfs[OPT_CNAME]))) goto end;
1733 :
1734 12 : logp("Switched to client %s\n", get_string(cconfs[OPT_CNAME]));
1735 12 : ret=0;
1736 : end:
1737 15 : confs_free(&sconfs);
1738 15 : return ret;
1739 : }
1740 :
1741 18 : char *config_default_path(void)
1742 : {
1743 : static char path[256]="";
1744 : #ifdef HAVE_WIN32
1745 : char *pfenv=NULL;
1746 :
1747 : // Burp used to always install to 'C:/Program Files/Burp/', but as
1748 : // of 1.3.11, it changed to %PROGRAMFILES%. Still want the old way
1749 : // to work though. So check %PROGRAMFILES% first, then fall back.
1750 : if((pfenv=getenv("PROGRAMFILES")))
1751 : {
1752 : struct stat statp;
1753 : snprintf(path, sizeof(path), "%s/%s/%s.conf",
1754 : pfenv, PACKAGE_NAME, PACKAGE_TARNAME);
1755 : if(!lstat(path, &statp)
1756 : && !S_ISDIR(statp.st_mode))
1757 : return path;
1758 : }
1759 : snprintf(path, sizeof(path), "C:/Program Files/%s/%s.conf",
1760 : PACKAGE_NAME, PACKAGE_TARNAME);
1761 : #else
1762 18 : snprintf(path, sizeof(path), "%s/%s.conf",
1763 : SYSCONFDIR, PACKAGE_TARNAME);
1764 : #endif
1765 18 : return path;
1766 : }
|
