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