path: root/indra/llfilesystem/lldir_win32.cpp

/**
 * @file lldir_win32.cpp
 * @brief Implementation of directory utilities for windows
 *
 * $LicenseInfo:firstyear=2002&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library 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;
 * version 2.1 of the License only.
 *
 * This library 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#if LL_WINDOWS

#include "linden_common.h"

#include "lldir_win32.h"
#include "llerror.h"
#include "llstring.h"
#include "stringize.h"
#include "llfile.h"
#include <shlobj.h>
#include <fstream>

#include <direct.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>

// Utility stuff to get versions of the sh
#define PACKVERSION(major,minor) MAKELONG(minor,major)
DWORD GetDllVersion(LPCTSTR lpszDllName);

namespace
{ // anonymous
    enum class prst { INIT, OPEN, SKIP } state = prst::INIT;
    // This is called so early that we can't count on static objects being
    // properly constructed yet, so declare a pointer instead of an instance.
    std::ofstream* prelogf = nullptr;

    void prelog(const std::string& message)
    {
        boost::optional<std::string> prelog_name;

        switch (state)
        {
        case prst::INIT:
            // assume we failed, until we succeed
            state = prst::SKIP;

            prelog_name = LLStringUtil::getoptenv("PRELOG");
            if (! prelog_name)
                // no PRELOG variable set, carry on
                return;
            prelogf = new llofstream(*prelog_name, std::ios_base::app);
            if (! (prelogf && prelogf->is_open()))
                // can't complain to anybody; how?
                return;
            // got the log file open, cool!
            state = prst::OPEN;
            (*prelogf) << "========================================================================"
                       << std::endl;
            // fall through, don't break

        case prst::OPEN:
            (*prelogf) << message << std::endl;
            break;

        case prst::SKIP:
            // either PRELOG isn't set, or we failed to open that pathname
            break;
        }
    }
} // anonymous namespace

#define PRELOG(expression) prelog(STRINGIZE(expression))

LLDir_Win32::LLDir_Win32()
{
    // set this first: used by append() and add() methods
    mDirDelimiter = "\\";

    WCHAR w_str[MAX_PATH];
    // Application Data is where user settings go. We rely on $APPDATA being
    // correct.
    auto APPDATA = LLStringUtil::getoptenv("APPDATA");
    if (APPDATA)
    {
        mOSUserDir = *APPDATA;
    }
    PRELOG("APPDATA='" << mOSUserDir << "'");
    // On Windows, we could have received a plain-ASCII pathname in which
    // non-ASCII characters have been munged to '?', or the pathname could
    // have been badly encoded and decoded such that we now have garbage
    // instead of a valid path. Check that mOSUserDir actually exists.
    if (mOSUserDir.empty() || ! fileExists(mOSUserDir))
    {
        PRELOG("APPDATA does not exist");
        //HRESULT okay = SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, w_str);
        wchar_t *pwstr = NULL;
        HRESULT okay = SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, NULL, &pwstr);
        PRELOG("SHGetKnownFolderPath(FOLDERID_RoamingAppData) returned " << okay);
        if (SUCCEEDED(okay) && pwstr)
        {
            // But of course, only update mOSUserDir if SHGetKnownFolderPath() works.
            mOSUserDir = ll_convert_wide_to_string(pwstr);
            // Not only that: update our environment so that child processes
            // will see a reasonable value as well.
            _wputenv_s(L"APPDATA", pwstr);
            // SHGetKnownFolderPath() contract requires us to free pwstr
            CoTaskMemFree(pwstr);
            PRELOG("mOSUserDir='" << mOSUserDir << "'");
        }
    }

    // We want cache files to go on the local disk, even if the
    // user is on a network with a "roaming profile".
    //
    // On Vista this is:
    //   C:\Users\James\AppData\Local
    //
    // We used to store the cache in AppData\Roaming, and the installer
    // cleans up that version on upgrade.  JC
    auto LOCALAPPDATA = LLStringUtil::getoptenv("LOCALAPPDATA");
    if (LOCALAPPDATA)
    {
        mOSCacheDir = *LOCALAPPDATA;
    }
    PRELOG("LOCALAPPDATA='" << mOSCacheDir << "'");
    // Windows really does not deal well with pathnames containing non-ASCII
    // characters. See above remarks about APPDATA.
    if (mOSCacheDir.empty() || ! fileExists(mOSCacheDir))
    {
        PRELOG("LOCALAPPDATA does not exist");
        //HRESULT okay = SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, w_str);
        wchar_t *pwstr = NULL;
        HRESULT okay = SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, NULL, &pwstr);
        PRELOG("SHGetKnownFolderPath(FOLDERID_LocalAppData) returned " << okay);
        if (SUCCEEDED(okay) && pwstr)
        {
            // But of course, only update mOSCacheDir if SHGetKnownFolderPath() works.
            mOSCacheDir = ll_convert_wide_to_string(pwstr);
            // Update our environment so that child processes will see a
            // reasonable value as well.
            _wputenv_s(L"LOCALAPPDATA", pwstr);
            // SHGetKnownFolderPath() contract requires us to free pwstr
            CoTaskMemFree(pwstr);
            PRELOG("mOSCacheDir='" << mOSCacheDir << "'");
        }
    }

    if (GetTempPath(MAX_PATH, w_str))
    {
        if (wcslen(w_str))  /* Flawfinder: ignore */
        {
            w_str[wcslen(w_str)-1] = '\0'; /* Flawfinder: ignore */ // remove trailing slash
        }
        mTempDir = utf16str_to_utf8str(llutf16string(w_str));

        if (mOSUserDir.empty())
        {
            mOSUserDir = mTempDir;
        }

        if (mOSCacheDir.empty())
        {
            mOSCacheDir = mTempDir;
        }
    }
    else
    {
        mTempDir = mOSUserDir;
    }

