File indexing completed on 2024-04-28 05:46:49

 /*****************************************************************************
  *   Copyright 2013 - 2015 Yichao Yu <yyc1992@gmail.com>                     *
  *                                                                           *
  *   This program is free software; you can redistribute it and/or modify    *
  *   it under the terms of the GNU Lesser General Public License as          *
  *   published by the Free Software Foundation; either version 2.1 of the    *
  *   License, or (at your option) version 3, or any later version accepted   *
  *   by the membership of KDE e.V. (or its successor approved by the         *
  *   membership of KDE e.V.), which shall act as a proxy defined in          *
  *   Section 6 of version 3 of the license.                                  *
  *                                                                           *
  *   This program is distributed in the hope that it will be useful,         *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       *
  *   Lesser General Public License for more details.                         *
  *                                                                           *
  *   You should have received a copy of the GNU Lesser General Public        *
  *   License along with this library. If not,                                *
  *   see <http://www.gnu.org/licenses/>.                                     *
  *****************************************************************************/
 
 #include "dirs.h"
 #include "log.h"
 #include "strs.h"
 
 #include <config.h>
 
 #include <forward_list>
 
 #include <sys/types.h>
 #include <pwd.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <libgen.h>
 
 namespace QtCurve {
 
 QTC_EXPORT void
 makePath(const char *path, int mode)
 {
     if (isDir(path)) {
         return;
     }
     Str::Buff<1024> opath(path);
     size_t len = opath.size() - 1;
     while (opath[len - 1] == '/') {
         opath[len - 1] = '\0';
         len--;
     }
     char *p = opath.get() + strspn(opath, "/");
     if (!*p) {
         return;
     }
     p += 1;
     for (;*p;p++) {
         if (*p == '/') {
             *p = '\0';
             if (access(opath, F_OK)) {
                 mkdir(opath, mode | 0300);
             }
             *p = '/';
         }
     }
     if (access(opath, F_OK)) {
         mkdir(opath, mode);
     }
 }
 
 // Home
 QTC_EXPORT const char*
 getHome()
 {
     static uniqueStr dir = [] {
         const char *env_home = getenv("HOME");
         if (qtcLikely(env_home && *env_home == '/')) {
             return Str::cat(env_home, "/");
         } else {
             struct passwd *pw = getpwuid(getuid());
             if (qtcLikely(pw && pw->pw_dir && *pw->pw_dir == '/')) {
                 return Str::cat(pw->pw_dir, "/");
             }
         }
         return strdup("/tmp/");
     };
     return dir.get();
 }
 
 // XDG dirs
 QTC_EXPORT const char*
 getXDGConfigHome()
 {
     static uniqueStr dir = [] {
         const char *env_home = getenv("XDG_CONFIG_HOME");
         if (env_home && *env_home == '/') {
             return Str::cat(env_home, "/");
         } else {
             return Str::cat(getHome(), ".config/");
         }
     };
     return dir.get();
 }
 
 QTC_EXPORT const char*
 getXDGDataHome()
 {
     static uniqueStr dir = [] {
         const char *env_home = getenv("XDG_DATA_HOME");
         if (env_home && *env_home == '/') {
             return Str::cat(env_home, "/");
         } else {
             return Str::cat(getHome(), ".local/share/");
         }
     };
     return dir.get();
 }
 
 // TODO
 const std::forward_list<uniqueStr>&
 getKDE4Home()
 {
     static const std::forward_list<uniqueStr> homes = [] {
         std::forward_list<uniqueStr> res;
         auto add_dir = [&] (char *dir) {
             if (isDir(dir)) {
                 res.emplace_front(dir);
             } else {
                 free(dir);
             }
         };
         add_dir(Str::cat(getHome(), ".kde/"));
         add_dir(Str::cat(getHome(), ".kde4/"));
         char *env = getenv(getuid() ? "KDEHOME" : "KDEROOTHOME");
         if (env && env[0] == '/') {
             add_dir(Str::cat(env, "/"));
         } else {
 #ifndef QTC_KDE4_DEFAULT_HOME_DEFAULT
             add_dir(Str::cat(getHome(), QTC_KDE4_DEFAULT_HOME "/"));
 #endif
         }
         return res;
     }();
     return homes;
 }
 
 QTC_EXPORT const char*
 getConfDir()
 {
     static uniqueStr dir = [] {
         const char *env_home = getenv("QTCURVE_CONFIG_DIR");
         char *res = ((env_home && *env_home == '/') ? Str::cat(env_home, "/") :
                      Str::cat(getXDGConfigHome(), "qtcurve/"));
         makePath(res, 0700);
         return res;
     };
     return dir.get();
 }
 
 QTC_EXPORT char*
 getConfFile(const char *file, char *buff)
 {
     if (file[0] == '/')
         return Str::fill(buff, file);
     return Str::fill(buff, getConfDir(), file);
 }
 
 static const std::forward_list<std::string>&
 getPresetDirs()
 {
     static const std::forward_list<std::string> dirs = [] {
         std::forward_list<std::string> res;
         auto add_dir = [&] (const char *dir, bool needfree=true) {
             if (isDir(dir)) {
                 res.emplace_front(dir);
             }
             if (needfree) {
                 free(const_cast<char*>(dir));
             }
         };
         for (auto &kde_home: getKDE4Home()) {
             add_dir(Str::cat(kde_home.get(), "share/apps/QtCurve/"));
         }
         if (auto xdg_data_dirs = getenv("XDG_DATA_DIRS")) {
             while (true) {
                 auto delim = strchr(xdg_data_dirs, ':');
                 if (delim) {
                     auto origin = xdg_data_dirs;
                     xdg_data_dirs = delim + 1;
                     if (origin[0] != '/')
                         continue;
                     std::string dir(origin, delim - origin);
                     dir += "/QtCurve/";
                     if (isDir(dir.c_str())) {
                         res.push_front(std::move(dir));
                     }
                 } else if (xdg_data_dirs[0] == '/') {
                     std::string dir(xdg_data_dirs);
                     dir += "/QtCurve/";
                     if (isDir(dir.c_str()))
                         res.push_front(std::move(dir));
                     break;
                 } else {
                     break;
                 }
             }
         } else {
             add_dir("/usr/local/share/QtCurve/", false);
             add_dir("/usr/share/QtCurve/", false);
         }
         auto xdg_home = Str::cat(getXDGDataHome(), "QtCurve/");
         makePath(xdg_home, 0700);
         add_dir(xdg_home);
         return res;
     }();
     return dirs;
 }
 
 QTC_EXPORT std::map<std::string, std::string>
 getPresets()
 {
     std::map<std::string, std::string> presets;
 
     for (auto &dir_name: getPresetDirs()) {
         DIR *dir = opendir(dir_name.c_str());
         if (!dir)
             continue;
         while (auto ent = readdir(dir)) {
             auto fname = ent->d_name;
             // Non preset files
             if (!Str::endsWith(fname, ".qtcurve"))
                 continue;
             size_t name_len = strlen(fname) - strlen(".qtcurve");
             std::string name(fname, name_len);
             // preset already loaded
             if (presets.find(name) != presets.end())
                 continue;
             presets[name] = dir_name + fname;
         }
         closedir(dir);
     }
 
     return presets;
 }
 
 }