468 lines
12 KiB
C++
468 lines
12 KiB
C++
/**
|
|
* @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 "llrand.h" // for gLindenLabRandomNumber
|
|
#include <shlobj.h>
|
|
// <FS:Ansariel> Remove VMP
|
|
#include <Knownfolders.h>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <Objbase.h> // CoTaskMemFree()
|
|
// </FS:Ansariel> Remove VMP
|
|
#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);
|
|
|
|
// <FS:Ansariel> Remove VMP
|
|
namespace {
|
|
|
|
std::string getKnownFolderPath(const std::string& desc, REFKNOWNFOLDERID folderid)
|
|
{
|
|
// https://msdn.microsoft.com/en-us/library/windows/desktop/bb762188(v=vs.85).aspx
|
|
PWSTR wstrptr = 0;
|
|
HRESULT result = SHGetKnownFolderPath(
|
|
folderid,
|
|
KF_FLAG_DEFAULT, // no flags
|
|
NULL, // current user, no impersonation
|
|
&wstrptr);
|
|
if (result == S_OK)
|
|
{
|
|
std::string utf8 = utf16str_to_utf8str(llutf16string(wstrptr));
|
|
// have to free the returned pointer after copying its data
|
|
CoTaskMemFree(wstrptr);
|
|
return utf8;
|
|
}
|
|
|
|
// gack, no logging yet!
|
|
// at least say something to a developer trying to debug this...
|
|
static std::map<HRESULT, const char*> codes
|
|
{
|
|
{ E_FAIL, "E_FAIL; known folder does not have a path?" },
|
|
{ E_INVALIDARG, "E_INVALIDARG; not present on system?" }
|
|
};
|
|
auto found = codes.find(result);
|
|
const char* text = (found == codes.end())? "unknown" : found->second;
|
|
std::cout << "*** SHGetKnownFolderPath(" << desc << ") failed with "
|
|
<< result << " (" << text << ")\n";
|
|
return {};
|
|
}
|
|
|
|
} // anonymous namespace
|
|
// </FS:Ansariel> Remove VMP
|
|
|
|
LLDir_Win32::LLDir_Win32()
|
|
{
|
|
// set this first: used by append() and add() methods
|
|
mDirDelimiter = "\\";
|
|
|
|
// Application Data is where user settings go. We rely on $APPDATA being
|
|
// correct; in fact the VMP makes a point of setting it properly, since
|
|
// Windows itself botches the job for non-ASCII usernames (MAINT-8087).
|
|
// <FS:Ansariel> Remove VMP
|
|
//mOSUserDir = ll_safe_string(getenv("APPDATA"));
|
|
mOSUserDir = getKnownFolderPath("RoamingAppData", FOLDERID_RoamingAppData);
|
|
// </FS:Ansariel> Remove VMP
|
|
|
|
// 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
|
|
// <FS:Ansariel> Remove VMP
|
|
//mOSCacheDir = ll_safe_string(getenv("LOCALAPPDATA"));
|
|
mOSCacheDir = getKnownFolderPath("LocalAppData", FOLDERID_LocalAppData);
|
|
// </FS:Ansariel> Remove VMP
|
|
|
|
WCHAR w_str[MAX_PATH];
|
|
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);
|
|
|
|
#if 1
|
|
// Don't use the real app path for now, as we'll have to add parsing to detect if
|
|
// we're in a developer tree, which has a different structure from the installed product.
|
|
|
|
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;
|
|
}
|
|
GetCurrentDirectory(MAX_PATH, w_str);
|
|
mWorkingDir = utf16str_to_utf8str(llutf16string(w_str));
|
|
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("AppInit") << "Couldn't get APP path, assuming current directory!\n" << LL_ENDL;
|
|
GetCurrentDirectory(MAX_PATH, w_str);
|
|
mExecutableDir = utf16str_to_utf8str(llutf16string(w_str));
|
|
// Assume it's the current directory
|
|
}
|
|
#else
|
|
GetCurrentDirectory(MAX_PATH, w_str);
|
|
mExecutableDir = utf16str_to_utf8str(llutf16string(w_str));
|
|
#endif
|
|
|
|
|
|
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")) || ! LLFile::isdir(add(mAppRODataDir, "app_settings")))
|
|
{
|
|
// What? No skins or app_settings 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 = gDirUtilp->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);
|
|
}
|
|
|
|
|
|
// get the next file in the directory
|
|
// AO: Used by LGG selection beams
|
|
BOOL LLDir_Win32::getNextFileInDir(const std::string &dirname, const std::string &mask, std::string &fname)
|
|
{
|
|
BOOL fileFound = FALSE;
|
|
fname = "";
|
|
|
|
WIN32_FIND_DATAW FileData;
|
|
llutf16string pathname = utf8str_to_utf16str(dirname) + utf8str_to_utf16str(mask);
|
|
|
|
if (pathname != mCurrentDir)
|
|
{
|
|
// different dir specified, close old search
|
|
if (mCurrentDir[0])
|
|
{
|
|
FindClose(mDirSearch_h);
|
|
}
|
|
mCurrentDir = pathname;
|
|
|
|
// and open new one
|
|
// Check error opening Directory structure
|
|
if ((mDirSearch_h = FindFirstFile(pathname.c_str(), &FileData)) != INVALID_HANDLE_VALUE)
|
|
{
|
|
fileFound = TRUE;
|
|
}
|
|
}
|
|
|
|
// Loop to skip over the current (.) and parent (..) directory entries
|
|
// (apparently returned in Win7 but not XP)
|
|
do
|
|
{
|
|
if ( fileFound
|
|
&& ( (lstrcmp(FileData.cFileName, (LPCTSTR)TEXT(".")) == 0)
|
|
||(lstrcmp(FileData.cFileName, (LPCTSTR)TEXT("..")) == 0)
|
|
)
|
|
)
|
|
{
|
|
fileFound = FALSE;
|
|
}
|
|
} while ( mDirSearch_h != INVALID_HANDLE_VALUE
|
|
&& !fileFound
|
|
&& (fileFound = FindNextFile(mDirSearch_h, &FileData)
|
|
)
|
|
);
|
|
|
|
if (!fileFound && GetLastError() == ERROR_NO_MORE_FILES)
|
|
{
|
|
// No more files, so reset to beginning of directory
|
|
FindClose(mDirSearch_h);
|
|
mCurrentDir[0] = '\000';
|
|
}
|
|
|
|
if (fileFound)
|
|
{
|
|
// convert from TCHAR to char
|
|
fname = utf16str_to_utf8str(FileData.cFileName);
|
|
}
|
|
|
|
return fileFound;
|
|
}
|
|
|
|
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
|
|
|
|
|