/*==========================================================================*|
    // Now that we've got mOSUserDir, one way or another, let's see how we did
    // with our environment variables.
    {
        auto report = [this](std::ostream& out){
            out << "mOSUserDir  = '" << mOSUserDir  << "'\n"
                << "mOSCacheDir = '" << mOSCacheDir << "'\n"
                << "mTempDir    = '" << mTempDir    << "'" << std::endl;
        };
        int res = LLFile::mkdir(mOSUserDir);
        if (res == -1)
        {
            // If we couldn't even create the directory, just blurt to stderr
            report(std::cerr);
        }
        else
        {
            // successfully created logdir, plunk a log file there
            std::string logfilename(add(mOSUserDir, "lldir.log"));
            std::ofstream logfile(logfilename.c_str());
            if (! logfile.is_open())
            {
                report(std::cerr);
            }
            else
            {
                report(logfile);
            }
        }
    }
|*==========================================================================*/

//  fprintf(stderr, "mTempDir = <%s>",mTempDir);

    // Set working directory, for LLDir::getWorkingDir()
    GetCurrentDirectory(MAX_PATH, w_str);
    mWorkingDir = utf16str_to_utf8str(llutf16string(w_str));

    // Set the executable directory
    S32 size = GetModuleFileName(NULL, w_str, MAX_PATH);
    if (size)
    {
        w_str[size] = '\0';
        mExecutablePathAndName = utf16str_to_utf8str(llutf16string(w_str));
        S32 path_end = mExecutablePathAndName.find_last_of('\\');
        if (path_end != std::string::npos)
        {
            mExecutableDir = mExecutablePathAndName.substr(0, path_end);
            mExecutableFilename = mExecutablePathAndName.substr(path_end+1, std::string::npos);
        }
        else
        {
            mExecutableFilename = mExecutablePathAndName;
        }

    }
    else
    {
        fprintf(stderr, "Couldn't get APP path, assuming current directory!");
        mExecutableDir = mWorkingDir;
        // Assume it's the current directory
    }

    // mAppRODataDir = ".";

    // Determine the location of the App-Read-Only-Data
    // Try the working directory then the exe's dir.
    mAppRODataDir = mWorkingDir;


//  if (mExecutableDir.find("indra") == std::string::npos)

    // *NOTE:Mani - It is a mistake to put viewer specific code in
    // the LLDir implementation. The references to 'skins' and
    // 'llplugin' need to go somewhere else.
    // alas... this also gets called during static initialization
    // time due to the construction of gDirUtil in lldir.cpp.
    if(! LLFile::isdir(add(mAppRODataDir, "skins")))
    {
        // What? No skins in the working dir?
        // Try the executable's directory.
        mAppRODataDir = mExecutableDir;
    }

//  LL_INFOS() << "mAppRODataDir = " << mAppRODataDir << LL_ENDL;

    mSkinBaseDir = add(mAppRODataDir, "skins");

    // Build the default cache directory
    mDefaultCacheDir = buildSLOSCacheDir();

    // Make sure it exists
    int res = LLFile::mkdir(mDefaultCacheDir);
    if (res == -1)
    {
        LL_WARNS() << "Couldn't create LL_PATH_CACHE dir " << mDefaultCacheDir << LL_ENDL;
    }

    mLLPluginDir = add(mExecutableDir, "llplugin");
}

LLDir_Win32::~LLDir_Win32()
{
}

// Implementation

