600 lines
16 KiB
C++
600 lines
16 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
#include "windows.h"
|
|
#include "windef.h"
|
|
#include <shlobj.h>
|
|
#include <Rpc.h>
|
|
#elif __linux__
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <dirent.h>
|
|
#elif MAC
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <dirent.h>
|
|
#elif _IOS
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <dirent.h>
|
|
#endif
|
|
|
|
#include <string.h>
|
|
#include "Directory.h"
|
|
|
|
namespace NSDirectory
|
|
{
|
|
#if !defined(_WIN32) && !defined (_WIN64)
|
|
static bool is_directory_exist(char* dir)
|
|
{
|
|
#ifdef __ANDROID__
|
|
if (0 == strcmp("/storage/emulated", dir))
|
|
return true;
|
|
#endif
|
|
struct stat st;
|
|
bool bRes = (0 == stat(dir, &st)) && S_ISDIR(st.st_mode);
|
|
return bRes;
|
|
}
|
|
|
|
static bool _mkdir (const char *dir)
|
|
{
|
|
char tmp[MAX_PATH];
|
|
char *p = NULL;
|
|
size_t len;
|
|
bool res = true;
|
|
|
|
snprintf(tmp, sizeof(tmp),"%s",dir);
|
|
len = strlen(tmp);
|
|
if(tmp[len - 1] == '/')
|
|
tmp[len - 1] = 0;
|
|
for(p = tmp + 1; *p; p++)
|
|
if(*p == '/') {
|
|
*p = 0;
|
|
res = is_directory_exist(tmp);
|
|
if (!res)
|
|
res = (0 == mkdir(tmp, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
|
|
*p = '/';
|
|
if (!res)
|
|
break;
|
|
}
|
|
if (res)
|
|
res = (0 == mkdir(tmp, S_IRWXU));
|
|
return res;
|
|
}
|
|
#endif
|
|
|
|
void GetFiles2(std::wstring strDirectory, std::vector<std::wstring>& oArray, bool bIsRecursion)
|
|
{
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
WIN32_FIND_DATAW oFD;
|
|
|
|
std::wstring sSpec = strDirectory + L"\\*.*";
|
|
HANDLE hRes = FindFirstFileW( sSpec.c_str(), &oFD );
|
|
if( INVALID_HANDLE_VALUE == hRes )
|
|
return;
|
|
do
|
|
{
|
|
sSpec = oFD.cFileName;
|
|
if (sSpec != L"." && sSpec != L"..")
|
|
{
|
|
sSpec = strDirectory + L"\\" + sSpec;
|
|
if( !( oFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
|
|
{
|
|
oArray.push_back(sSpec);
|
|
}
|
|
else if (bIsRecursion)
|
|
{
|
|
GetFiles2(sSpec, oArray, bIsRecursion);
|
|
}
|
|
}
|
|
} while( FindNextFileW( hRes, &oFD ) );
|
|
FindClose( hRes );
|
|
#endif
|
|
|
|
#ifdef __linux__
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir((char*)pUtf8)) != NULL)
|
|
{
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
int nType = 0;
|
|
if(DT_REG == dirp->d_type)
|
|
nType = 2;
|
|
else if (DT_DIR == dirp->d_type)
|
|
nType = 1;
|
|
else if (DT_UNKNOWN == dirp->d_type)
|
|
{
|
|
// XFS problem
|
|
struct stat buff;
|
|
std::string sTmp = std::string((char*)pUtf8) + "/" + std::string(dirp->d_name);
|
|
stat(sTmp.c_str(), &buff);
|
|
if (S_ISREG(buff.st_mode))
|
|
nType = 2;
|
|
else if (S_ISDIR(buff.st_mode))
|
|
nType = 1;
|
|
}
|
|
|
|
if (2 == nType)
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
oArray.push_back(strDirectory + L"/" + sName);
|
|
}
|
|
|
|
if (bIsRecursion && (1 == nType))
|
|
{
|
|
if(dirp->d_name[0] != '.')
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
GetFiles2(strDirectory + L"/" + sName, oArray, bIsRecursion);
|
|
}
|
|
}
|
|
}
|
|
closedir(dp);
|
|
}
|
|
delete [] pUtf8;
|
|
#endif
|
|
|
|
#if defined(MAC) || defined (_IOS)
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir((char*)pUtf8)) != NULL)
|
|
{
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
if(DT_REG == dirp->d_type)
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
oArray.push_back(strDirectory + L"/" + sName);
|
|
}
|
|
|
|
if (bIsRecursion && DT_DIR == dirp->d_type)
|
|
{
|
|
if(dirp->d_name[0] != '.')
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
GetFiles2(strDirectory + L"/" + sName, oArray, bIsRecursion);
|
|
}
|
|
}
|
|
}
|
|
closedir(dp);
|
|
}
|
|
delete [] pUtf8;
|
|
return;
|
|
#endif
|
|
}
|
|
|
|
std::vector<std::wstring> GetFiles(std::wstring strDirectory, bool bIsRecursion)
|
|
{
|
|
std::vector<std::wstring> oArray;
|
|
|
|
if (!strDirectory.empty())
|
|
{
|
|
GetFiles2(strDirectory, oArray, bIsRecursion);
|
|
}
|
|
return oArray;
|
|
}
|
|
std::vector<std::wstring> GetDirectories(std::wstring strDirectory)
|
|
{
|
|
std::vector<std::wstring> oArray;
|
|
|
|
if (strDirectory.empty()) return oArray;
|
|
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
WIN32_FIND_DATAW oFD;
|
|
|
|
std::wstring sSpec = strDirectory + L"\\*";
|
|
HANDLE hRes = FindFirstFileW( sSpec.c_str(), &oFD );
|
|
if( INVALID_HANDLE_VALUE == hRes )
|
|
return oArray;
|
|
do
|
|
{
|
|
sSpec = oFD.cFileName;
|
|
if (sSpec != L"." && sSpec != L"..")
|
|
{
|
|
sSpec = strDirectory + L"\\" + sSpec;
|
|
if( oFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
|
|
{
|
|
oArray.push_back(sSpec);
|
|
}
|
|
}
|
|
} while( FindNextFileW( hRes, &oFD ) );
|
|
FindClose( hRes );
|
|
#elif __linux__
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir((char*)pUtf8)) != NULL)
|
|
{
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
bool bIsDir = false;
|
|
if (DT_DIR == dirp->d_type)
|
|
bIsDir = true;
|
|
else if (DT_UNKNOWN == dirp->d_type)
|
|
{
|
|
// XFS problem
|
|
struct stat buff;
|
|
std::string sTmp = std::string((char*)pUtf8) + "/" + std::string(dirp->d_name);
|
|
stat(sTmp.c_str(), &buff);
|
|
if (S_ISDIR(buff.st_mode))
|
|
bIsDir = true;
|
|
}
|
|
if(bIsDir)
|
|
{
|
|
if(dirp->d_name[0] != '.')
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
oArray.push_back(strDirectory + L"/" + sName);
|
|
}
|
|
}
|
|
}
|
|
closedir(dp);
|
|
}
|
|
delete [] pUtf8;
|
|
#elif MAC
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir((char*)pUtf8)) != NULL)
|
|
{
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
if(DT_DIR == dirp->d_type)
|
|
{
|
|
if(dirp->d_name[0] != '.')
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
oArray.push_back(strDirectory + L"/" + sName);
|
|
}
|
|
}
|
|
}
|
|
closedir(dp);
|
|
}
|
|
delete [] pUtf8;
|
|
#endif
|
|
return oArray;
|
|
}
|
|
bool Exists(const std::wstring& strDirectory)
|
|
{
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
DWORD dwAttrib = ::GetFileAttributesW(strDirectory.c_str());
|
|
return (dwAttrib != INVALID_FILE_ATTRIBUTES && 0 != (dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
|
|
#elif __linux__
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
bool bRes = is_directory_exist((char*)pUtf8);
|
|
delete [] pUtf8;
|
|
return bRes;
|
|
#elif MAC
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
struct stat st;
|
|
bool bRes = is_directory_exist((char*)pUtf8);
|
|
delete [] pUtf8;
|
|
return bRes;
|
|
#endif
|
|
return false;
|
|
}
|
|
bool CreateDirectory(const std::wstring& strDirectory)
|
|
{
|
|
if (Exists(strDirectory) == true) return true;
|
|
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
return FALSE != ::CreateDirectoryW(strDirectory.c_str(), NULL);
|
|
#else
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
struct stat st;
|
|
int nRes = 0;
|
|
if (stat((char*)pUtf8, &st) == -1) {
|
|
nRes = mkdir((char*)pUtf8, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
|
|
}
|
|
delete [] pUtf8;
|
|
return 0 == nRes;
|
|
#endif
|
|
}
|
|
bool CreateDirectories(const std::wstring& strDirectory)
|
|
{
|
|
if (Exists(strDirectory) == true) return true;
|
|
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
DWORD dwAttrib = ::GetFileAttributesW(strDirectory.c_str());
|
|
if (dwAttrib != INVALID_FILE_ATTRIBUTES && 0 != (dwAttrib & FILE_ATTRIBUTE_DIRECTORY)) return true;
|
|
|
|
int codeResult = ERROR_SUCCESS;
|
|
|
|
SECURITY_ATTRIBUTES sa={};
|
|
|
|
if (strDirectory.find(L"./") == 0)
|
|
{
|
|
std::wstring sDir = NSFile::GetProcessDirectory() + L"/" + strDirectory;
|
|
codeResult = SHCreateDirectoryExW(NULL, sDir.c_str(), &sa);
|
|
}
|
|
else
|
|
codeResult = SHCreateDirectoryExW(NULL, strDirectory.c_str(), &sa);
|
|
|
|
bool created = false;
|
|
if (codeResult == ERROR_SUCCESS)
|
|
created = true;
|
|
|
|
return created;
|
|
#else
|
|
std::string pathUtf8 = U_TO_UTF8(strDirectory);
|
|
return _mkdir (pathUtf8.c_str());
|
|
#endif
|
|
return false;
|
|
}
|
|
bool CopyDirectory(const std::wstring& strSrc, const std::wstring& strDst, bool bIsRecursion)
|
|
{
|
|
if (!NSDirectory::Exists(strDst))
|
|
NSDirectory::CreateDirectory(strDst);
|
|
|
|
#ifdef WIN32
|
|
WIN32_FIND_DATAW oFD;
|
|
|
|
std::wstring sSpec = strSrc + L"\\*.*";
|
|
HANDLE hRes = FindFirstFileW( sSpec.c_str(), &oFD );
|
|
if( INVALID_HANDLE_VALUE == hRes )
|
|
return false;
|
|
do
|
|
{
|
|
sSpec = oFD.cFileName;
|
|
if (sSpec != L"." && sSpec != L"..")
|
|
{
|
|
if( !( oFD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
|
|
{
|
|
NSFile::CFileBinary::Copy(strSrc + L"/" + sSpec, strDst + L"/" + sSpec);
|
|
}
|
|
else if (bIsRecursion)
|
|
{
|
|
CopyDirectory(strSrc + L"/" + sSpec, strDst + L"/" + sSpec, bIsRecursion);
|
|
}
|
|
}
|
|
} while( FindNextFileW( hRes, &oFD ) );
|
|
FindClose( hRes );
|
|
return true;
|
|
#endif
|
|
|
|
#ifdef __linux__
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strSrc.c_str(), strSrc.length(), pUtf8, lLen, false);
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir((char*)pUtf8)) != NULL)
|
|
{
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
int nType = 0;
|
|
if(DT_REG == dirp->d_type)
|
|
nType = 2;
|
|
else if (DT_DIR == dirp->d_type)
|
|
nType = 1;
|
|
else if (DT_UNKNOWN == dirp->d_type)
|
|
{
|
|
// XFS problem
|
|
struct stat buff;
|
|
std::string sTmp = std::string((char*)pUtf8) + "/" + std::string(dirp->d_name);
|
|
stat(sTmp.c_str(), &buff);
|
|
if (S_ISREG(buff.st_mode))
|
|
nType = 2;
|
|
else if (S_ISDIR(buff.st_mode))
|
|
nType = 1;
|
|
}
|
|
|
|
if (2 == nType)
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
NSFile::CFileBinary::Copy(strSrc + L"/" + sName, strDst + L"/" + sName);
|
|
}
|
|
|
|
if (bIsRecursion && (1 == nType))
|
|
{
|
|
if(dirp->d_name[0] != '.')
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
CopyDirectory(strSrc + L"/" + sName, strDst + L"/" + sName, bIsRecursion);
|
|
}
|
|
}
|
|
}
|
|
closedir(dp);
|
|
}
|
|
delete [] pUtf8;
|
|
return true;
|
|
#endif
|
|
|
|
#if defined(MAC) || defined (_IOS)
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strSrc.c_str(), strSrc.length(), pUtf8, lLen, false);
|
|
DIR *dp;
|
|
struct dirent *dirp;
|
|
if((dp = opendir((char*)pUtf8)) != NULL)
|
|
{
|
|
while ((dirp = readdir(dp)) != NULL)
|
|
{
|
|
if(DT_REG == dirp->d_type)
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
NSFile::CFileBinary::Copy(strSrc + L"/" + sName, strDst + L"/" + sName);
|
|
}
|
|
|
|
if (bIsRecursion && DT_DIR == dirp->d_type)
|
|
{
|
|
if(dirp->d_name[0] != '.')
|
|
{
|
|
std::wstring sName = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)dirp->d_name, strlen(dirp->d_name));
|
|
CopyDirectory(strSrc + L"/" + sName, strDst + L"/" + sName, bIsRecursion);
|
|
}
|
|
}
|
|
}
|
|
closedir(dp);
|
|
}
|
|
delete [] pUtf8;
|
|
return true;
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
void DeleteDirectory(const std::wstring& strDirectory, bool deleteRoot)
|
|
{
|
|
if (strDirectory.empty()) return;
|
|
|
|
std::vector<std::wstring> aFiles = GetFiles(strDirectory);
|
|
for(size_t i = 0; i < aFiles.size(); ++i)
|
|
{
|
|
NSFile::CFileBinary::Remove(aFiles[i]);
|
|
}
|
|
std::vector<std::wstring> aDirectories = GetDirectories(strDirectory);
|
|
for(size_t i = 0; i < aDirectories.size(); ++i)
|
|
{
|
|
DeleteDirectory(aDirectories[i]);
|
|
}
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
if (deleteRoot) RemoveDirectoryW(strDirectory.c_str());
|
|
#elif __linux__
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
rmdir((char*)pUtf8);
|
|
delete [] pUtf8;
|
|
|
|
if (deleteRoot == false)CreateDirectory(strDirectory);
|
|
#elif MAC
|
|
BYTE* pUtf8 = NULL;
|
|
LONG lLen = 0;
|
|
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strDirectory.c_str(), strDirectory.length(), pUtf8, lLen, false);
|
|
rmdir((char*)pUtf8);
|
|
delete [] pUtf8;
|
|
|
|
if (deleteRoot == false)CreateDirectory(strDirectory);
|
|
#endif
|
|
}
|
|
std::wstring GetFolderPath(const std::wstring& wsFolderPath)
|
|
{
|
|
#ifdef _WIN32
|
|
std::wstring::size_type nPos1 = wsFolderPath.rfind('\\');
|
|
#else
|
|
std::wstring::size_type nPos1 = std::wstring::npos;
|
|
#endif
|
|
std::wstring::size_type nPos2 = wsFolderPath.rfind('/');
|
|
std::wstring::size_type nPos = std::wstring::npos;
|
|
|
|
if (nPos1 != std::wstring::npos)
|
|
{
|
|
nPos = nPos1;
|
|
if (nPos2 != std::wstring::npos && nPos2 > nPos)
|
|
nPos = nPos2;
|
|
}
|
|
else
|
|
nPos = nPos2;
|
|
|
|
if (nPos == std::wstring::npos)
|
|
return wsFolderPath;
|
|
return wsFolderPath.substr(0, nPos);
|
|
}
|
|
std::wstring CreateTempFileWithUniqueName (const std::wstring & strFolderPathRoot, std::wstring Prefix)
|
|
{
|
|
return NSFile::CFileBinary::CreateTempFileWithUniqueName(strFolderPathRoot, Prefix);
|
|
}
|
|
std::wstring CreateDirectoryWithUniqueName (const std::wstring & strFolderPathRoot)
|
|
{
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
UUID uuid;
|
|
RPC_WSTR str_uuid;
|
|
UuidCreate (&uuid);
|
|
UuidToStringW (&uuid, &str_uuid);
|
|
std::wstring pcTemplate = strFolderPathRoot + FILE_SEPARATOR_STR;
|
|
pcTemplate += (wchar_t *) str_uuid;
|
|
RpcStringFreeW (&str_uuid);
|
|
|
|
int attemps = 10;
|
|
while (!CreateDirectory(pcTemplate))
|
|
{
|
|
UuidCreate (&uuid);
|
|
UuidToStringW (&uuid, &str_uuid);
|
|
pcTemplate = strFolderPathRoot + FILE_SEPARATOR_STR;
|
|
pcTemplate += (wchar_t *) str_uuid;
|
|
RpcStringFreeW (&str_uuid);
|
|
attemps--;
|
|
|
|
if (0 == attemps)
|
|
{
|
|
pcTemplate = L"";
|
|
break;
|
|
}
|
|
}
|
|
return pcTemplate;
|
|
#else
|
|
std::string pcTemplate = U_TO_UTF8(strFolderPathRoot) + "/ascXXXXXX";
|
|
char *pcRes = mkdtemp(const_cast <char *> (pcTemplate.c_str()));
|
|
if (NULL == pcRes)
|
|
return L"";
|
|
|
|
std::string sRes = pcRes;
|
|
return NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)sRes.c_str(), (LONG)sRes.length());
|
|
#endif
|
|
}
|
|
std::wstring GetTempPath()
|
|
{
|
|
return NSFile::CFileBinary::GetTempPath();
|
|
}
|
|
|
|
int GetFilesCount(const std::wstring& path, const bool& recursive)
|
|
{
|
|
std::vector<std::wstring> arrFiles = NSDirectory::GetFiles(path, recursive);
|
|
return (int)arrFiles.size();
|
|
}
|
|
bool PathIsDirectory(const std::wstring& pathName)
|
|
{
|
|
return Exists(pathName);
|
|
}
|
|
}
|