LCOV - code coverage report
Current view: top level - src - conffile.c (source / functions) Hit Total Coverage
Test: burp-coverage-clean.info Lines: 400 587 68.1 %
Date: 2016-01-03 Functions: 38 44 86.4 %

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

Generated by: LCOV version 1.10