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