void LLDir_Win32::initAppDirs(const std::string &app_name,
                              const std::string& app_read_only_data_dir)
{
    // Allow override so test apps can read newview directory
    if (!app_read_only_data_dir.empty())
    {
        mAppRODataDir = app_read_only_data_dir;
        mSkinBaseDir = add(mAppRODataDir, "skins");
    }
    mAppName = app_name;
    mOSUserAppDir = add(mOSUserDir, app_name);

    int res = LLFile::mkdir(mOSUserAppDir);
    if (res == -1)
    {
        LL_WARNS() << "Couldn't create app user dir " << mOSUserAppDir << LL_ENDL;
        LL_WARNS() << "Default to base dir" << mOSUserDir << LL_ENDL;
        mOSUserAppDir = mOSUserDir;
    }
    //dumpCurrentDirectories();

    res = LLFile::mkdir(getExpandedFilename(LL_PATH_LOGS,""));
    if (res == -1)
    {
        LL_WARNS() << "Couldn't create LL_PATH_LOGS dir " << getExpandedFilename(LL_PATH_LOGS,"") << LL_ENDL;
    }

    res = LLFile::mkdir(getExpandedFilename(LL_PATH_USER_SETTINGS,""));
    if (res == -1)
    {
        LL_WARNS() << "Couldn't create LL_PATH_USER_SETTINGS dir " << getExpandedFilename(LL_PATH_USER_SETTINGS,"") << LL_ENDL;
    }

    res = LLFile::mkdir(getExpandedFilename(LL_PATH_CACHE,""));
    if (res == -1)
    {
        LL_WARNS() << "Couldn't create LL_PATH_CACHE dir " << getExpandedFilename(LL_PATH_CACHE,"") << LL_ENDL;
    }

    mCAFile = getExpandedFilename( LL_PATH_EXECUTABLE, "ca-bundle.crt" );
}

U32 LLDir_Win32::countFilesInDir(const std::string &dirname, const std::string &mask)
{
    HANDLE count_search_h;
    U32 file_count;

    file_count = 0;

    WIN32_FIND_DATA FileData;

    llutf16string pathname = utf8str_to_utf16str(dirname);
    pathname += utf8str_to_utf16str(mask);

    if ((count_search_h = FindFirstFile(pathname.c_str(), &FileData)) != INVALID_HANDLE_VALUE)
    {
        file_count++;

        while (FindNextFile(count_search_h, &FileData))
        {
            file_count++;
        }

        FindClose(count_search_h);
    }

    return (file_count);
}

std::string LLDir_Win32::getCurPath()
{
    WCHAR w_str[MAX_PATH];
    GetCurrentDirectory(MAX_PATH, w_str);

    return utf16str_to_utf8str(llutf16string(w_str));
}


bool LLDir_Win32::fileExists(const std::string &filename) const
{
    llstat stat_data;
    // Check the age of the file
    // Now, we see if the files we've gathered are recent...
    int res = LLFile::stat(filename, &stat_data);
    if (!res)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


/*virtual*/ std::string LLDir_Win32::getLLPluginLauncher()
{
    return gDirUtilp->getExecutableDir() + gDirUtilp->getDirDelimiter() +
        "SLPlugin.exe";
}

/*virtual*/ std::string LLDir_Win32::getLLPluginFilename(std::string base_name)
{
    return gDirUtilp->getLLPluginDir() + gDirUtilp->getDirDelimiter() +
        base_name + ".dll";
}


#if 0
// Utility function to get version number of a DLL

#define PACKVERSION(major,minor) MAKELONG(minor,major)

DWORD GetDllVersion(LPCTSTR lpszDllName)
{

    HINSTANCE hinstDll;
    DWORD dwVersion = 0;

    hinstDll = LoadLibrary(lpszDllName);    /* Flawfinder: ignore */

    if(hinstDll)
    {
        DLLGETVERSIONPROC pDllGetVersion;

        pDllGetVersion = (DLLGETVERSIONPROC) GetProcAddress(hinstDll, "DllGetVersion");

/*Because some DLLs might not implement this function, you
  must test for it explicitly. Depending on the particular
  DLL, the lack of a DllGetVersion function can be a useful
  indicator of the version.
*/
        if(pDllGetVersion)
        {
            DLLVERSIONINFO dvi;
            HRESULT hr;

            ZeroMemory(&dvi, sizeof(dvi));
            dvi.cbSize = sizeof(dvi);

            hr = (*pDllGetVersion)(&dvi);

            if(SUCCEEDED(hr))
            {
                dwVersion = PACKVERSION(dvi.dwMajorVersion, dvi.dwMinorVersion);
            }
        }

        FreeLibrary(hinstDll);
    }
    return dwVersion;
}
#endif

#endif