Alc/alcConfig.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #ifdef _WIN32
  22 #ifdef __MINGW32__
  23 #define _WIN32_IE 0x501
  24 #else
  25 #define _WIN32_IE 0x400
  26 #endif
  27 #endif
  28
  29 #include "config.h"
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <ctype.h>
  34 #include <string.h>
  35 #ifdef _WIN32_IE
  36 #include <shlobj.h>
  37 #endif
  38
  39 #include "alMain.h"
  40 #include "compat.h"
  41
  42
  43 typedef struct ConfigEntry {
  44     char *key;
  45     char *value;
  46 } ConfigEntry;
  47
  48 typedef struct ConfigBlock {
  49     ConfigEntry *entries;
  50     unsigned int entryCount;
  51 } ConfigBlock;
  52 static ConfigBlock cfgBlock;
  53
  54
  55 static char *lstrip(char *line)
  56 {
  57     while(isspace(line[0]))
  58         line++;
  59     return line;
  60 }
  61
  62 static char *rstrip(char *line)
  63 {
  64     size_t len = strlen(line);
  65     while(len > 0 && isspace(line[len-1]))
  66         len--;
  67     line[len] = 0;
  68     return line;
  69 }
  70
  71 static int readline(FILE *f, char **output, size_t *maxlen)
  72 {
  73     size_t len = 0;
  74     int c;
  75
  76     while((c=fgetc(f)) != EOF && (c == '\r' || c == '\n'))
  77         ;
  78     if(c == EOF)
  79         return 0;
  80
  81     do {
  82         if(len+1 >= *maxlen)
  83         {
  84             void *temp = NULL;
  85             size_t newmax;
  86
  87             newmax = (*maxlen ? (*maxlen)<<1 : 32);
  88             if(newmax > *maxlen)
  89                 temp = realloc(*output, newmax);
  90             if(!temp)
  91             {
  92                 ERR("Failed to realloc "SZFMT" bytes from "SZFMT"!\n", newmax, *maxlen);
  93                 return 0;
  94             }
  95
  96             *output = temp;
  97             *maxlen = newmax;
  98         }
  99         (*output)[len++] = c;
 100         (*output)[len] = '\0';
 101     } while((c=fgetc(f)) != EOF && c != '\r' && c != '\n');
 102
 103     return 1;
 104 }
 105
 106
 107 static char *expdup(const char *str)
 108 {
 109     char *output = NULL;
 110     size_t maxlen = 0;
 111     size_t len = 0;
 112
 113     while(*str != '\0')
 114     {
 115         const char *addstr;
 116         size_t addstrlen;
 117         size_t i;
 118
 119         if(str[0] != '$')
 120         {
 121             const char *next = strchr(str, '$');
 122             addstr = str;
 123             addstrlen = next ? (size_t)(next-str) : strlen(str);
 124
 125             str += addstrlen;
 126         }
 127         else
 128         {
 129             str++;
 130             if(*str == '$')
 131             {
 132                 const char *next = strchr(str+1, '$');
 133                 addstr = str;
 134                 addstrlen = next ? (size_t)(next-str) : strlen(str);
 135
 136                 str += addstrlen;
 137             }
 138             else
 139             {
 140                 char envname[1024];
 141                 size_t k = 0;
 142
 143                 while((isalnum(*str) || *str == '_') && k < sizeof(envname)-1)
 144                     envname[k++] = *(str++);
 145                 envname[k++] = '\0';
 146
 147                 if((addstr=getenv(envname)) == NULL)
 148                     continue;
 149                 addstrlen = strlen(addstr);
 150             }
 151         }
 152         if(addstrlen == 0)
 153             continue;
 154
 155         if(addstrlen >= maxlen-len)
 156         {
 157             void *temp = NULL;
 158             size_t newmax;
 159
 160             newmax = len+addstrlen+1;
 161             if(newmax > maxlen)
 162                 temp = realloc(output, newmax);
 163             if(!temp)
 164             {
 165                 ERR("Failed to realloc "SZFMT" bytes from "SZFMT"!\n", newmax, maxlen);
 166                 return output;
 167             }
 168
 169             output = temp;
 170             maxlen = newmax;
 171         }
 172
 173         for(i = 0;i < addstrlen;i++)
 174             output[len++] = addstr[i];
 175         output[len] = '\0';
 176     }
 177
 178     return output ? output : calloc(1, 1);
 179 }
 180
 181
 182 static void LoadConfigFromFile(FILE *f)
 183 {
 184     char curSection[128] = "";
 185     char *buffer = NULL;
 186     size_t maxlen = 0;
 187     ConfigEntry *ent;
 188
 189     while(readline(f, &buffer, &maxlen))
 190     {
 191         char *line, *comment;
 192         char key[256] = "";
 193         char value[256] = "";
 194
 195         comment = strchr(buffer, '#');
 196         if(comment)
 197         {
 198             *(comment++) = 0;
 199             comment = rstrip(lstrip(comment));
 200         }
 201
 202         line = rstrip(lstrip(buffer));
 203         if(!line[0])
 204             continue;
 205
 206         if(line[0] == '[')
 207         {
 208             char *section = line+1;
 209             char *endsection;
 210
 211             endsection = strchr(section, ']');
 212             if(!endsection || section == endsection || endsection[1] != 0)
 213             {
 214                  ERR("config parse error: bad line \"%s\"\n", line);
 215                  continue;
 216             }
 217             *endsection = 0;
 218
 219             if(strcasecmp(section, "general") == 0)
 220                 curSection[0] = 0;
 221             else
 222             {
 223                 strncpy(curSection, section, sizeof(curSection)-1);
 224                 curSection[sizeof(curSection)-1] = 0;
 225             }
 226
 227             continue;
 228         }
 229
 230         if(sscanf(line, "%255[^=] = \"%255[^\"]\"", key, value) == 2 ||
 231            sscanf(line, "%255[^=] = '%255[^\']'", key, value) == 2 ||
 232            sscanf(line, "%255[^=] = %255[^\n]", key, value) == 2)
 233         {
 234             /* sscanf doesn't handle '' or "" as empty values, so clip it
 235              * manually. */
 236             if(strcmp(value, "\"\"") == 0 || strcmp(value, "''") == 0)
 237                 value[0] = 0;
 238         }
 239         else if(sscanf(line, "%255[^=] %255[=]", key, value) == 2)
 240         {
 241             /* Special case for 'key =' */
 242             value[0] = 0;
 243         }
 244         else
 245         {
 246             ERR("config parse error: malformed option line: \"%s\"\n\n", line);
 247             continue;
 248         }
 249         rstrip(key);
 250
 251         if(curSection[0] != 0)
 252         {
 253             size_t len = strlen(curSection);
 254             memmove(&key[len+1], key, sizeof(key)-1-len);
 255             key[len] = '/';
 256             memcpy(key, curSection, len);
 257         }
 258
 259         /* Check if we already have this option set */
 260         ent = cfgBlock.entries;
 261         while((unsigned int)(ent-cfgBlock.entries) < cfgBlock.entryCount)
 262         {
 263             if(strcasecmp(ent->key, key) == 0)
 264                 break;
 265             ent++;
 266         }
 267
 268         if((unsigned int)(ent-cfgBlock.entries) >= cfgBlock.entryCount)
 269         {
 270             /* Allocate a new option entry */
 271             ent = realloc(cfgBlock.entries, (cfgBlock.entryCount+1)*sizeof(ConfigEntry));
 272             if(!ent)
 273             {
 274                  ERR("config parse error: error reallocating config entries\n");
 275                  continue;
 276             }
 277             cfgBlock.entries = ent;
 278             ent = cfgBlock.entries + cfgBlock.entryCount;
 279             cfgBlock.entryCount++;
 280
 281             ent->key = strdup(key);
 282             ent->value = NULL;
 283         }
 284
 285         free(ent->value);
 286         ent->value = expdup(value);
 287
 288         TRACE("found '%s' = '%s'\n", ent->key, ent->value);
 289     }
 290
 291     free(buffer);
 292 }
 293
 294 #ifdef _WIN32
 295 void ReadALConfig(void)
 296 {
 297     WCHAR buffer[PATH_MAX];
 298     const WCHAR *str;
 299     FILE *f;
 300
 301     if(SHGetSpecialFolderPathW(NULL, buffer, CSIDL_APPDATA, FALSE) != FALSE)
 302     {
 303         size_t p = lstrlenW(buffer);
 304         _snwprintf(buffer+p, PATH_MAX-p, L"\\alsoft.ini");
 305
 306         TRACE("Loading config %ls...\n", buffer);
 307         f = _wfopen(buffer, L"rt");
 308         if(f)
 309         {
 310             LoadConfigFromFile(f);
 311             fclose(f);
 312         }
 313     }
 314
 315     if((str=_wgetenv(L"ALSOFT_CONF")) != NULL && *str)
 316     {
 317         TRACE("Loading config %ls...\n", str);
 318         f = _wfopen(str, L"rt");
 319         if(f)
 320         {
 321             LoadConfigFromFile(f);
 322             fclose(f);
 323         }
 324     }
 325 }
 326 #else
 327 void ReadALConfig(void)
 328 {
 329     char buffer[PATH_MAX];
 330     const char *str;
 331     FILE *f;
 332
 333     str = "/etc/openal/alsoft.conf";
 334
 335     TRACE("Loading config %s...\n", str);
 336     f = al_fopen(str, "r");
 337     if(f)
 338     {
 339         LoadConfigFromFile(f);
 340         fclose(f);
 341     }
 342
 343     if(!(str=getenv("XDG_CONFIG_DIRS")) || str[0] == 0)
 344         str = "/etc/xdg";
 345     strncpy(buffer, str, sizeof(buffer)-1);
 346     buffer[sizeof(buffer)-1] = 0;
 347     /* Go through the list in reverse, since "the order of base directories
 348      * denotes their importance; the first directory listed is the most
 349      * important". Ergo, we need to load the settings from the later dirs
 350      * first so that the settings in the earlier dirs override them.
 351      */
 352     while(1)
 353     {
 354         char *next = strrchr(buffer, ':');
 355         if(next) *(next++) = 0;
 356         else next = buffer;
 357
 358         if(next[0] != '/')
 359             WARN("Ignoring XDG config dir: %s\n", next);
 360         else
 361         {
 362             size_t len = strlen(next);
 363             strncpy(next+len, "/alsoft.conf", buffer+sizeof(buffer)-next-len);
 364             buffer[sizeof(buffer)-1] = 0;
 365
 366             TRACE("Loading config %s...\n", next);
 367             f = al_fopen(next, "r");
 368             if(f)
 369             {
 370                 LoadConfigFromFile(f);
 371                 fclose(f);
 372             }
 373         }
 374         if(next == buffer)
 375             break;
 376     }
 377
 378     if((str=getenv("HOME")) != NULL && *str)
 379     {
 380         snprintf(buffer, sizeof(buffer), "%s/.alsoftrc", str);
 381
 382         TRACE("Loading config %s...\n", buffer);
 383         f = al_fopen(buffer, "r");
 384         if(f)
 385         {
 386             LoadConfigFromFile(f);
 387             fclose(f);
 388         }
 389     }
 390
 391     if((str=getenv("XDG_CONFIG_HOME")) != NULL && str[0] != 0)
 392         snprintf(buffer, sizeof(buffer), "%s/%s", str, "alsoft.conf");
 393     else
 394     {
 395         buffer[0] = 0;
 396         if((str=getenv("HOME")) != NULL && str[0] != 0)
 397             snprintf(buffer, sizeof(buffer), "%s/.config/%s", str, "alsoft.conf");
 398     }
 399     if(buffer[0] != 0)
 400     {
 401         TRACE("Loading config %s...\n", buffer);
 402         f = al_fopen(buffer, "r");
 403         if(f)
 404         {
 405             LoadConfigFromFile(f);
 406             fclose(f);
 407         }
 408     }
 409
 410     if((str=getenv("ALSOFT_CONF")) != NULL && *str)
 411     {
 412         TRACE("Loading config %s...\n", str);
 413         f = al_fopen(str, "r");
 414         if(f)
 415         {
 416             LoadConfigFromFile(f);
 417             fclose(f);
 418         }
 419     }
 420 }
 421 #endif
 422
 423 void FreeALConfig(void)
 424 {
 425     unsigned int i;
 426
 427     for(i = 0;i < cfgBlock.entryCount;i++)
 428     {
 429         free(cfgBlock.entries[i].key);
 430         free(cfgBlock.entries[i].value);
 431     }
 432     free(cfgBlock.entries);
 433 }
 434
 435 const char *GetConfigValue(const char *blockName, const char *keyName, const char *def)
 436 {
 437     unsigned int i;
 438     char key[256];
 439
 440     if(!keyName)
 441         return def;
 442
 443     if(blockName && strcasecmp(blockName, "general") != 0)
 444         snprintf(key, sizeof(key), "%s/%s", blockName, keyName);
 445     else
 446     {
 447         strncpy(key, keyName, sizeof(key)-1);
 448         key[sizeof(key)-1] = 0;
 449     }
 450
 451     for(i = 0;i < cfgBlock.entryCount;i++)
 452     {
 453         if(strcasecmp(cfgBlock.entries[i].key, key) == 0)
 454         {
 455             TRACE("Found %s = \"%s\"\n", key, cfgBlock.entries[i].value);
 456             if(cfgBlock.entries[i].value[0])
 457                 return cfgBlock.entries[i].value;
 458             return def;
 459         }
 460     }
 461
 462     TRACE("Key %s not found\n", key);
 463     return def;
 464 }
 465
 466 int ConfigValueExists(const char *blockName, const char *keyName)
 467 {
 468     const char *val = GetConfigValue(blockName, keyName, "");
 469     return !!val[0];
 470 }
 471
 472 int ConfigValueStr(const char *blockName, const char *keyName, const char **ret)
 473 {
 474     const char *val = GetConfigValue(blockName, keyName, "");
 475     if(!val[0]) return 0;
 476
 477     *ret = val;
 478     return 1;
 479 }
 480
 481 int ConfigValueInt(const char *blockName, const char *keyName, int *ret)
 482 {
 483     const char *val = GetConfigValue(blockName, keyName, "");
 484     if(!val[0]) return 0;
 485
 486     *ret = strtol(val, NULL, 0);
 487     return 1;
 488 }
 489
 490 int ConfigValueUInt(const char *blockName, const char *keyName, unsigned int *ret)
 491 {
 492     const char *val = GetConfigValue(blockName, keyName, "");
 493     if(!val[0]) return 0;
 494
 495     *ret = strtoul(val, NULL, 0);
 496     return 1;
 497 }
 498
 499 int ConfigValueFloat(const char *blockName, const char *keyName, float *ret)
 500 {
 501     const char *val = GetConfigValue(blockName, keyName, "");
 502     if(!val[0]) return 0;
 503
 504 #ifdef HAVE_STRTOF
 505     *ret = strtof(val, NULL);
 506 #else
 507     *ret = (float)strtod(val, NULL);
 508 #endif
 509     return 1;
 510 }
 511
 512 int GetConfigValueBool(const char *blockName, const char *keyName, int def)
 513 {
 514     const char *val = GetConfigValue(blockName, keyName, "");
 515
 516     if(!val[0]) return !!def;
 517     return (strcasecmp(val, "true") == 0 || strcasecmp(val, "yes") == 0 ||
 518             strcasecmp(val, "on") == 0 || atoi(val) != 0);
 519 }