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