BOOL CZipException::GetErrorMessage(LPTSTR lpszError, UINT nMaxError,
UINT* )
{
if (!lpszError || !nMaxError)
return FALSE;
CZipString sz = GetErrorDescription();
if (sz.IsEmpty())
return FALSE;
UINT iLen = sz.GetLength();
if (nMaxError - 1 < iLen)
iLen = nMaxError - 1;
LPTSTR lpsz = sz.GetBuffer(iLen);
#if _MSC_VER >= 1400
#ifdef _UNICODE
wcsncpy_s(lpszError, nMaxError, lpsz, iLen);
#else
strncpy_s(lpszError, nMaxError, lpsz, iLen);
#endif
#else
#ifdef _UNICODE
wcsncpy(lpszError, lpsz, iLen);
#else
strncpy(lpszError, lpsz, iLen);
#endif
#endif
lpszError[iLen] = _T('\0');
return TRUE;
}
void CZipPathComponent::SetFullPath(LPCTSTR lpszFullPath)
{
TCHAR szDrive[_MAX_DRIVE];
TCHAR szDir[_MAX_DIR];
TCHAR szFname[_MAX_FNAME];
TCHAR szExt[_MAX_EXT];
CZipString szTempPath(lpszFullPath);
const CZipString szPrefix = _T("\\\\?\\unc\\");
int i = -1, iLen = szPrefix.GetLength();
if (iLen > szTempPath.GetLength())
iLen = szTempPath.GetLength();
CZipString szPossiblePrefix = szTempPath.Left(iLen);
szPossiblePrefix.MakeLower(); // must perform case insensitive comparison
while (++i < iLen && szPossiblePrefix[i] == szPrefix[i]);
if (i == 2 || i == 4 || i == 8) // unc path, unicode path or unc path meeting windows file name conventions
{
m_szPrefix = szTempPath.Left(i);
szTempPath = szTempPath.Mid(i);
}
else
m_szPrefix.Empty();
_tsplitpath(szTempPath, szDrive , szDir, szFname, szExt);
m_szDrive = szDrive;
m_szDirectory = szDir;
m_szDirectory.TrimLeft(m_cSeparator);
m_szDirectory.TrimRight(m_cSeparator);
SetExtension(szExt);
m_szFileTitle = szFname;
}
void DocXDocumentStore::GetDocumentTexts(const CStdString& sFileName, std::vector<std::string>& vDocumentTexts) const
{
vDocumentTexts.clear();
CZipArchive zipArchive;
zipArchive.Open(sFileName, CZipArchive::zipOpenReadOnly);
if( !zipArchive.IsClosed() )
{
CZipWordArray ar;
zipArchive.FindMatches( L"word\\\\*.xml", ar );
for( int uIndex = 0; uIndex < ar.GetSize(); uIndex++ )
{
CZipFileHeader fhInfo;
if( zipArchive.GetFileInfo( fhInfo, ar[uIndex] ) )
{
const CZipString fileName( fhInfo.GetFileName() );
if( fileName.find_first_of( '\\' ) == fileName.find_last_of( '\\' ) )
{
C2007DocFile mf;
zipArchive.ExtractFile( ar[uIndex], mf );
const CStdStringA sDocText = mf.GetWTInnerText();
if( sDocText.size() > 0 )
vDocumentTexts.push_back( sDocText );
}
}
}
zipArchive.Flush();
zipArchive.Close();
}
}
int ZipPlatform::SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide, bool bUseAnsi)
{
int singleLen = szSingle.GetSize();
// iLen doesn't include terminating character
UINT uCodePage;
DWORD dwFlags;
if (bUseAnsi)
{
uCodePage = CP_ACP;
dwFlags = MB_PRECOMPOSED;
}
else
{
uCodePage = CP_UTF8;
dwFlags = 0;
}
int iLen = MultiByteToWideChar(uCodePage, dwFlags, szSingle.GetBuffer(), singleLen, NULL, 0);
if (iLen > 0)
{
iLen = MultiByteToWideChar(uCodePage, dwFlags, szSingle.GetBuffer(), singleLen,
szWide.GetBuffer(iLen) , iLen);
szWide.ReleaseBuffer(iLen);
ASSERT(iLen != 0);
}
else
{
szWide.Empty();
iLen --; // return -1
}
return iLen;
}
CZipString CZipPathComponent::GetNoDrive() const
{
CZipString szPath = m_szDirectory;
CZipString szFileName = GetFileName();
if (!szFileName.IsEmpty() && !szPath.IsEmpty())
szPath += m_cSeparator;
szPath += szFileName;
return szPath;
}
void CZipPathComponent::SetFullPath(LPCTSTR lpszFullPath)
{
CZipString szTempPath(lpszFullPath);
const CZipString szPrefix = _T("\\\\?\\unc\\");
int i = -1, iLen = szPrefix.GetLength();
if (iLen > szTempPath.GetLength())
iLen = szTempPath.GetLength();
CZipString szPossiblePrefix = szTempPath.Left(iLen);
szPossiblePrefix.MakeLower(); // must perform case insensitive comparison
while (++i < iLen && szPossiblePrefix[i] == szPrefix[i]);
if (i == 2 || i == 4 || i == 8) // unc path, Unicode path or unc path meeting windows file name conventions
{
m_szPrefix = szTempPath.Left(i);
szTempPath = szTempPath.Mid(i);
}
else
m_szPrefix.Empty();
m_szDrive.Empty();
m_szFileTitle.Empty();
m_szDirectory.Empty();
m_szFileExt.Empty();
int p;
for (p = szTempPath.GetLength() - 1; p >= 0; p--)
if (szTempPath[p] == m_cSeparator)
break;
if (p != -1)
{
m_szDirectory = szTempPath.Left(p);
if (p == szTempPath.GetLength() - 1 )
return; // no filename present
else
p++;
}
else
p = 0;
// p points at the beginning of the filename
m_szFileTitle = szTempPath.Mid(p);
for (p = m_szFileTitle.GetLength() - 1; p >= 0; p--)
if (m_szFileTitle[p] == _T('.'))
break;
if (p != -1)
{
m_szFileExt = m_szFileTitle.Mid(p+1);
m_szFileTitle = m_szFileTitle.Left(p);
}
}
int CZipPathComponent::IsPrefixed(const CZipString& path)
{
int i = -1, iLen = PathPrefix.GetLength();
int pathLen = path.GetLength();
if (iLen > pathLen)
iLen = pathLen;
CZipString szPossiblePrefix = path.Left(iLen);
szPossiblePrefix.MakeLower(); // must perform case insensitive comparison
while (++i < iLen && szPossiblePrefix[i] == PathPrefix[i]);
return i;
}
bool CWildcard::IsMatch(LPCTSTR lpszText, int *iRetCode)
{
CZipString sz;
if (!m_bCaseSensitive)
{
sz = lpszText;
sz.MakeLower();
lpszText = (LPCTSTR)sz;
}
int i = Match((LPCTSTR)m_szPattern, lpszText);
if (iRetCode)
*iRetCode = i;
return i == matchValid;
}
bool ZipPlatform::ForceDirectory(LPCTSTR lpDirectory)
{
ASSERT(lpDirectory);
CZipString szDirectory = lpDirectory;
szDirectory.TrimRight(CZipPathComponent::m_cSeparator);
CZipPathComponent zpc(szDirectory);
if ((zpc.GetFilePath() == (LPCTSTR)szDirectory) ||
(FileExists(szDirectory) == -1))
return true;
if (!ForceDirectory(zpc.GetFilePath()))
return false;
if (!CreateDirectory(szDirectory))
return false;
return true;
}
CZipAddFileInfo(const CZipString& szFilePath, const CZipString& szFileNameInZip)
:m_szFilePath(szFilePath), m_szFileNameInZip(szFileNameInZip)
{
int is = szFileNameInZip.GetLength();
m_iSeparators = 0;
for (int i = 0; i < is; i++)
if (CZipPathComponent::IsSeparator(szFileNameInZip[i]))
m_iSeparators++;
}
int ZipPlatform::SingleToWide(const CZipAutoBuffer &szSingle, CZipString& szWide)
{
int singleLen = szSingle.GetSize();
// iLen doesn't include terminating character
int iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle.GetBuffer(), singleLen, NULL, 0);
if (iLen > 0)
{
iLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szSingle.GetBuffer(), singleLen,
szWide.GetBuffer(iLen) , iLen);
szWide.ReleaseBuffer(iLen);
ASSERT(iLen != 0);
}
else
{
szWide.Empty();
iLen --; // return -1
}
return iLen;
}
ZIP_API bool ZipArchiveLib::IsStringAscii(const CZipString& value)
{
for (int i = 0; i < value.GetLength(); i++)
#if !defined __GNUC__ || defined __MINGW32__
if (!_istascii(value[i]))
#else
if (!isascii(value[i]))
#endif
return false;
return true;
}
CZipString ZipPlatform::GetTmpFileName(LPCTSTR lpszPath, ZIP_SIZE_TYPE uSizeNeeded)
{
TCHAR empty[] = _T("");
CZipString tempPath;
bool bCheckTemp = true;
if (lpszPath)
{
tempPath = lpszPath;
bCheckTemp = uSizeNeeded > 0 && GetDeviceFreeSpace(tempPath) < uSizeNeeded;
}
if (bCheckTemp)
{
DWORD size = GetTempPath(0, empty);
if (size == 0)
return (CZipString)empty;
GetTempPath(size, tempPath.GetBuffer(size));
tempPath.ReleaseBuffer();
if (GetDeviceFreeSpace(tempPath) < uSizeNeeded)
{
if (!GetCurrentDirectory(tempPath) || (uSizeNeeded > 0 && GetDeviceFreeSpace(tempPath) < uSizeNeeded))
return (CZipString)empty;
}
}
CZipString tempName;
if (!GetTempFileName(tempPath, _T("ZAR"), 0, tempName.GetBuffer(_MAX_PATH)))
return (CZipString)empty;
tempName.ReleaseBuffer();
return tempName;
}
void FillFromFile(FILELIST& l, LPCTSTR lpszFile, bool bCheck)
{
FILE* f;
#if _MSC_VER >= 1400
if (fopen_s(&f, lpszFile, "rt") != 0)
f = NULL;
#else
f = fopen(lpszFile, "rt");
#endif
if (!f)
{
printf ("File %s could not be opened\n", lpszFile);
return;
}
fseek(f, 0, SEEK_END);
int iSize = ftell(f);
fseek(f, 0, SEEK_SET);
CZipAutoBuffer buf(iSize + 1);
iSize = fread(buf, 1, iSize, f);
fclose(f);
char* sEnd = buf + iSize;
char* sBeg = buf;
for (char* pos = buf; ; pos++)
{
bool bEnd = pos == sEnd; // there may be no newline at the end
if (strncmp(pos, "\n", 1) == 0 || bEnd)
{
*pos = '\0';
CZipString s = sBeg;
s.TrimLeft(" ");
s.TrimRight(" ");
if (!s.IsEmpty() && (!bCheck || ZipPlatform::FileExists(s) != 0))
l.push_back(s);
if (bEnd)
break;
sBeg = pos + 1;
}
}
}
CZipString ZipPlatform::GetTmpFileName(LPCTSTR lpszPath, ZIP_U32_U64 uSizeNeeded)
{
TCHAR empty[] = _T(""), prefix [] = _T("zar");
TCHAR* buf = NULL;
CZipString tempPath = lpszPath;
if (tempPath.IsEmpty())
tempPath = "/tmp";
if (ZipPlatform::GetDeviceFreeSpace(tempPath) < uSizeNeeded)
return empty;
CZipPathComponent::AppendSeparator(tempPath);
tempPath += prefix;
tempPath += _T("XXXXXX");
int handle = mkstemp(tempPath.GetBuffer(tempPath.GetLength()));
tempPath.ReleaseBuffer();
if (handle != -1)
{
close(handle); // we just create the file and open it later
return tempPath;
}
else
return empty;
}
int ZipPlatform::MultiByteToWide(const CZipAutoBuffer &szIn, CZipString& szOut, UINT uCodePage)
{
int singleLen = szIn.GetSize();
if (singleLen == 0)
{
szOut.Empty();
return 0;
}
// iLen doesn't include terminating character
DWORD dwFlags = uCodePage <= CP_OEMCP ? MB_PRECOMPOSED : 0;
int iLen = MultiByteToWideChar(uCodePage, dwFlags, szIn.GetBuffer(), singleLen, NULL, 0);
if (iLen > 0)
{
iLen = MultiByteToWideChar(uCodePage, dwFlags, szIn.GetBuffer(), singleLen,
szOut.GetBuffer(iLen) , iLen);
szOut.ReleaseBuffer(iLen);
ASSERT(iLen > 0);
if (iLen == 0)
return -1;
#ifdef _ZIP_UNICODE_NORMALIZE
// if there is a problem with compilation here, you may need uncomment the block defining WINVER = 0x0600 at the bottom of _features.h file
if (IsNormalizedString(NormalizationC, szOut, iLen + 1) == TRUE)
return iLen;
int iNewLen = NormalizeString(NormalizationC, szOut, iLen, NULL, 0);
if (iNewLen <= 0)
{
return iLen;
}
CZipString szNormalized;
iNewLen = NormalizeString(NormalizationC, szOut, iLen, szNormalized.GetBuffer(iNewLen), iNewLen);
if (iNewLen <= 0)
{
szNormalized.ReleaseBuffer(0);
return iLen;
}
szNormalized.ReleaseBuffer(iNewLen);
szOut = szNormalized;
return iNewLen;
#else
return iLen;
#endif
}
else
{
szOut.Empty();
return -1;
}
}
void ZipCompatibility::ConvertBufferToString(CZipString& szString, const CZipAutoBuffer& buffer, UINT uCodePage)
{
#ifdef _UNICODE
ZipPlatform::MultiByteToWide(buffer, szString, uCodePage);
#else
// iLen does not include the NULL character
int iLen;
if (uCodePage == CP_OEMCP)
{
CZipAutoBuffer buf;
buf = buffer;
ZipPlatform::AnsiOem(buf, false);
iLen = buf.GetSize();
memcpy(szString.GetBuffer(iLen), buf.GetBuffer(), iLen);
}
else
{
iLen = buffer.GetSize();
memcpy(szString.GetBuffer(iLen), buffer.GetBuffer(), iLen);
}
szString.ReleaseBuffer(iLen);
#endif
}
void ZipCompatibility::SlashBackslashChg(CZipString& szFileName, bool bReplaceSlash)
{
TCHAR t1 = _T('\\') /*backslash*/, t2 = _T('/'), c1, c2;
if (bReplaceSlash)
{
c1 = t1;
c2 = t2;
}
else
{
c1 = t2;
c2 = t1;
}
szFileName.Replace(c2, c1);
}
bool CheckOrder(const CZipString& sz1, const CZipString& sz2,
int iSep1, int iSep2, bool bCheckTheBeginning = false) const
{
if (iSep1)
{
if (iSep2)
{
if (iSep1 == iSep2)
return (sz1.*pZipComp)(sz2) < 0;
if (bCheckTheBeginning)
{
int is = sz1.GetLength() > sz2.GetLength() ? sz2.GetLength() : sz1.GetLength();
int iSeparators = 0;
// find the common path beginning
int iLastSepPos = -1;
for (int i = 0; i < is; i++)
{
CZipString sz = sz2.Mid(i, 1);
if ((sz1.Mid(i, 1).*pZipComp)(sz) != 0) // must be Mid 'cos of case sens. here
break;
else if (CZipPathComponent::IsSeparator(sz[0]))
{
iLastSepPos = i;
iSeparators++;
}
}
// if necessary remove the common path beginning and check again
if (iLastSepPos != -1)
return CheckOrder(sz1.Mid(iLastSepPos), sz2.Mid(iLastSepPos), iSep1 - iSeparators, iSep2 - iSeparators);
}
return (sz1.*pZipComp)(sz2) < 0;
}
else
return false;
}
else
if (iSep2)
return true;
else
return (sz1.*pZipComp)(sz2) < 0;
}
bool CSimpleZip::Add(std::string strZipFile,std::list<std::string>& lstFile,std::string strRootPath,bool bFullPath)
{
CZipArchive zip;
CZipString szArchive;
int iVolumeSize = 0;
int iMode = CZipArchive::zipOpen;
szArchive =CZipString(strZipFile);
if (!ZipPlatform::FileExists(szArchive))
iMode = CZipArchive::zipCreate;
CZipPathComponent zpc(szArchive);
SpanCallback span;
zip.SetSpanCallback(&span);
try
{
zip.Open(szArchive, iMode, iVolumeSize);
}
catch(...)
{
return FALSE;
}
zip.SetRootPath(strRootPath.c_str());
FILELIST lFiles;
for(std::list<std::string>::iterator it =lstFile.begin();it!=lstFile.end();it++)
{
std::string strFileName;
strFileName =*it;
lFiles.push_back(CZipString(strFileName));
}
FILELISTADD rev;
for (FILELISTIT it = lFiles.begin(); it != lFiles.end(); ++it)
{
CZipString sz = zip.PredictFileNameInZip(*it, bFullPath);
if (!sz.IsEmpty())
rev.push_back(CZipAddFileInfo(*it, sz));
}
lFiles.clear();
// rev.sort(std::greater<CZipAddFileInfo>());
FILELISTADDIT it1;
int iSmartLevel = CZipArchive::zipsmSafeSmart;
for (it1 = rev.begin(); it1 != rev.end(); ++it1)
{
if (zip.AddNewFile((*it1).m_szFilePath, 5, bFullPath, iSmartLevel))
{
printf ("%s added\n", (LPCTSTR)(*it1).m_szFileNameInZip);
}
else
printf ("%s not added\n", (LPCTSTR)(*it1).m_szFilePath);
}
zip.Close();
return TRUE;
}
CZipString CZipException::GetInternalErrorDescription(int iCause, bool bNoLoop)
{
CZipString sz;
switch (iCause)
{
case EROFS:
sz = _T("Read-only file system");
break;
case ESPIPE:
sz = _T("Illegal seek");
break;
case ENOSPC:
sz = _T("No space left on device");
break;
case EFBIG:
sz = _T("File too large");
break;
case EMFILE:
sz = _T("Too many open files");
break;
case ENFILE:
sz = _T("File table overflow");
break;
case EINVAL:
sz = _T("Invalid argument");
break;
case EISDIR:
sz = _T("Is a directory");
break;
case ENOTDIR:
sz = _T("Not a directory");
break;
case ENODEV:
sz = _T("No such device");
break;
case EXDEV:
sz = _T("Cross-device link");
break;
case EEXIST:
sz = _T("File exists");
break;
case EFAULT:
sz = _T("Bad address");
break;
case EACCES:
sz = _T("Permission denied");
break;
case ENOMEM:
sz = _T("Not enough space");
break;
case EBADF:
sz = _T("Bad file number");
break;
case ENXIO:
sz = _T("No such device or address");
break;
case EIO:
sz = _T("I/O error");
break;
case EINTR:
sz = _T("Interrupted system call");
break;
case ENOENT:
sz = _T("No such file or directory");
break;
case EPERM:
sz = _T("Not super-user");
break;
case badZipFile:
sz = _T("Damaged or not a zip file");
break;
case badCrc:
sz = _T("Crc mismatched");
break;
case noCallback:
sz = _T("No disk-spanning callback functor set");
break;
case aborted:
sz = _T("Disk change aborted");
break;
case abortedAction:
sz = _T("Action aborted");
break;
case abortedSafely:
sz = _T("Action aborted safely");
break;
case nonRemovable:
sz = _T("The device selected for the disk spanning archive is non removable");
break;
case tooManyVolumes:
sz = _T("Limit of the maximum volumes reached (999)");
break;
case tooLongFileName:
sz = _T("The filename of the file being added to the archive is too long");
break;
case badPassword:
sz = _T("Incorrect password set for the file being decrypted");
break;
case dirWithSize:
sz = _T("During testing found the directory with the size greater than 0");
break;
case internal:
sz = _T("Internal error");
break;
case notRemoved:
sz.Format(_T("%s (%s)"), _T("Error while removing a file"), (LPCTSTR)GetSystemErrorDescription());
break;
case notRenamed:
sz.Format(_T("%s (%s)"), _T("Error while renaming a file"), (LPCTSTR)GetSystemErrorDescription());
break;
case platfNotSupp:
sz = _T("Cannot create the file for the specified platform");
break;
case cdirNotFound:
sz = _T("The central directory was not found in the archive (or you were trying to open not the last disk of a multi-disk archive)");
break;
case streamEnd:
sz = _T("Zlib Library error (end of stream)");
break;
case errNo:
sz = GetInternalErrorDescription(errno != errNo ? errno : generic);
break;
case streamError:
sz = _T("Zlib library error (stream error)");
break;
case dataError:
sz = _T("Zlib library error (data error)");
break;
case memError:
sz = _T("Not enough memory");
break;
case bufError:
sz = _T("Zlib library error (buffer error)");
break;
case versionError:
sz = _T("Zlib library error (version error)");
break;
default:
sz = bNoLoop ? _T("Unknown error") :(LPCTSTR) GetSystemErrorDescription();
}
return sz;
}
bool CZipFile::Open(LPCTSTR lpszFileName, UINT openFlags, bool bThrow)
{
if (!IsClosed())
Close();
CZipString fileName = lpszFileName;
if (fileName.IsEmpty())
{
return false;
}
DWORD access;
DWORD temp = openFlags & 3;
if (temp == modeWrite)
{
access = GENERIC_WRITE;
}
else if (temp == modeReadWrite)
{
access = GENERIC_READ | GENERIC_WRITE;
}
else
{
access = GENERIC_READ;
}
DWORD share;
temp = openFlags & 0x70;
if (temp == shareDenyWrite)
{
share = FILE_SHARE_READ;
}
else if (temp == shareDenyRead)
{
share = FILE_SHARE_WRITE;
}
else if (temp == shareDenyNone)
{
share = FILE_SHARE_READ | FILE_SHARE_WRITE;
}
else
{
share = 0;
}
CZipPathComponent::AddPrefix(fileName, false);
DWORD create;
if (openFlags & modeCreate)
{
if (openFlags & modeNoTruncate)
{
create = OPEN_ALWAYS;
}
else
{
create = CREATE_ALWAYS;
}
}
else
{
create = OPEN_EXISTING;
}
SECURITY_ATTRIBUTES sa;
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
m_hFile = ::CreateFile(fileName, access, share, &sa, create, FILE_ATTRIBUTE_NORMAL, NULL);
if (m_hFile == INVALID_HANDLE_VALUE)
{
if (bThrow)
ThrowError();
else
return false;
}
m_szFileName = lpszFileName;
return true;
}
void AddDirectory(CZipString szPath, struct AddDirectoryInfo& info, bool bDoNotAdd)
{
if (!szPath.IsEmpty())
CZipPathComponent::AppendSeparator(szPath);
bool bPathAdded = info.m_bAddEmpty || bDoNotAdd;
if (info.m_bAddEmpty && !szPath.IsEmpty() && !bDoNotAdd)
info.m_l.push_back(szPath);
#ifdef __GNUC__
DIR* dp = opendir(szPath.IsEmpty() ? "." : szPath);
if (!dp)
return;
struct dirent* entry;
while (entry = readdir(dp))
{
struct stat sStats;
CZipString szFullFileName = szPath + entry->d_name;
if (stat(szFullFileName, &sStats) == -1)
continue;
if (S_ISDIR(sStats.st_mode))
{
if (info.m_bRecursive)
{
if (IsDots(entry->d_name))
continue;
AddDirectory(szFullFileName, info, false);
}
}
else if (fnmatch(info.m_lpszFile, entry->d_name, FNM_NOESCAPE |FNM_PATHNAME) == 0)
{
if (!bPathAdded)
{
if (!szPath.IsEmpty())
info.m_l.push_back(szPath);
bPathAdded = true;
}
info.m_l.push_back(szPath + entry->d_name);
}
}
closedir(dp);
#else
CZipString szFullFileName = szPath + info.m_lpszFile;
struct _finddata_t c_file;
long hFile;
if( (hFile = _findfirst( szFullFileName, &c_file )) != -1L )
{
do
{
if (!(c_file.attrib & FILE_ATTRIBUTE_DIRECTORY))
{
// add it when the first file comes
if (!bPathAdded)
{
if (!szPath.IsEmpty())
info.m_l.push_back(szPath);
bPathAdded = true;
}
info.m_l.push_back(szPath + c_file.name);
}
}
while (_findnext(hFile, &c_file) == 0L);
}
_findclose(hFile);
if (info.m_bRecursive)
{
szFullFileName = szPath + "*";
if( (hFile = _findfirst( szFullFileName, &c_file )) != -1L )
{
do
{
if (c_file.attrib & FILE_ATTRIBUTE_DIRECTORY)
{
if (IsDots(c_file.name))
continue;
szFullFileName = szPath + c_file.name;
AddDirectory(szFullFileName, info, false);
}
}
while (_findnext(hFile, &c_file) == 0L);
}
_findclose(hFile);
}
#endif
}
ZIPINLINE bool ZipPlatform::RemoveFile(LPCTSTR lpszFileName, bool bThrow, int iMode)
{
if ((iMode & ZipPlatform::dfmRemoveReadOnly) != 0)
{
DWORD attr;
if (ZipPlatform::GetFileAttr(lpszFileName, attr)
&& (ZipCompatibility::GetAsInternalAttributes(attr, ZipPlatform::GetSystemID()) & ZipCompatibility::attROnly) != 0)
{
ZipPlatform::SetFileAttr(lpszFileName, ZipPlatform::GetDefaultAttributes());
}
}
#ifdef SHFileOperation
if ((iMode & ZipPlatform::dfmRecycleBin) == 0)
{
#endif
if (::DeleteFile((LPTSTR)(LPCTSTR)CZipPathComponent::AddPrefix(lpszFileName, false)))
return true;
#ifdef SHFileOperation
}
else
{
CZipString file = lpszFileName;
#if defined _UNICODE && _MSC_VER >= 1400
if (file.GetLength() >= MAX_PATH)
{
// cannot prefix for SHFileOperation, use short path
CZipString temp = CZipPathComponent::AddPrefix(lpszFileName, false);
DWORD size = ::GetShortPathName(temp, NULL, 0);
if (size != 0)
{
size = ::GetShortPathName(temp, file.GetBuffer(size), size);
file.ReleaseBuffer();
}
if (size == 0)
{
if (bThrow)
CZipException::Throw(CZipException::notRemoved, lpszFileName);
return false;
}
// GetShortPathName keeps the prefix - remove it
int prefixLength = CZipPathComponent::IsPrefixed(file);
if (prefixLength > 0)
{
file = file.Mid(prefixLength);
}
}
#endif
int length = file.GetLength();
CZipAutoBuffer buffer((length + 2) * sizeof(TCHAR), true); // double NULL is required
memcpy(buffer, (LPCTSTR)file, length * sizeof(TCHAR));
SHFILEOPSTRUCT shFileOp = {0};
shFileOp.wFunc = FO_DELETE;
shFileOp.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
shFileOp.pFrom = (LPCTSTR)(char*)buffer;
if (SHFileOperation(&shFileOp) == 0 && !shFileOp.fAnyOperationsAborted)
return true;
}
#endif
if (bThrow)
CZipException::Throw(CZipException::notRemoved, lpszFileName);
return false;
}