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