LCOV - code coverage report
Current view: top level - src - conffile.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 499 647 77.1 %
Date: 2018-01-31 Functions: 46 49 93.9 %

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

Generated by: LCOV version 1.10