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