alc/alconfig.cpp

   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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "alconfig.h"
  24
  25 #include <cstdlib>
  26 #include <cctype>
  27 #include <cstring>
  28 #ifdef _WIN32
  29 #include <windows.h>
  30 #include <shlobj.h>
  31 #endif
  32 #ifdef __APPLE__
  33 #include <CoreFoundation/CoreFoundation.h>
  34 #endif
  35
  36 #include <algorithm>
  37 #include <cstdio>
  38 #include <string>
  39 #include <utility>
  40
  41 #include "alfstream.h"
  42 #include "alstring.h"
  43 #include "compat.h"
  44 #include "logging.h"
  45 #include "strutils.h"
  46 #include "vector.h"
  47
  48
  49 namespace {
  50
  51 struct ConfigEntry {
  52     std::string key;
  53     std::string value;
  54 };
  55 al::vector<ConfigEntry> ConfOpts;
  56
  57
  58 std::string &lstrip(std::string &line)
  59 {
  60     size_t pos{0};
  61     while(pos < line.length() && std::isspace(line[pos]))
  62         ++pos;
  63     line.erase(0, pos);
  64     return line;
  65 }
  66
  67 bool readline(std::istream &f, std::string &output)
  68 {
  69     while(f.good() && f.peek() == '\n')
  70         f.ignore();
  71
  72     return std::getline(f, output) && !output.empty();
  73 }
  74
  75 std::string expdup(const char *str)
  76 {
  77     std::string output;
  78
  79     std::string envval;
  80     while(*str != '\0')
  81     {
  82         const char *addstr;
  83         size_t addstrlen;
  84
  85         if(str[0] != '$')
  86         {
  87             const char *next = std::strchr(str, '$');
  88             addstr = str;
  89             addstrlen = next ? static_cast<size_t>(next-str) : std::strlen(str);
  90
  91             str += addstrlen;
  92         }
  93         else
  94         {
  95             str++;
  96             if(*str == '$')
  97             {
  98                 const char *next = std::strchr(str+1, '$');
  99                 addstr = str;
 100                 addstrlen = next ? static_cast<size_t>(next-str) : std::strlen(str);
 101
 102                 str += addstrlen;
 103             }
 104             else
 105             {
 106                 const bool hasbraces{(*str == '{')};
 107
 108                 if(hasbraces) str++;
 109                 const char *envstart = str;
 110                 while(std::isalnum(*str) || *str == '_')
 111                     ++str;
 112                 if(hasbraces && *str != '}')
 113                     continue;
 114                 const std::string envname{envstart, str};
 115                 if(hasbraces) str++;
 116
 117                 envval = al::getenv(envname.c_str()).value_or(std::string{});
 118                 addstr = envval.data();
 119                 addstrlen = envval.length();
 120             }
 121         }
 122         if(addstrlen == 0)
 123             continue;
 124
 125         output.append(addstr, addstrlen);
 126     }
 127
 128     return output;
 129 }
 130
 131 void LoadConfigFromFile(std::istream &f)
 132 {
 133     std::string curSection;
 134     std::string buffer;
 135
 136     while(readline(f, buffer))
 137     {
 138         if(lstrip(buffer).empty())
 139             continue;
 140
 141         if(buffer[0] == '[')
 142         {
 143             char *line{&buffer[0]};
 144             char *section = line+1;
 145             char *endsection;
 146
 147             endsection = std::strchr(section, ']');
 148             if(!endsection || section == endsection)
 149             {
 150                 ERR(" config parse error: bad line \"%s\"\n", line);
 151                 continue;
 152             }
 153             if(endsection[1] != 0)
 154             {
 155                 char *end = endsection+1;
 156                 while(std::isspace(*end))
 157                     ++end;
 158                 if(*end != 0 && *end != '#')
 159                 {
 160                     ERR(" config parse error: bad line \"%s\"\n", line);
 161                     continue;
 162                 }
 163             }
 164             *endsection = 0;
 165
 166             curSection.clear();
 167             if(al::strcasecmp(section, "general") != 0)
 168             {
 169                 do {
 170                     char *nextp = std::strchr(section, '%');
 171                     if(!nextp)
 172                     {
 173                         curSection += section;
 174                         break;
 175                     }
 176
 177                     curSection.append(section, nextp);
 178                     section = nextp;
 179
 180                     if(((section[1] >= '0' && section[1] <= '9') ||
 181                         (section[1] >= 'a' && section[1] <= 'f') ||
 182                         (section[1] >= 'A' && section[1] <= 'F')) &&
 183                        ((section[2] >= '0' && section[2] <= '9') ||
 184                         (section[2] >= 'a' && section[2] <= 'f') ||
 185                         (section[2] >= 'A' && section[2] <= 'F')))
 186                     {
 187                         int b{0};
 188                         if(section[1] >= '0' && section[1] <= '9')
 189                             b = (section[1]-'0') << 4;
 190                         else if(section[1] >= 'a' && section[1] <= 'f')
 191                             b = (section[1]-'a'+0xa) << 4;
 192                         else if(section[1] >= 'A' && section[1] <= 'F')
 193                             b = (section[1]-'A'+0x0a) << 4;
 194                         if(section[2] >= '0' && section[2] <= '9')
 195                             b |= (section[2]-'0');
 196                         else if(section[2] >= 'a' && section[2] <= 'f')
 197                             b |= (section[2]-'a'+0xa);
 198                         else if(section[2] >= 'A' && section[2] <= 'F')
 199                             b |= (section[2]-'A'+0x0a);
 200                         curSection += static_cast<char>(b);
 201                         section += 3;
 202                     }
 203                     else if(section[1] == '%')
 204                     {
 205                         curSection += '%';
 206                         section += 2;
 207                     }
 208                     else
 209                     {
 210                         curSection += '%';
 211                         section += 1;
 212                     }
 213                 } while(*section != 0);
 214             }
 215
 216             continue;
 217         }
 218
 219         auto cmtpos = std::min(buffer.find('#'), buffer.size());
 220         while(cmtpos > 0 && std::isspace(buffer[cmtpos-1]))
 221             --cmtpos;
 222         if(!cmtpos) continue;
 223         buffer.erase(cmtpos);
 224
 225         auto sep = buffer.find('=');
 226         if(sep == std::string::npos)
 227         {
 228             ERR(" config parse error: malformed option line: \"%s\"\n", buffer.c_str());
 229             continue;
 230         }
 231         auto keyend = sep++;
 232         while(keyend > 0 && std::isspace(buffer[keyend-1]))
 233             --keyend;
 234         if(!keyend)
 235         {
 236             ERR(" config parse error: malformed option line: \"%s\"\n", buffer.c_str());
 237             continue;
 238         }
 239         while(sep < buffer.size() && std::isspace(buffer[sep]))
 240             sep++;
 241
 242         std::string fullKey;
 243         if(!curSection.empty())
 244         {
 245             fullKey += curSection;
 246             fullKey += '/';
 247         }
 248         fullKey += buffer.substr(0u, keyend);
 249
 250         std::string value{(sep < buffer.size()) ? buffer.substr(sep) : std::string{}};
 251         if(value.size() > 1)
 252         {
 253             if((value.front() == '"' && value.back() == '"')
 254                 || (value.front() == '\'' && value.back() == '\''))
 255             {
 256                 value.pop_back();
 257                 value.erase(value.begin());
 258             }
 259         }
 260
 261         TRACE(" found '%s' = '%s'\n", fullKey.c_str(), value.c_str());
 262
 263         /* Check if we already have this option set */
 264         auto find_key = [&fullKey](const ConfigEntry &entry) -> bool
 265         { return entry.key == fullKey; };
 266         auto ent = std::find_if(ConfOpts.begin(), ConfOpts.end(), find_key);
 267         if(ent != ConfOpts.end())
 268         {
 269             if(!value.empty())
 270                 ent->value = expdup(value.c_str());
 271             else
 272                 ConfOpts.erase(ent);
 273         }
 274         else if(!value.empty())
 275             ConfOpts.emplace_back(ConfigEntry{std::move(fullKey), expdup(value.c_str())});
 276     }
 277     ConfOpts.shrink_to_fit();
 278 }
 279
 280 } // namespace
 281
 282
 283 #ifdef _WIN32
 284 void ReadALConfig()
 285 {
 286     WCHAR buffer[MAX_PATH];
 287     if(SHGetSpecialFolderPathW(nullptr, buffer, CSIDL_APPDATA, FALSE) != FALSE)
 288     {
 289         std::string filepath{wstr_to_utf8(buffer)};
 290         filepath += "\\alsoft.ini";
 291
 292         TRACE("Loading config %s...\n", filepath.c_str());
 293         al::ifstream f{filepath};
 294         if(f.is_open())
 295             LoadConfigFromFile(f);
 296     }
 297
 298     std::string ppath{GetProcBinary().path};
 299     if(!ppath.empty())
 300     {
 301         ppath += "\\alsoft.ini";
 302         TRACE("Loading config %s...\n", ppath.c_str());
 303         al::ifstream f{ppath};
 304         if(f.is_open())
 305             LoadConfigFromFile(f);
 306     }
 307
 308     if(auto confpath = al::getenv(L"ALSOFT_CONF"))
 309     {
 310         TRACE("Loading config %s...\n", wstr_to_utf8(confpath->c_str()).c_str());
 311         al::ifstream f{*confpath};
 312         if(f.is_open())
 313             LoadConfigFromFile(f);
 314     }
 315 }
 316
 317 #else
 318
 319 void ReadALConfig()
 320 {
 321     const char *str{"/etc/openal/alsoft.conf"};
 322
 323     TRACE("Loading config %s...\n", str);
 324     al::ifstream f{str};
 325     if(f.is_open())
 326         LoadConfigFromFile(f);
 327     f.close();
 328
 329     std::string confpaths{al::getenv("XDG_CONFIG_DIRS").value_or("/etc/xdg")};
 330     /* Go through the list in reverse, since "the order of base directories
 331      * denotes their importance; the first directory listed is the most
 332      * important". Ergo, we need to load the settings from the later dirs
 333      * first so that the settings in the earlier dirs override them.
 334      */
 335     std::string fname;
 336     while(!confpaths.empty())
 337     {
 338         auto next = confpaths.find_last_of(':');
 339         if(next < confpaths.length())
 340         {
 341             fname = confpaths.substr(next+1);
 342             confpaths.erase(next);
 343         }
 344         else
 345         {
 346             fname = confpaths;
 347             confpaths.clear();
 348         }
 349
 350         if(fname.empty() || fname.front() != '/')
 351             WARN("Ignoring XDG config dir: %s\n", fname.c_str());
 352         else
 353         {
 354             if(fname.back() != '/') fname += "/alsoft.conf";
 355             else fname += "alsoft.conf";
 356
 357             TRACE("Loading config %s...\n", fname.c_str());
 358             f = al::ifstream{fname};
 359             if(f.is_open())
 360                 LoadConfigFromFile(f);
 361         }
 362         fname.clear();
 363     }
 364
 365 #ifdef __APPLE__
 366     CFBundleRef mainBundle = CFBundleGetMainBundle();
 367     if(mainBundle)
 368     {
 369         unsigned char fileName[PATH_MAX];
 370         CFURLRef configURL;
 371
 372         if((configURL=CFBundleCopyResourceURL(mainBundle, CFSTR(".alsoftrc"), CFSTR(""), nullptr)) &&
 373            CFURLGetFileSystemRepresentation(configURL, true, fileName, sizeof(fileName)))
 374         {
 375             f = al::ifstream{reinterpret_cast<char*>(fileName)};
 376             if(f.is_open())
 377                 LoadConfigFromFile(f);
 378         }
 379     }
 380 #endif
 381
 382     if(auto homedir = al::getenv("HOME"))
 383     {
 384         fname = *homedir;
 385         if(fname.back() != '/') fname += "/.alsoftrc";
 386         else fname += ".alsoftrc";
 387
 388         TRACE("Loading config %s...\n", fname.c_str());
 389         f = al::ifstream{fname};
 390         if(f.is_open())
 391             LoadConfigFromFile(f);
 392     }
 393
 394     if(auto configdir = al::getenv("XDG_CONFIG_HOME"))
 395     {
 396         fname = *configdir;
 397         if(fname.back() != '/') fname += "/alsoft.conf";
 398         else fname += "alsoft.conf";
 399     }
 400     else
 401     {
 402         fname.clear();
 403         if(auto homedir = al::getenv("HOME"))
 404         {
 405             fname = *homedir;
 406             if(fname.back() != '/') fname += "/.config/alsoft.conf";
 407             else fname += ".config/alsoft.conf";
 408         }
 409     }
 410     if(!fname.empty())
 411     {
 412         TRACE("Loading config %s...\n", fname.c_str());
 413         f = al::ifstream{fname};
 414         if(f.is_open())
 415             LoadConfigFromFile(f);
 416     }
 417
 418     std::string ppath{GetProcBinary().path};
 419     if(!ppath.empty())
 420     {
 421         if(ppath.back() != '/') ppath += "/alsoft.conf";
 422         else ppath += "alsoft.conf";
 423
 424         TRACE("Loading config %s...\n", ppath.c_str());
 425         f = al::ifstream{ppath};
 426         if(f.is_open())
 427             LoadConfigFromFile(f);
 428     }
 429
 430     if(auto confname = al::getenv("ALSOFT_CONF"))
 431     {
 432         TRACE("Loading config %s...\n", confname->c_str());
 433         f = al::ifstream{*confname};
 434         if(f.is_open())
 435             LoadConfigFromFile(f);
 436     }
 437 }
 438 #endif
 439
 440 const char *GetConfigValue(const char *devName, const char *blockName, const char *keyName, const char *def)
 441 {
 442     if(!keyName)
 443         return def;
 444
 445     std::string key;
 446     if(blockName && al::strcasecmp(blockName, "general") != 0)
 447     {
 448         key = blockName;
 449         if(devName)
 450         {
 451             key += '/';
 452             key += devName;
 453         }
 454         key += '/';
 455         key += keyName;
 456     }
 457     else
 458     {
 459         if(devName)
 460         {
 461             key = devName;
 462             key += '/';
 463         }
 464         key += keyName;
 465     }
 466
 467     auto iter = std::find_if(ConfOpts.cbegin(), ConfOpts.cend(),
 468         [&key](const ConfigEntry &entry) -> bool
 469         { return entry.key == key; }
 470     );
 471     if(iter != ConfOpts.cend())
 472     {
 473         TRACE("Found %s = \"%s\"\n", key.c_str(), iter->value.c_str());
 474         if(!iter->value.empty())
 475             return iter->value.c_str();
 476         return def;
 477     }
 478
 479     if(!devName)
 480     {
 481         TRACE("Key %s not found\n", key.c_str());
 482         return def;
 483     }
 484     return GetConfigValue(nullptr, blockName, keyName, def);
 485 }
 486
 487 int ConfigValueExists(const char *devName, const char *blockName, const char *keyName)
 488 {
 489     const char *val = GetConfigValue(devName, blockName, keyName, "");
 490     return val[0] != 0;
 491 }
 492
 493 al::optional<std::string> ConfigValueStr(const char *devName, const char *blockName, const char *keyName)
 494 {
 495     const char *val = GetConfigValue(devName, blockName, keyName, "");
 496     if(!val[0]) return al::nullopt;
 497
 498     return al::make_optional<std::string>(val);
 499 }
 500
 501 al::optional<int> ConfigValueInt(const char *devName, const char *blockName, const char *keyName)
 502 {
 503     const char *val = GetConfigValue(devName, blockName, keyName, "");
 504     if(!val[0]) return al::nullopt;
 505
 506     return al::make_optional(static_cast<int>(std::strtol(val, nullptr, 0)));
 507 }
 508
 509 al::optional<unsigned int> ConfigValueUInt(const char *devName, const char *blockName, const char *keyName)
 510 {
 511     const char *val = GetConfigValue(devName, blockName, keyName, "");
 512     if(!val[0]) return al::nullopt;
 513
 514     return al::make_optional(static_cast<unsigned int>(std::strtoul(val, nullptr, 0)));
 515 }
 516
 517 al::optional<float> ConfigValueFloat(const char *devName, const char *blockName, const char *keyName)
 518 {
 519     const char *val = GetConfigValue(devName, blockName, keyName, "");
 520     if(!val[0]) return al::nullopt;
 521
 522     return al::make_optional(std::strtof(val, nullptr));
 523 }
 524
 525 al::optional<bool> ConfigValueBool(const char *devName, const char *blockName, const char *keyName)
 526 {
 527     const char *val = GetConfigValue(devName, blockName, keyName, "");
 528     if(!val[0]) return al::nullopt;
 529
 530     return al::make_optional(
 531         al::strcasecmp(val, "true") == 0 || al::strcasecmp(val, "yes") == 0 ||
 532         al::strcasecmp(val, "on") == 0 || atoi(val) != 0);
 533 }
 534
 535 int GetConfigValueBool(const char *devName, const char *blockName, const char *keyName, int def)
 536 {
 537     const char *val = GetConfigValue(devName, blockName, keyName, "");
 538
 539     if(!val[0]) return def != 0;
 540     return (al::strcasecmp(val, "true") == 0 || al::strcasecmp(val, "yes") == 0 ||
 541             al::strcasecmp(val, "on") == 0 || atoi(val) != 0);
 542 }