Line data Source code
1 : #include "burp.h"
2 : #include "alloc.h"
3 : #include "conf.h"
4 : #include "fsops.h"
5 : #include "handy.h"
6 : #include "lock.h"
7 : #include "log.h"
8 : #include "msg.h"
9 : #include "pathcmp.h"
10 : #include "prepend.h"
11 : #include "strlist.h"
12 : #include "times.h"
13 : #include "client/glob_windows.h"
14 : #include "conffile.h"
15 :
16 : static struct strlist *cli_overrides=NULL;
17 :
18 0 : void conf_set_cli_overrides(struct strlist *overrides)
19 : {
20 0 : cli_overrides=overrides;
21 0 : }
22 :
23 : // This will strip off everything after the last quote. So, configs like this
24 : // should work:
25 : // exclude_regex = "[A-Z]:/pagefile.sys" # swap file (Windows XP, 7, 8)
26 : // Return 1 for quotes removed, -1 for error, 0 for OK.
27 3570 : static int remove_quotes(const char *f, char **v, char quote)
28 : {
29 3570 : char *dp=NULL;
30 3570 : char *sp=NULL;
31 3570 : char *copy=NULL;
32 3570 : int ret=1;
33 :
34 : // If it does not start with a quote, leave it alone.
35 3570 : if(**v!=quote) return 0;
36 :
37 4 : if(!(copy=strdup_w(*v, __func__)))
38 : {
39 : ret=-1;
40 : goto end;
41 : }
42 :
43 8 : for(dp=*v, sp=copy+1; *sp; sp++)
44 : {
45 6 : if(*sp==quote)
46 : {
47 : // Found a matching quote. Stop here.
48 2 : *dp='\0';
49 2 : for(sp++; *sp && isspace(*sp); sp++) { }
50 : // Do not complain about trailing comments.
51 2 : if(*sp && *sp!='#')
52 0 : logp("ignoring trailing characters after quote in config '%s = %s'\n", f, copy);
53 : goto end;
54 : }
55 4 : else if(*sp=='\\')
56 : {
57 0 : sp++;
58 0 : *dp=*sp;
59 0 : dp++;
60 0 : if(*sp!=quote
61 0 : && *sp!='\\')
62 0 : logp("unknown escape sequence '\\%c' in config '%s = %s' - treating it as '%c'\n", *sp, f, copy, *sp);
63 : }
64 : else
65 : {
66 4 : *dp=*sp;
67 4 : dp++;
68 : }
69 : }
70 2 : logp("Did not find closing quote in config '%s = %s'\n", f, copy);
71 2 : *dp='\0';
72 : end:
73 4 : free_w(©);
74 4 : return ret;
75 : }
76 :
77 : // Get field and value pair.
78 1821 : int conf_get_pair(char buf[], char **f, char **v, int *r)
79 : {
80 1821 : char *cp=NULL;
81 1821 : char *eq=NULL;
82 :
83 : // strip leading space
84 1821 : for(cp=buf; *cp && isspace(*cp); cp++) { }
85 1821 : if(!*cp || *cp=='#')
86 : {
87 34 : *f=NULL;
88 34 : *v=NULL;
89 34 : return 0;
90 : }
91 1787 : *f=cp;
92 1787 : if(!(eq=strchr(*f, '='))) return -1;
93 1786 : *eq='\0';
94 :
95 : // Strip white space from before the equals sign.
96 1822 : for(cp=eq-1; *cp && (isspace(*cp) || *cp == ':'); cp--)
97 : {
98 36 : if(*cp == ':') *r=1;
99 36 : *cp='\0';
100 : }
101 : // Skip white space after the equals sign.
102 1786 : for(cp=eq+1; *cp && isspace(*cp); cp++) { }
103 1786 : *v=cp;
104 : // Strip white space at the end of the line.
105 1786 : for(cp+=strlen(cp)-1; *cp && isspace(*cp); cp--) { *cp='\0'; }
106 :
107 : // FIX THIS: Make this more sophisticated - it should understand
108 : // escapes, for example.
109 :
110 1786 : switch(remove_quotes(*f, v, '\''))
111 : {
112 : case -1: return -1;
113 : case 1: break;
114 : default:
115 : // If single quotes were not removed, try to remove
116 : // double quotes.
117 1784 : if(remove_quotes(*f, v, '\"')<0) return -1;
118 : break;
119 : }
120 :
121 1786 : if(!*f || !**f || !*v || !**v) return -1;
122 :
123 1786 : return 0;
124 : }
125 :
126 : static int conf_error(const char *conf_path, int line)
127 : {
128 1 : logp("%s: parse error on line %d\n", conf_path, line);
129 : return -1;
130 : }
131 :
132 53 : int get_file_size(const char *v, uint64_t *dest, const char *conf_path, int line)
133 : {
134 : // Store in bytes, allow k/m/g.
135 53 : const char *cp=NULL;
136 53 : *dest=strtoul(v, NULL, 10);
137 53 : for(cp=v; *cp && (isspace(*cp) || isdigit(*cp)); cp++) { }
138 53 : if(tolower(*cp)=='k') *dest*=1024;
139 53 : else if(tolower(*cp)=='m') *dest*=1024*1024;
140 52 : else if(tolower(*cp)=='g') *dest*=1024*1024*1024;
141 52 : else if(!*cp || *cp=='b')
142 : { }
143 : else
144 : {
145 0 : logp("Unknown file size type '%s' - please use b/kb/mb/gb\n",
146 : cp);
147 0 : return conf_error(conf_path, line);
148 : }
149 : return 0;
150 : }
151 :
152 558 : static int pre_post_override(struct conf *c,
153 : struct conf *pre, struct conf *post)
154 : {
155 558 : const char *override=get_string(c);
156 558 : if(!override) return 0;
157 5 : if(set_string(pre, override)
158 5 : || set_string(post, override))
159 : return -1;
160 : return 0;
161 : }
162 :
163 : #ifdef HAVE_LINUX_OS
164 : struct fstype
165 : {
166 : const char *str;
167 : uint64_t flag;
168 : };
169 :
170 : // Sorted in magic number order.
171 : static struct fstype fstypes[]={
172 : { "devfs", 0x00001373 },
173 : { "devpts", 0x00001CD1 },
174 : { "smbfs", 0x0000517B },
175 : { "nfs", 0x00006969 },
176 : { "romfs", 0x00007275 },
177 : { "iso9660", 0x00009660 },
178 : { "devtmpfs", 0x00009FA0 },
179 : { "proc", 0x00009FA0 },
180 : { "usbdevfs", 0x00009FA2 },
181 : { "ext2", 0x0000EF53 },
182 : { "ext3", 0x0000EF53 },
183 : { "ext4", 0x0000EF53 },
184 : { "ecryptfs", 0x0000F15F },
185 : { "cgroup", 0x0027E0EB },
186 : { "ceph", 0x00C36400 },
187 : { "tmpfs", 0x01021994 },
188 : { "zfs", 0x2FC12FC1 },
189 : { "jfs", 0x3153464A },
190 : { "autofs", 0x42494E4D },
191 : { "reiserfs", 0x52654973 },
192 : { "ntfs", 0x5346544E },
193 : { "xfs", 0x58465342 },
194 : { "sysfs", 0x62656572 },
195 : { "debugfs", 0x64626720 },
196 : { "fusectl", 0x65735543 },
197 : { "fuse.lxcfs", 0x65735546 },
198 : { "securityfs", 0x73636673 },
199 : { "ramfs", 0x858458F6 },
200 : { "btrfs", 0x9123683E },
201 : { "hugetlbfs", 0x958458F6 },
202 : { "cifs", 0xFF534D42 },
203 : { NULL, 0 },
204 : };
205 : /* Use this C code to figure out what f_type gets set to.
206 : #include <stdio.h>
207 : #include <sys/vfs.h>
208 :
209 : int main(int argc, char *argv[])
210 : {
211 : int i=0;
212 : struct statfs buf;
213 : if(argc<1)
214 : {
215 : printf("not enough args\n");
216 : return -1;
217 : }
218 : if(statfs(argv[1], &buf))
219 : {
220 : printf("error\n");
221 : return -1;
222 : }
223 : printf("0x%08X\n", buf.f_type);
224 : return 0;
225 : }
226 : */
227 :
228 : #endif
229 :
230 0 : static int fstype_to_flag(const char *fstype, long *flag)
231 : {
232 : #ifdef HAVE_LINUX_OS
233 0 : int i=0;
234 0 : for(i=0; fstypes[i].str; i++)
235 : {
236 0 : if(!strcmp(fstypes[i].str, fstype))
237 : {
238 0 : *flag=fstypes[i].flag;
239 0 : return 0;
240 : }
241 : }
242 : #else
243 : return 0;
244 : #endif
245 : return -1;
246 : }
247 :
248 5 : static int get_compression(const char *v)
249 : {
250 5 : const char *cp=v;
251 5 : if(!strncmp(v, "gzip", strlen("gzip"))
252 5 : || !(strncmp(v, "zlib", strlen("zlib"))))
253 0 : cp=v+strlen("gzip"); // Or "zlib".
254 5 : if(strlen(cp)==1 && isdigit(*cp))
255 5 : return atoi(cp);
256 : return -1;
257 : }
258 :
259 1772 : static int load_conf_field_and_value(struct conf **c,
260 : const char *f, // field
261 : const char *v, // value
262 : int reset, // reset flag
263 : const char *conf_path,
264 : int line)
265 : {
266 1772 : 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 1767 : 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 1767 : 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 104049 : for(i=0; i<OPT_MAX; i++)
296 : {
297 105811 : if(strcmp(c[i]->field, f)) continue;
298 1762 : switch(c[i]->conf_type)
299 : {
300 : case CT_STRING:
301 948 : return set_string(c[i], v);
302 : case CT_UINT:
303 166 : 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 3 : uint64_t s=0;
313 : return
314 3 : get_file_size(v, &s, conf_path, line)
315 3 : || set_uint64_t(c[i], s);
316 : }
317 : case CT_E_BURP_MODE:
318 127 : 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 503 : if (reset) set_strlist(c[i], 0);
328 503 : return add_to_strlist(c[i], v,
329 503 : !strcmp(c[i]->field, "include"));
330 : case CT_E_RSHASH:
331 : break;
332 : case CT_CNTR:
333 : break;
334 : // No default so we get a warning if something
335 : // was missed;
336 : }
337 : }
338 : }
339 : return 0;
340 : }
341 :
342 : // Recursing, so need to define this ahead of conf_parse_line.
343 : static int conf_load_lines_from_file(const char *conf_path,
344 : struct conf **confs);
345 :
346 0 : static int deal_with_dot_inclusion(const char *conf_path,
347 : char **extrafile, struct conf **confs)
348 : {
349 0 : int ret=-1;
350 0 : char *copy=NULL;
351 : #ifndef HAVE_WIN32
352 0 : int i=0;
353 : glob_t globbuf;
354 0 : if(**extrafile!='/')
355 : #else
356 : if(strlen(*extrafile)>2
357 : && (*extrafile)[1]!=':')
358 : #endif
359 : {
360 : // It is relative to the directory that the
361 : // current conf file is in.
362 0 : char *cp=NULL;
363 0 : char *tmp=NULL;
364 0 : if(!(copy=strdup_w(conf_path, __func__)))
365 : goto end;
366 0 : if((cp=strrchr(copy, '/'))) *cp='\0';
367 0 : if(!(tmp=prepend_s(copy, *extrafile)))
368 : {
369 0 : log_out_of_memory(__func__);
370 0 : goto end;
371 : }
372 0 : free_w(extrafile);
373 0 : *extrafile=tmp;
374 : }
375 : #ifndef HAVE_WIN32
376 : // Treat it is a glob expression.
377 0 : memset(&globbuf, 0, sizeof(globbuf));
378 0 : glob(*extrafile, 0, NULL, &globbuf);
379 0 : for(i=0; (unsigned int)i<globbuf.gl_pathc; i++)
380 0 : if((ret=conf_load_lines_from_file(globbuf.gl_pathv[i], confs)))
381 : goto end;
382 :
383 0 : globfree(&globbuf);
384 : #else
385 : ret=conf_load_lines_from_file(*extrafile, confs);
386 : #endif
387 :
388 : end:
389 0 : free_w(©);
390 0 : return ret;
391 : }
392 :
393 1805 : static int conf_parse_line(struct conf **confs, const char *conf_path,
394 : char buf[], int line)
395 : {
396 1805 : int ret=-1;
397 1805 : int r=0;
398 1805 : char *f=NULL; // field
399 1805 : char *v=NULL; // value
400 1805 : char *extrafile=NULL;
401 :
402 1805 : if(!strncmp(buf, ". ", 2))
403 : {
404 : // The conf file specifies another file to include.
405 0 : char *np=NULL;
406 :
407 0 : if(!(extrafile=strdup_w(buf+2, __func__))) goto end;
408 :
409 0 : if((np=strrchr(extrafile, '\n'))) *np='\0';
410 0 : if(!*extrafile) goto end;
411 :
412 0 : ret=deal_with_dot_inclusion(conf_path, &extrafile, confs);
413 0 : goto end;
414 : }
415 :
416 1805 : if(conf_get_pair(buf, &f, &v, &r)) goto end;
417 1804 : if(f && v
418 1772 : && load_conf_field_and_value(confs, f, v, r, conf_path, line))
419 : goto end;
420 : ret=0;
421 : end:
422 1805 : free_w(&extrafile);
423 1805 : return ret;
424 : }
425 :
426 : static void conf_problem(const char *conf_path, const char *msg, int *r)
427 : {
428 6 : logp("%s: %s\n", conf_path, msg);
429 6 : (*r)--;
430 : }
431 :
432 4 : static void burp_ca_conf_problem(const char *conf_path,
433 : const char *field, int *r)
434 : {
435 4 : char msg[128]="";
436 4 : snprintf(msg, sizeof(msg), "ca_%s_ca set, but %s not set\n",
437 : PACKAGE_TARNAME, field);
438 4 : conf_problem(conf_path, msg, r);
439 4 : }
440 :
441 56 : static int server_conf_checks(struct conf **c, const char *path, int *r)
442 : {
443 : // FIX THIS: Most of this could be done by flags.
444 56 : if(!get_string(c[OPT_DIRECTORY]))
445 : conf_problem(path, "directory unset", r);
446 56 : if(!get_string(c[OPT_DEDUP_GROUP]))
447 : conf_problem(path, "dedup_group unset", r);
448 56 : if(!get_string(c[OPT_CLIENTCONFDIR]))
449 : conf_problem(path, "clientconfdir unset", r);
450 56 : 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 56 : if(!get_string(c[OPT_SSL_DHFILE]))
453 : conf_problem(path, "ssl_dhfile unset", r);
454 56 : if(get_string(c[OPT_ENCRYPTION_PASSWORD]))
455 : conf_problem(path,
456 : "encryption_password should not be set on the server!", r);
457 56 : if(!get_strlist(c[OPT_KEEP]))
458 : conf_problem(path, "keep unset", r);
459 56 : if(get_int(c[OPT_MAX_HARDLINKS])<2)
460 : conf_problem(path, "max_hardlinks too low", r);
461 :
462 56 : if(get_int(c[OPT_MAX_STORAGE_SUBDIRS])<=1000)
463 : conf_problem(path, "max_storage_subdirs too low", r);
464 56 : if(!get_string(c[OPT_TIMESTAMP_FORMAT])
465 56 : && set_string(c[OPT_TIMESTAMP_FORMAT], DEFAULT_TIMESTAMP_FORMAT))
466 : return -1;
467 56 : if(get_string(c[OPT_CA_CONF]))
468 : {
469 1 : int ca_err=0;
470 1 : const char *ca_name=get_string(c[OPT_CA_NAME]);
471 1 : const char *ca_server_name=get_string(c[OPT_CA_SERVER_NAME]);
472 1 : if(!ca_name)
473 : {
474 0 : logp("ca_conf set, but ca_name not set\n");
475 0 : ca_err++;
476 : }
477 1 : if(!ca_server_name)
478 : {
479 0 : logp("ca_conf set, but ca_server_name not set\n");
480 0 : ca_err++;
481 : }
482 2 : if(ca_name
483 1 : && ca_server_name
484 1 : && !strcmp(ca_name, ca_server_name))
485 : {
486 0 : logp("ca_name and ca_server_name cannot be the same\n");
487 0 : ca_err++;
488 : }
489 1 : if(!get_string(c[OPT_CA_BURP_CA]))
490 : {
491 0 : logp("ca_conf set, but ca_%s_ca not set\n",
492 : PACKAGE_TARNAME);
493 0 : ca_err++;
494 : }
495 1 : if(!get_string(c[OPT_SSL_DHFILE]))
496 : {
497 0 : logp("ca_conf set, but ssl_dhfile not set\n");
498 0 : ca_err++;
499 : }
500 1 : if(!get_string(c[OPT_SSL_CERT_CA]))
501 : {
502 0 : logp("ca_conf set, but ssl_cert_ca not set\n");
503 0 : ca_err++;
504 : }
505 1 : if(!get_string(c[OPT_SSL_CERT]))
506 : {
507 0 : logp("ca_conf set, but ssl_cert not set\n");
508 0 : ca_err++;
509 : }
510 1 : if(!get_string(c[OPT_SSL_KEY]))
511 : {
512 0 : logp("ca_conf set, but ssl_key not set\n");
513 0 : ca_err++;
514 : }
515 1 : if(ca_err) return -1;
516 : }
517 56 : if(get_string(c[OPT_MANUAL_DELETE]))
518 : {
519 0 : if(!is_absolute(get_string(c[OPT_MANUAL_DELETE])))
520 : {
521 0 : logp("ERROR: Please use an absolute manual_delete path.\n");
522 0 : return -1;
523 : }
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 : return (char *)ASN1_STRING_data(d);
548 : #else
549 0 : return (char *)ASN1_STRING_get0_data(d);
550 : #endif
551 : }
552 :
553 52 : static void mangle_cname(char **cname, struct conf **c)
554 : {
555 52 : if(!get_int(c[OPT_CNAME_FQDN]))
556 0 : strip_fqdn(cname);
557 52 : if(get_int(c[OPT_CNAME_LOWERCASE]))
558 0 : strlwr(*cname);
559 52 : }
560 :
561 52 : static int get_cname_from_ssl_cert(struct conf **c)
562 : {
563 52 : int ret=-1;
564 52 : struct fzp *fzp=NULL;
565 52 : X509 *cert=NULL;
566 52 : X509_NAME *subj=NULL;
567 52 : char *path=get_string(c[OPT_SSL_CERT]);
568 52 : const char *cn=NULL;
569 52 : char *copy=NULL;
570 :
571 52 : 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 52 : static int get_fqdn(struct conf **c)
612 : {
613 52 : int ret=-1;
614 : int gai_result;
615 : struct addrinfo hints;
616 52 : struct addrinfo *info=NULL;
617 52 : char hostname[1024]="";
618 52 : char *fqdn=NULL;
619 52 : hostname[1023] = '\0';
620 52 : if(gethostname(hostname, 1023))
621 : {
622 0 : logp("gethostname() failed: %s\n", strerror(errno));
623 0 : goto end;
624 : }
625 :
626 52 : memset(&hints, 0, sizeof hints);
627 : hints.ai_family=AF_UNSPEC;
628 52 : hints.ai_socktype=SOCK_STREAM;
629 52 : hints.ai_flags=AI_CANONNAME;
630 :
631 52 : 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 : logp("Using %s\n", hostname);
636 0 : if(!(fqdn=strdup_w(hostname, __func__)))
637 : goto end;
638 : }
639 : else
640 : {
641 : //for(p=info; p; p=p->ai_next)
642 : // Just use the first one.
643 52 : if(!info)
644 : {
645 0 : logp("Got no hostname in %s\n", __func__);
646 0 : goto end;
647 : }
648 52 : if(!(fqdn=strdup_w(info->ai_canonname, __func__)))
649 : goto end;
650 : }
651 :
652 52 : mangle_cname(&fqdn, c);
653 :
654 52 : if(set_string(c[OPT_CNAME], fqdn))
655 : goto end;
656 52 : logp("cname from hostname: %s\n", get_string(c[OPT_CNAME]));
657 :
658 52 : ret=0;
659 : end:
660 52 : if(info) freeaddrinfo(info);
661 52 : free_w(&fqdn);
662 52 : return ret;
663 : }
664 :
665 108 : const char *confs_get_lockfile(struct conf **confs)
666 : {
667 108 : const char *lockfile=get_string(confs[OPT_LOCKFILE]);
668 108 : if(!lockfile) lockfile=get_string(confs[OPT_PIDFILE]);
669 108 : return lockfile;
670 : }
671 :
672 108 : static int general_conf_checks(struct conf **c, const char *path, int *r)
673 : {
674 108 : if(!confs_get_lockfile(c))
675 : conf_problem(path, "lockfile unset", r);
676 108 : if(!get_string(c[OPT_SSL_CERT]))
677 : conf_problem(path, "ssl_cert unset", r);
678 108 : if(!get_string(c[OPT_SSL_CERT_CA]))
679 : conf_problem(path, "ssl_cert_ca unset", r);
680 108 : return 0;
681 : }
682 :
683 52 : static int client_conf_checks(struct conf **c, const char *path, int *r)
684 : {
685 52 : int ret=-1;
686 52 : char *copy=NULL;
687 52 : const char *autoupgrade_os=get_string(c[OPT_AUTOUPGRADE_OS]);
688 :
689 52 : if(!get_string(c[OPT_CNAME]))
690 : {
691 52 : if(get_cname_from_ssl_cert(c))
692 : goto end;
693 : // There was no error. This is probably a new install.
694 : // Try getting the fqdn and using that.
695 52 : if(!get_string(c[OPT_CNAME]))
696 : {
697 52 : if(get_fqdn(c))
698 : goto end;
699 52 : if(!get_string(c[OPT_CNAME]))
700 : conf_problem(path, "client name unset", r);
701 : }
702 : }
703 52 : if(!get_string(c[OPT_PASSWORD]))
704 : {
705 52 : logp("password not set, falling back to \"password\"\n");
706 52 : if(set_string(c[OPT_PASSWORD], "password"))
707 : goto end;
708 : }
709 52 : if(!get_string(c[OPT_SERVER]))
710 : conf_problem(path, "server unset", r);
711 52 : if(!get_string(c[OPT_SSL_PEER_CN]))
712 : {
713 1 : const char *server=get_string(c[OPT_SERVER]);
714 1 : logp("ssl_peer_cn unset\n");
715 1 : if(server)
716 : {
717 1 : char *cp=NULL;
718 1 : if(!(copy=strdup_w(server, __func__)))
719 : goto end;
720 :
721 1 : if((cp=strchr(copy, ':')))
722 0 : *cp='\0';
723 1 : logp("falling back to '%s'\n", copy);
724 1 : if(set_string(c[OPT_SSL_PEER_CN], copy))
725 : goto end;
726 : }
727 : }
728 52 : if(autoupgrade_os
729 0 : && strstr(autoupgrade_os, ".."))
730 : conf_problem(path,
731 : "autoupgrade_os must not contain a '..' component", r);
732 52 : if(get_string(c[OPT_CA_BURP_CA]))
733 : {
734 1 : if(!get_string(c[OPT_CA_CSR_DIR]))
735 1 : burp_ca_conf_problem(path, "ca_csr_dir", r);
736 1 : if(!get_string(c[OPT_SSL_CERT_CA]))
737 1 : burp_ca_conf_problem(path, "ssl_cert_ca", r);
738 1 : if(!get_string(c[OPT_SSL_CERT]))
739 1 : burp_ca_conf_problem(path, "ssl_cert", r);
740 1 : if(!get_string(c[OPT_SSL_KEY]))
741 1 : burp_ca_conf_problem(path, "ssl_key", r);
742 : }
743 :
744 52 : if(!r)
745 : {
746 : struct strlist *l;
747 0 : logp("Listing configured paths:\n");
748 0 : for(l=get_strlist(c[OPT_INCEXCDIR]); l; l=l->next)
749 0 : logp("%s: %s\n", l->flag?"include":"exclude", l->path);
750 0 : logp("Listing starting paths:\n");
751 0 : for(l=get_strlist(c[OPT_STARTDIR]); l; l=l->next)
752 0 : if(l->flag) logp("%s\n", l->path);
753 : }
754 :
755 : ret=0;
756 : end:
757 52 : free_w(©);
758 52 : return ret;
759 : }
760 :
761 187 : static int finalise_keep_args(struct conf **c)
762 : {
763 : struct strlist *k;
764 187 : struct strlist *last=NULL;
765 187 : uint64_t mult=1;
766 310 : for(k=get_strlist(c[OPT_KEEP]); k; k=k->next)
767 : {
768 246 : if(!(k->flag=atoi(k->path)))
769 : {
770 0 : logp("'keep' value cannot be set to '%s'\n", k->path);
771 0 : return -1;
772 : }
773 123 : mult*=k->flag;
774 :
775 : // An error if you try to keep backups every second
776 : // for 100 years.
777 123 : if(mult>52560000)
778 : {
779 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");
780 0 : return -1;
781 : }
782 123 : last=k;
783 : }
784 : // If more than one keep value is set, add one to the last one.
785 : // This is so that, for example, having set 7, 4, 6, then
786 : // a backup of age 7*4*6=168 or more is guaranteed to be kept.
787 : // Otherwise, only 7*4*5=140 would be guaranteed to be kept.
788 187 : k=get_strlist(c[OPT_KEEP]);
789 187 : if(k && k->next) last->flag++;
790 : return 0;
791 : }
792 :
793 46 : static int incexc_munge(struct conf **c, struct strlist *s)
794 : {
795 : #ifdef HAVE_WIN32
796 : convert_backslashes(&s->path);
797 : #endif
798 46 : if(!is_absolute(s->path))
799 : {
800 1 : logp("ERROR: Please use absolute include/exclude paths.\n");
801 : return -1;
802 : }
803 45 : if(add_to_strlist(c[OPT_INCEXCDIR], s->path, s->flag))
804 : return -1;
805 : return 0;
806 : }
807 :
808 191 : static int finalise_incexc_dirs(struct conf **c)
809 : {
810 191 : struct strlist *s=NULL;
811 :
812 231 : for(s=get_strlist(c[OPT_INCLUDE]); s; s=s->next)
813 41 : if(incexc_munge(c, s)) return -1;
814 195 : for(s=get_strlist(c[OPT_EXCLUDE]); s; s=s->next)
815 5 : if(incexc_munge(c, s)) return -1;
816 191 : if(get_strlist(c[OPT_INCREG]) &&
817 1 : !(get_strlist(c[OPT_INCLUDE]) || get_strlist(c[OPT_INCGLOB])))
818 : {
819 0 : logp("Need at least one 'include' or 'include_glob' for the 'include_regex' to work.\n");
820 0 : return -1;
821 : }
822 : return 0;
823 : }
824 :
825 6 : static int add_to_cross_filesystem(struct conf **c, const char *path)
826 : {
827 6 : if(strlist_find(get_strlist(c[OPT_FSCHGDIR]), path, 0))
828 : return 0;
829 6 : return add_to_strlist(c[OPT_FSCHGDIR], path, 0);
830 : }
831 :
832 189 : static int check_start_dirs_and_seed(struct conf **c)
833 : {
834 189 : int errors=0;
835 189 : struct strlist *s=NULL;
836 189 : const char *src=get_string(c[OPT_SEED_SRC]);
837 189 : if(!src)
838 : return 0;
839 :
840 0 : for(s=get_strlist(c[OPT_STARTDIR]); s; s=s->next)
841 : {
842 0 : if(!is_subdir(src, s->path))
843 : {
844 0 : logp("ERROR: Starting directories need to be within %s:%s: %s\n",
845 0 : c[OPT_SEED_SRC]->field, src, s->path);
846 0 : errors++;
847 : }
848 : }
849 :
850 : return errors;
851 : }
852 :
853 : // This decides which directories to start backing up, and which
854 : // are subdirectories which don't need to be started separately.
855 190 : static int finalise_start_dirs(struct conf **c)
856 : {
857 190 : struct strlist *s=NULL;
858 190 : struct strlist *last_ie=NULL;
859 190 : struct strlist *last_sd=NULL;
860 :
861 : // Make sure that the startdir list starts empty, or chaos will ensue.
862 190 : conf_free_content(c[OPT_STARTDIR]);
863 :
864 229 : for(s=get_strlist(c[OPT_INCLUDE]); s; s=s->next)
865 : {
866 : #ifdef HAVE_WIN32
867 : convert_backslashes(&s->path);
868 : #endif
869 40 : if(!is_absolute(s->path))
870 : {
871 0 : logp("ERROR: Please use absolute include/exclude paths.\n");
872 0 : return -1;
873 : }
874 :
875 : // Ensure that we do not backup the same directory twice.
876 40 : if(last_ie && !strcmp(s->path, last_ie->path))
877 : {
878 1 : logp("Directory appears twice in conf: %s\n",
879 : s->path);
880 1 : return -1;
881 : }
882 : // If it is not a subdirectory of the most recent start point,
883 : // we have found another start point.
884 39 : if(!get_strlist(c[OPT_STARTDIR])
885 14 : || !last_sd || !is_subdir(last_sd->path, s->path))
886 : {
887 : // Do not use strlist_add_sorted, because last_sd is
888 : // relying on incexcdir already being sorted.
889 33 : if(add_to_strlist(c[OPT_STARTDIR], s->path, s->flag))
890 : return -1;
891 : last_sd=s;
892 : }
893 : else
894 : {
895 : // If it is not a starting directory, it should at
896 : // least be included as a cross_filesystem entry.
897 6 : if(add_to_cross_filesystem(c, s->path))
898 : return -1;
899 : }
900 39 : last_ie=s;
901 : }
902 :
903 189 : if(check_start_dirs_and_seed(c))
904 : return -1;
905 :
906 189 : return 0;
907 : }
908 :
909 189 : static int finalise_fschg_dirs(struct conf **c)
910 : {
911 : struct strlist *s;
912 197 : for(s=get_strlist(c[OPT_FSCHGDIR]); s; s=s->next)
913 8 : strip_trailing_slashes(&s->path);
914 189 : return 0;
915 : }
916 :
917 : // The glob stuff should only run on the client side.
918 56 : static int finalise_glob(struct conf **c)
919 : {
920 56 : int ret=-1;
921 : #ifdef HAVE_WIN32
922 : if(glob_windows(c)) goto end;
923 : #else
924 : int i;
925 : glob_t globbuf;
926 : struct strlist *l;
927 56 : struct strlist *last=NULL;
928 56 : memset(&globbuf, 0, sizeof(globbuf));
929 59 : for(l=get_strlist(c[OPT_INCGLOB]); l; l=l->next)
930 : {
931 3 : glob(l->path, last?GLOB_APPEND:0, NULL, &globbuf);
932 3 : last=l;
933 : }
934 :
935 3 : for(i=0; (unsigned int)i<globbuf.gl_pathc; i++)
936 3 : if(add_to_strlist_include_uniq(c[OPT_INCLUDE], globbuf.gl_pathv[i]))
937 : goto end;
938 :
939 56 : globfree(&globbuf);
940 : #endif
941 56 : ret=0;
942 : end:
943 56 : return ret;
944 : }
945 :
946 : // Reeval the glob after script pre
947 2 : int reeval_glob(struct conf **c)
948 : {
949 2 : if(finalise_glob(c))
950 : return -1;
951 :
952 2 : if(finalise_incexc_dirs(c)
953 2 : || finalise_start_dirs(c)
954 2 : || finalise_fschg_dirs(c))
955 : return -1;
956 :
957 : return 0;
958 : }
959 :
960 : // Set the flag of the first item in a list that looks at extensions to the
961 : // maximum number of characters that need to be checked, plus one. This is for
962 : // a bit of added efficiency.
963 567 : static void set_max_ext(struct strlist *list)
964 : {
965 567 : int max=0;
966 567 : struct strlist *l=NULL;
967 571 : for(l=list; l; l=l->next)
968 : {
969 4 : int s=strlen(l->path);
970 4 : if(s>max) max=s;
971 : }
972 567 : if(list) list->flag=max+1;
973 567 : }
974 :
975 378 : static int finalise_fstypes(struct conf **c, int opt)
976 : {
977 : struct strlist *l;
978 : // Set the strlist flag for the excluded fstypes
979 378 : for(l=get_strlist(c[opt]); l; l=l->next)
980 : {
981 0 : l->flag=0;
982 0 : if(!strncasecmp(l->path, "0x", 2))
983 : {
984 0 : l->flag=strtol((l->path)+2, NULL, 16);
985 0 : logp("Excluding file system type 0x%08lX\n", l->flag);
986 : }
987 : else
988 : {
989 0 : if(fstype_to_flag(l->path, &(l->flag)))
990 : {
991 0 : logp("Unknown exclude fs type: %s\n", l->path);
992 0 : l->flag=0;
993 : }
994 : }
995 : }
996 378 : return 0;
997 : }
998 :
999 10 : static int setup_script_arg_override(struct conf *c, struct conf *args)
1000 : {
1001 : struct strlist *s;
1002 10 : set_strlist(args, NULL);
1003 30 : for(s=get_strlist(c); s; s=s->next)
1004 20 : if(add_to_strlist(args, s->path, s->flag))
1005 : return -1;
1006 : return 0;
1007 : }
1008 :
1009 558 : static int setup_script_arg_overrides(struct conf *c,
1010 : struct conf *pre_args, struct conf *post_args)
1011 : {
1012 558 : if(!get_strlist(c)) return 0;
1013 5 : return setup_script_arg_override(c, pre_args)
1014 5 : || setup_script_arg_override(c, post_args);
1015 : }
1016 :
1017 149 : static int listen_config_ok(const char *l)
1018 : {
1019 : int port;
1020 149 : const char *c=NULL;
1021 149 : const char *cp=NULL;
1022 :
1023 2010 : for(c=l; *c; c++)
1024 1861 : if(!isalnum(*c) && *c!=':' && *c!='.')
1025 : return 0;
1026 :
1027 149 : if(!(cp=strrchr(l, ':')))
1028 : return 0;
1029 149 : if(l==cp)
1030 : return 0;
1031 149 : cp++;
1032 149 : if(!strlen(cp) || strlen(cp)>5)
1033 : return 0;
1034 149 : port=atoi(cp);
1035 149 : if(port<=0 || port>65535)
1036 : return 0;
1037 :
1038 149 : return 1;
1039 : }
1040 :
1041 144 : static int finalise_server_max_children(struct conf **c,
1042 : enum conf_opt listen_opt, enum conf_opt max_children_opt)
1043 : {
1044 : struct strlist *l;
1045 : struct strlist *mc;
1046 144 : long max_children=5;
1047 :
1048 581 : for(l=get_strlist(c[listen_opt]),
1049 293 : mc=get_strlist(c[max_children_opt]); l; l=l->next)
1050 : {
1051 149 : if(!listen_config_ok(l->path))
1052 : {
1053 0 : logp("Could not parse %s config '%s'\n",
1054 0 : c[listen_opt]->field, l->path);
1055 0 : return -1;
1056 : }
1057 149 : if(mc)
1058 : {
1059 20 : if((max_children=atol(mc->path))<=0)
1060 : {
1061 0 : logp("%s too low for %s %s\n",
1062 0 : c[max_children_opt]->field,
1063 0 : c[listen_opt]->field,
1064 : l->path);
1065 0 : return -1;
1066 : }
1067 10 : l->flag=max_children;
1068 :
1069 10 : mc=mc->next;
1070 : }
1071 : else
1072 : {
1073 278 : logp("%s %s defaulting to %s %lu\n",
1074 139 : c[listen_opt]->field,
1075 : l->path,
1076 139 : c[max_children_opt]->field,
1077 : max_children);
1078 139 : l->flag=max_children;
1079 : }
1080 : }
1081 :
1082 144 : if(mc)
1083 : {
1084 0 : logp("too many %s options\n", c[max_children_opt]->field);
1085 0 : return -1;
1086 : }
1087 :
1088 : return 0;
1089 : }
1090 :
1091 52 : static int finalise_client_ports(struct conf **c)
1092 : {
1093 52 : int port=0;
1094 : struct strlist *p;
1095 :
1096 103 : for(p=get_strlist(c[OPT_PORT]); p; p=p->next)
1097 102 : port=atoi(p->path);
1098 :
1099 52 : if(!port)
1100 : return 0;
1101 :
1102 51 : if(!get_int(c[OPT_PORT_BACKUP]))
1103 50 : set_int(c[OPT_PORT_BACKUP], port);
1104 51 : if(!get_int(c[OPT_PORT_RESTORE]))
1105 49 : set_int(c[OPT_PORT_RESTORE], port);
1106 51 : if(!get_int(c[OPT_PORT_VERIFY]))
1107 50 : set_int(c[OPT_PORT_VERIFY], get_int(c[OPT_PORT_RESTORE]));
1108 51 : if(!get_int(c[OPT_PORT_LIST]))
1109 50 : set_int(c[OPT_PORT_LIST], port);
1110 51 : if(!get_int(c[OPT_PORT_DELETE]))
1111 50 : set_int(c[OPT_PORT_DELETE], port);
1112 :
1113 : return 0;
1114 : }
1115 :
1116 189 : static int apply_cli_overrides(struct conf **confs)
1117 : {
1118 189 : int ret=-1;
1119 189 : int line=0;
1120 189 : char *opt=NULL;
1121 189 : struct strlist *oo=NULL;
1122 :
1123 189 : for(oo=cli_overrides; oo; oo=oo->next)
1124 : {
1125 0 : line++;
1126 0 : free_w(&opt);
1127 0 : if(!(opt=strdup_w(oo->path, __func__)))
1128 : goto end;
1129 0 : if((ret=conf_parse_line(confs, "", opt, line)))
1130 : {
1131 0 : logp("Unable to parse cli option %d '%s'\n",
1132 : line, oo->path);
1133 0 : goto end;
1134 : }
1135 : }
1136 : ret=0;
1137 : end:
1138 189 : free_w(&opt);
1139 189 : return ret;
1140 : }
1141 :
1142 189 : static int conf_finalise(struct conf **c)
1143 : {
1144 : enum burp_mode burp_mode;
1145 189 : int s_script_notify=0;
1146 :
1147 189 : if(apply_cli_overrides(c))
1148 : return -1;
1149 :
1150 189 : burp_mode=get_e_burp_mode(c[OPT_BURP_MODE]);
1151 :
1152 189 : if(finalise_fstypes(c, OPT_EXCFS)
1153 189 : || finalise_fstypes(c, OPT_INCFS))
1154 : return -1;
1155 :
1156 189 : strlist_compile_regexes(get_strlist(c[OPT_INCREG]));
1157 189 : strlist_compile_regexes(get_strlist(c[OPT_EXCREG]));
1158 :
1159 189 : set_max_ext(get_strlist(c[OPT_INCEXT]));
1160 189 : set_max_ext(get_strlist(c[OPT_EXCEXT]));
1161 189 : set_max_ext(get_strlist(c[OPT_EXCOM]));
1162 :
1163 189 : if(burp_mode==BURP_MODE_CLIENT
1164 54 : && finalise_glob(c))
1165 : return -1;
1166 :
1167 189 : if(finalise_incexc_dirs(c)
1168 188 : || finalise_start_dirs(c)
1169 187 : || finalise_fschg_dirs(c))
1170 : return -1;
1171 :
1172 187 : if(finalise_keep_args(c))
1173 : return -1;
1174 :
1175 187 : if(burp_mode==BURP_MODE_SERVER)
1176 : {
1177 73 : if(!get_strlist(c[OPT_LISTEN]))
1178 : {
1179 1 : logp("Need at least one 'listen' config.\n");
1180 1 : return -1;
1181 : }
1182 72 : if(finalise_server_max_children(c,
1183 : OPT_LISTEN, OPT_MAX_CHILDREN)
1184 72 : || finalise_server_max_children(c,
1185 : OPT_LISTEN_STATUS, OPT_MAX_STATUS_CHILDREN))
1186 : return -1;
1187 : }
1188 186 : if(burp_mode==BURP_MODE_CLIENT)
1189 : {
1190 52 : if(finalise_client_ports(c))
1191 : return -1;
1192 : }
1193 :
1194 186 : if((s_script_notify=get_int(c[OPT_S_SCRIPT_NOTIFY])))
1195 : {
1196 4 : set_int(c[OPT_S_SCRIPT_PRE_NOTIFY], s_script_notify);
1197 4 : set_int(c[OPT_S_SCRIPT_POST_NOTIFY], s_script_notify);
1198 : }
1199 :
1200 : // These override the specific pre/post script paths with the general
1201 : // one. For example, if 'server_script' is set, its value is used for
1202 : // 'server_script_pre' and 'server_script_post'.
1203 186 : if(pre_post_override(c[OPT_B_SCRIPT],
1204 : c[OPT_B_SCRIPT_PRE], c[OPT_B_SCRIPT_POST])
1205 186 : || pre_post_override(c[OPT_R_SCRIPT],
1206 : c[OPT_R_SCRIPT_PRE], c[OPT_R_SCRIPT_POST])
1207 186 : || pre_post_override(c[OPT_S_SCRIPT],
1208 : c[OPT_S_SCRIPT_PRE], c[OPT_S_SCRIPT_POST])
1209 : // And these do the same for the script arguments.
1210 186 : || setup_script_arg_overrides(c[OPT_B_SCRIPT_ARG],
1211 : c[OPT_B_SCRIPT_PRE_ARG], c[OPT_B_SCRIPT_POST_ARG])
1212 186 : || setup_script_arg_overrides(c[OPT_R_SCRIPT_ARG],
1213 : c[OPT_R_SCRIPT_PRE_ARG], c[OPT_R_SCRIPT_POST_ARG])
1214 186 : || setup_script_arg_overrides(c[OPT_S_SCRIPT_ARG],
1215 : c[OPT_S_SCRIPT_PRE_ARG], c[OPT_S_SCRIPT_POST_ARG]))
1216 : return -1;
1217 :
1218 : // We are now done with these. Clear them, otherwise they interfere.
1219 186 : set_string(c[OPT_S_SCRIPT], NULL);
1220 186 : set_strlist(c[OPT_S_SCRIPT_ARG], NULL);
1221 186 : return 0;
1222 : }
1223 :
1224 108 : static int conf_finalise_global_only(const char *conf_path, struct conf **confs)
1225 : {
1226 108 : int r=0;
1227 :
1228 : // Let the caller check the 'keep' value.
1229 :
1230 108 : if(!get_string(confs[OPT_SSL_KEY_PASSWORD])
1231 108 : && set_string(confs[OPT_SSL_KEY_PASSWORD], ""))
1232 0 : r--;
1233 :
1234 108 : if(general_conf_checks(confs, conf_path, &r)) r--;
1235 :
1236 108 : switch(get_e_burp_mode(confs[OPT_BURP_MODE]))
1237 : {
1238 : case BURP_MODE_SERVER:
1239 56 : if(server_conf_checks(confs, conf_path, &r)) r--;
1240 : break;
1241 : case BURP_MODE_CLIENT:
1242 52 : if(client_conf_checks(confs, conf_path, &r)) r--;
1243 : break;
1244 : case BURP_MODE_UNSET:
1245 : default:
1246 0 : logp("%s: mode unset - need 'server' or 'client'\n",
1247 : conf_path);
1248 0 : r--;
1249 0 : break;
1250 : }
1251 :
1252 108 : return r;
1253 : }
1254 :
1255 190 : static int conf_load_lines_from_file(const char *conf_path, struct conf **confs)
1256 : {
1257 190 : int ret=0;
1258 190 : int line=0;
1259 190 : FILE *fp=NULL;
1260 190 : char buf[4096]="";
1261 :
1262 190 : if(!(fp=fopen(conf_path, "r")))
1263 : {
1264 3 : logp("could not open '%s' for reading.\n", conf_path);
1265 3 : return -1;
1266 : }
1267 1984 : while(fgets(buf, sizeof(buf), fp))
1268 : {
1269 1797 : line++;
1270 1797 : if(conf_parse_line(confs, conf_path, buf, line))
1271 : {
1272 1 : conf_error(conf_path, line);
1273 1 : ret=-1;
1274 : }
1275 : }
1276 187 : if(fp) fclose(fp);
1277 187 : return ret;
1278 : }
1279 :
1280 : #ifndef UTEST
1281 : static
1282 : #endif
1283 3 : int conf_load_lines_from_buf(const char *buf, struct conf **c)
1284 : {
1285 3 : int ret=0;
1286 3 : int line=0;
1287 3 : char *tok=NULL;
1288 3 : char *copy=NULL;
1289 :
1290 3 : if(!buf) return 0;
1291 :
1292 3 : if(!(copy=strdup_w(buf, __func__))) return -1;
1293 3 : if(!(tok=strtok(copy, "\n")))
1294 : {
1295 0 : logp("unable to parse conf buffer\n");
1296 0 : free_w(©);
1297 0 : return -1;
1298 : }
1299 : do
1300 : {
1301 8 : line++;
1302 8 : if(conf_parse_line(c, "", tok, line))
1303 : {
1304 : ret=-1;
1305 : break;
1306 : }
1307 8 : } while((tok=strtok(NULL, "\n")));
1308 3 : free_w(©);
1309 :
1310 3 : return ret;
1311 : }
1312 :
1313 : /* The server runs this when parsing a restore file on the server. */
1314 6 : int conf_parse_incexcs_path(struct conf **c, const char *path)
1315 : {
1316 6 : free_incexcs(c);
1317 6 : if(conf_load_lines_from_file(path, c)
1318 6 : || conf_finalise(c))
1319 : return -1;
1320 : return 0;
1321 : }
1322 :
1323 : /* The client runs this when the server overrides the incexcs. */
1324 1 : int conf_parse_incexcs_buf(struct conf **c, const char *incexc)
1325 : {
1326 1 : free_incexcs(c);
1327 1 : if(conf_load_lines_from_buf(incexc, c)
1328 1 : || conf_finalise(c))
1329 : return -1;
1330 : return 0;
1331 : }
1332 :
1333 : /* The client runs this when the server overrides the incexcs for restore. */
1334 4 : int conf_parse_incexcs_srestore(struct conf **c, const char *incexc)
1335 : {
1336 4 : int ret=-1;
1337 4 : char *rp=NULL;
1338 4 : char *oldprefix=NULL;
1339 4 : char *srvprefix=NULL;
1340 4 : char *newprefix=NULL;
1341 4 : const char *rpfield=c[OPT_RESTOREPREFIX]->field;
1342 :
1343 4 : if(!(rp=get_string(c[OPT_RESTOREPREFIX])))
1344 : {
1345 2 : logp("The client side must specify a %s!\n", rpfield);
1346 2 : goto end;
1347 : }
1348 2 : if(!(oldprefix=strdup_w(rp, __func__)))
1349 : goto end;
1350 :
1351 2 : free_incexcs(c);
1352 2 : if(conf_load_lines_from_buf(incexc, c)
1353 2 : || conf_finalise(c))
1354 : goto end;
1355 :
1356 2 : if((srvprefix=get_string(c[OPT_RESTOREPREFIX])))
1357 : {
1358 2 : if(has_dot_component(srvprefix))
1359 : {
1360 0 : logp("The server gave %s '%s', which is not allowed!",
1361 : rpfield, srvprefix);
1362 0 : goto end;
1363 : }
1364 2 : if(!strcmp(oldprefix, "/"))
1365 : {
1366 : // Avoid double slash.
1367 0 : if(!(newprefix=prepend_s("", srvprefix)))
1368 : goto end;
1369 : }
1370 : else
1371 : {
1372 2 : if(!(newprefix=prepend_s(oldprefix, srvprefix)))
1373 : goto end;
1374 : }
1375 2 : if(set_string(c[OPT_RESTOREPREFIX], newprefix))
1376 : goto end;
1377 2 : if(build_path_w(newprefix))
1378 : goto end;
1379 : }
1380 : else
1381 : {
1382 0 : if(set_string(c[OPT_RESTOREPREFIX], oldprefix))
1383 : goto end;
1384 : }
1385 : ret=0;
1386 : end:
1387 4 : free_w(&oldprefix);
1388 4 : free_w(&newprefix);
1389 4 : return ret;
1390 : }
1391 :
1392 73 : static int conf_set_from_global(struct conf **globalc, struct conf **cc)
1393 : {
1394 73 : int i=0;
1395 13432 : for(i=0; i<OPT_MAX; i++)
1396 : {
1397 13359 : if(!(cc[i]->flags & CONF_FLAG_CC_OVERRIDE))
1398 8760 : continue;
1399 4599 : switch(cc[i]->conf_type)
1400 : {
1401 : case CT_STRING:
1402 1095 : set_string(cc[i], get_string(globalc[i]));
1403 1095 : break;
1404 : case CT_UINT:
1405 2263 : set_int(cc[i], get_int(globalc[i]));
1406 2263 : break;
1407 : case CT_FLOAT:
1408 0 : set_float(cc[i], get_float(globalc[i]));
1409 0 : break;
1410 : case CT_MODE_T:
1411 0 : set_mode_t(cc[i], get_mode_t(globalc[i]));
1412 0 : break;
1413 : case CT_SSIZE_T:
1414 292 : set_uint64_t(cc[i], get_uint64_t(globalc[i]));
1415 292 : break;
1416 : case CT_E_BURP_MODE:
1417 0 : set_e_burp_mode(cc[i], get_e_burp_mode(globalc[i]));
1418 0 : break;
1419 : case CT_E_PROTOCOL:
1420 73 : set_e_protocol(cc[i], get_e_protocol(globalc[i]));
1421 73 : break;
1422 : case CT_E_RECOVERY_METHOD:
1423 73 : set_e_recovery_method(cc[i], get_e_recovery_method(globalc[i]));
1424 73 : break;
1425 : case CT_E_RSHASH:
1426 73 : set_e_rshash(cc[i], get_e_rshash(globalc[i]));
1427 73 : break;
1428 : case CT_STRLIST:
1429 : // Done later.
1430 : break;
1431 : case CT_CNTR:
1432 : break;
1433 : // No default so that there are warnings if anything
1434 : // was missed.
1435 : }
1436 : }
1437 :
1438 : // If ssl_peer_cn is not set, default it to the client name.
1439 73 : if(!get_string(globalc[OPT_SSL_PEER_CN])
1440 62 : && set_string(cc[OPT_SSL_PEER_CN], get_string(cc[OPT_CNAME])))
1441 : return -1;
1442 :
1443 : return 0;
1444 : }
1445 :
1446 794 : static int append_strlist(struct conf *dst, struct conf *src)
1447 : {
1448 : struct strlist *s;
1449 893 : for(s=get_strlist(src); s; s=s->next)
1450 99 : if(add_to_strlist(dst, s->path, s->flag))
1451 : return -1;
1452 : return 0;
1453 : }
1454 :
1455 : // Instead of adding onto the end of the list, this replaces the list.
1456 69 : static int conf_set_from_global_arg_list_overrides(struct conf **globalc,
1457 : struct conf **cc)
1458 : {
1459 69 : int i=0;
1460 12696 : for(i=0; i<OPT_MAX; i++)
1461 : {
1462 12627 : if(cc[i]->conf_type!=CT_STRLIST) continue;
1463 2829 : if(!(cc[i]->flags & CONF_FLAG_CC_OVERRIDE)) continue;
1464 690 : if(cc[i]->flags & CONF_FLAG_STRLIST_REPLACE)
1465 : {
1466 : // If there was no cc[i] strlist set, use the global.
1467 552 : if(!get_strlist(cc[i])
1468 518 : && append_strlist(cc[i], globalc[i]))
1469 : return -1;
1470 : }
1471 : else
1472 : {
1473 : struct conf tmpconf;
1474 : // A bit painful.
1475 138 : tmpconf.conf_type=cc[i]->conf_type;
1476 138 : tmpconf.flags=cc[i]->flags;
1477 138 : memset(&tmpconf.data, 0, sizeof(tmpconf.data));
1478 138 : if(append_strlist(&tmpconf, globalc[i])
1479 138 : || append_strlist(&tmpconf, cc[i]))
1480 0 : return -1;
1481 138 : set_strlist(cc[i], get_strlist(&tmpconf));
1482 : }
1483 : }
1484 : return 0;
1485 : }
1486 :
1487 44 : static int conf_init_save_cname_and_version(struct conf **cconfs)
1488 : {
1489 44 : int ret=-1;
1490 44 : char *cname=NULL;
1491 44 : char *cversion=NULL;
1492 44 : char *orig_cname=get_string(cconfs[OPT_CNAME]);
1493 44 : char *orig_cversion=get_string(cconfs[OPT_PEER_VERSION]);
1494 :
1495 44 : if((orig_cname && !(cname=strdup_w(orig_cname, __func__)))
1496 44 : || (orig_cversion
1497 10 : && !(cversion=strdup_w(orig_cversion, __func__))))
1498 : goto end;
1499 :
1500 44 : set_string(cconfs[OPT_CNAME], NULL);
1501 44 : set_string(cconfs[OPT_PEER_VERSION], NULL);
1502 44 : if(confs_init(cconfs)) goto end;
1503 44 : set_string(cconfs[OPT_CNAME], cname);
1504 44 : set_string(cconfs[OPT_PEER_VERSION], cversion);
1505 44 : ret=0;
1506 : end:
1507 44 : free_w(&cname);
1508 44 : free_w(&cversion);
1509 44 : return ret;
1510 : }
1511 :
1512 73 : static int do_conf_load_overrides(struct conf **globalcs, struct conf **cconfs,
1513 : const char *path, const char *buf)
1514 : {
1515 : // Some client settings can be globally set in the server conf and
1516 : // overridden in the client specific conf.
1517 73 : if(conf_set_from_global(globalcs, cconfs)) return -1;
1518 73 : if(buf) { if(conf_load_lines_from_buf(buf, cconfs)) return -1; }
1519 73 : else { if(conf_load_lines_from_file(path, cconfs)) return -1; }
1520 69 : if(conf_set_from_global_arg_list_overrides(globalcs, cconfs)
1521 69 : || conf_finalise(cconfs))
1522 : return -1;
1523 : return 0;
1524 : }
1525 :
1526 : #ifndef UTEST
1527 : static
1528 : #endif
1529 29 : int conf_load_overrides(struct conf **globalcs, struct conf **cconfs,
1530 : const char *path)
1531 : {
1532 73 : return do_conf_load_overrides(globalcs, cconfs, path, NULL);
1533 : }
1534 :
1535 133 : int cname_valid(const char *cname)
1536 : {
1537 133 : if(!cname) return 0;
1538 133 : if(cname[0]=='.'
1539 127 : || strchr(cname, '/') // Avoid path attacks.
1540 123 : || strchr(cname, '\\') // Be cautious of backslashes too.
1541 : // I am told that emacs tmp files end with '~'.
1542 122 : || cname[strlen(cname)-1]=='~')
1543 : return 0;
1544 120 : return 1;
1545 : }
1546 :
1547 44 : int conf_load_clientconfdir(struct conf **globalcs, struct conf **cconfs)
1548 : {
1549 44 : int ret=-1;
1550 44 : char *path=NULL;
1551 44 : const char *cname=NULL;
1552 :
1553 44 : if(conf_init_save_cname_and_version(cconfs)) goto end;
1554 44 : cname=get_string(cconfs[OPT_CNAME]);
1555 44 : if(!cname_valid(cname))
1556 : {
1557 0 : logp("client name '%s' is not valid\n", cname);
1558 0 : goto end;
1559 : }
1560 :
1561 44 : if(!(path=prepend_s(get_string(globalcs[OPT_CLIENTCONFDIR]), cname)))
1562 : goto end;
1563 88 : ret=conf_load_overrides(globalcs, cconfs, path);
1564 : end:
1565 44 : free_w(&path);
1566 44 : return ret;
1567 : }
1568 :
1569 111 : static int do_load_global_only(struct conf **globalcs,
1570 : const char *path, const char *buf)
1571 : {
1572 111 : if(set_string(globalcs[OPT_CONFFILE], path)) return -1;
1573 111 : if(buf) { if(conf_load_lines_from_buf(buf, globalcs)) return -1; }
1574 111 : else { if(conf_load_lines_from_file(path, globalcs)) return -1; }
1575 111 : if(conf_finalise(globalcs)
1576 108 : || conf_finalise_global_only(path, globalcs))
1577 : return -1;
1578 : return 0;
1579 :
1580 : }
1581 :
1582 111 : int conf_load_global_only(const char *path, struct conf **globalcs)
1583 : {
1584 111 : return do_load_global_only(globalcs, path, NULL);
1585 : }
1586 :
1587 14 : static int restore_client_allowed(struct conf **cconfs, struct conf **sconfs)
1588 : {
1589 : struct strlist *r;
1590 17 : for(r=get_strlist(sconfs[OPT_SUPER_CLIENTS]); r; r=r->next)
1591 8 : if(!strcmp(r->path, get_string(cconfs[OPT_CNAME])))
1592 : return 2;
1593 12 : for(r=get_strlist(sconfs[OPT_RESTORE_CLIENTS]); r; r=r->next)
1594 10 : if(!strcmp(r->path, get_string(cconfs[OPT_CNAME])))
1595 : return 1;
1596 2 : logp("Access to client is not allowed: %s\n",
1597 : get_string(sconfs[OPT_CNAME]));
1598 2 : return 0;
1599 : }
1600 :
1601 15 : int conf_switch_to_orig_client(struct conf **globalcs,
1602 : struct conf **cconfs, const char *orig_client)
1603 : {
1604 15 : int ret=-1;
1605 15 : int is_super=0;
1606 15 : struct conf **sconfs=NULL;
1607 :
1608 : // If we are already the wanted client, no need to switch.
1609 15 : if(!strcmp(get_string(cconfs[OPT_CNAME]), orig_client))
1610 : return 0;
1611 :
1612 15 : if(!(sconfs=confs_alloc())
1613 15 : || confs_init(sconfs)) goto end;
1614 15 : if(set_string(sconfs[OPT_CNAME], orig_client))
1615 : goto end;
1616 15 : logp("Client wants to switch to client: %s\n",
1617 15 : get_string(sconfs[OPT_CNAME]));
1618 :
1619 15 : if(conf_load_clientconfdir(globalcs, sconfs))
1620 : {
1621 1 : logp("Could not load alternate config: %s",
1622 1 : get_string(sconfs[OPT_CNAME]));
1623 1 : goto end;
1624 : }
1625 14 : set_int(sconfs[OPT_SEND_CLIENT_CNTR],
1626 14 : get_int(cconfs[OPT_SEND_CLIENT_CNTR]));
1627 :
1628 14 : switch(restore_client_allowed(cconfs, sconfs))
1629 : {
1630 : case 1:
1631 : break;
1632 : case 2:
1633 5 : is_super=1;
1634 5 : break;
1635 : default:
1636 : goto end;
1637 : }
1638 :
1639 : // Restore client can never force backup.
1640 12 : set_int(sconfs[OPT_CLIENT_CAN_FORCE_BACKUP], 0);
1641 :
1642 12 : if(is_super)
1643 : {
1644 5 : set_int(sconfs[OPT_CLIENT_CAN_DELETE],
1645 5 : get_int(cconfs[OPT_CLIENT_CAN_DELETE]));
1646 5 : set_int(sconfs[OPT_CLIENT_CAN_DIFF],
1647 5 : get_int(cconfs[OPT_CLIENT_CAN_DIFF]));
1648 5 : set_int(sconfs[OPT_CLIENT_CAN_LIST],
1649 5 : get_int(cconfs[OPT_CLIENT_CAN_LIST]));
1650 5 : set_int(sconfs[OPT_CLIENT_CAN_MONITOR],
1651 5 : get_int(cconfs[OPT_CLIENT_CAN_MONITOR]));
1652 5 : set_int(sconfs[OPT_CLIENT_CAN_RESTORE],
1653 5 : get_int(cconfs[OPT_CLIENT_CAN_RESTORE]));
1654 5 : set_int(sconfs[OPT_CLIENT_CAN_VERIFY],
1655 5 : get_int(cconfs[OPT_CLIENT_CAN_VERIFY]));
1656 : }
1657 : else
1658 : {
1659 : // For the rest of the client_can things, do not allow them on
1660 : // orig_client if we do not have them ourselves.
1661 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_DELETE]))
1662 2 : set_int(sconfs[OPT_CLIENT_CAN_DELETE], 0);
1663 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_DIFF]))
1664 2 : set_int(sconfs[OPT_CLIENT_CAN_DIFF], 0);
1665 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_LIST]))
1666 2 : set_int(sconfs[OPT_CLIENT_CAN_LIST], 0);
1667 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_MONITOR]))
1668 2 : set_int(sconfs[OPT_CLIENT_CAN_MONITOR], 0);
1669 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_RESTORE]))
1670 2 : set_int(sconfs[OPT_CLIENT_CAN_RESTORE], 0);
1671 7 : if(!get_int(cconfs[OPT_CLIENT_CAN_VERIFY]))
1672 2 : set_int(sconfs[OPT_CLIENT_CAN_VERIFY], 0);
1673 : }
1674 :
1675 12 : if(set_string(sconfs[OPT_CONNECT_CLIENT],
1676 12 : get_string(cconfs[OPT_CONNECT_CLIENT])))
1677 : goto end;
1678 12 : if(set_string(sconfs[OPT_RESTORE_PATH],
1679 12 : get_string(cconfs[OPT_RESTORE_PATH])))
1680 : goto end;
1681 12 : if(set_string(cconfs[OPT_RESTORE_PATH], NULL))
1682 : goto end;
1683 12 : set_cntr(sconfs[OPT_CNTR], get_cntr(cconfs));
1684 12 : set_cntr(cconfs[OPT_CNTR], NULL);
1685 12 : confs_free_content(cconfs);
1686 12 : confs_init(cconfs);
1687 12 : confs_memcpy(cconfs, sconfs);
1688 12 : confs_null(sconfs);
1689 12 : if(set_string(cconfs[OPT_SUPER_CLIENT],
1690 12 : get_string(cconfs[OPT_CNAME]))) goto end;
1691 12 : if(set_string(cconfs[OPT_ORIG_CLIENT],
1692 12 : get_string(cconfs[OPT_CNAME]))) goto end;
1693 :
1694 12 : logp("Switched to client %s\n", get_string(cconfs[OPT_CNAME]));
1695 12 : ret=0;
1696 : end:
1697 15 : confs_free(&sconfs);
1698 15 : return ret;
1699 : }
1700 :
1701 26 : char *config_default_path(void)
1702 : {
1703 : static char path[256]="";
1704 : #ifdef HAVE_WIN32
1705 : char *pfenv=NULL;
1706 :
1707 : // Burp used to always install to 'C:/Program Files/Burp/', but as
1708 : // of 1.3.11, it changed to %PROGRAMFILES%. Still want the old way
1709 : // to work though. So check %PROGRAMFILES% first, then fall back.
1710 : if((pfenv=getenv("PROGRAMFILES")))
1711 : {
1712 : struct stat statp;
1713 : snprintf(path, sizeof(path), "%s/%s/%s.conf",
1714 : pfenv, PACKAGE_NAME, PACKAGE_TARNAME);
1715 : if(!lstat(path, &statp)
1716 : && !S_ISDIR(statp.st_mode))
1717 : return path;
1718 : }
1719 : snprintf(path, sizeof(path), "C:/Program Files/%s/%s.conf",
1720 : PACKAGE_NAME, PACKAGE_TARNAME);
1721 : #else
1722 26 : snprintf(path, sizeof(path), "%s/%s.conf",
1723 : SYSCONFDIR, PACKAGE_TARNAME);
1724 : #endif
1725 26 : return path;
1726 : }
|
