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