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