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