able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/ext/ftp/ftppidl.cpp

2922 lines
91 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*****************************************************************************\
ftppidl.cpp - Pointers to Item ID Lists
This is the only file that knows the internal format of our IDLs.
\*****************************************************************************/
#include "priv.h"
#include "ftppidl.h"
#include "ftpurl.h"
#include "cookie.h"
#define NOT_INITIALIZED 10
DWORD g_fNoPasswordsInAddressBar = NOT_INITIALIZED;
#define SESSIONKEY FILETIME
// Private FtpServerID Helpers
HRESULT FtpServerID_GetServer(LPCITEMIDLIST pidl, LPTSTR szServer, DWORD cchSize);
DWORD FtpItemID_GetTypeID(LPCITEMIDLIST pidl);
// v0 never went to customers but was used in NT5 before 1799 - Shipped in: Never.
// v1 This switch was to use password cookies for a security fix. - Shipped in: Never.
// v2 this was done to not use the IDelegate's IMalloc for non-first ItemIDs - Shipped in: Never (5/15/98)
// v3 add extra padding to ItemIDs so their dwType matches that of ServerIDs - Shipped in: IE5b1, IE5b2, NT5b2 (5/25/98)
// v4 add wzDisplayName to FtpItemID - Shipped in: IE5 RTM & NT5 b3 (11/16/98)
#define PIDL_VERSION_NUMBER_UPGRADE 3
#define PIDL_VERSION_NUMBER 4
#define SIZE_ITEMID_SIZEFIELD (sizeof(DWORD) + sizeof(WORD))
#define SIZE_ITEMID_TERMINATOR (sizeof(DWORD))
/****************************************************\
IDType
DESCRIPTION:
These bits go into FTPIDLIST.dwIDType and describe
what type of pidl it is AND which areas of the
data structure have been verified by getting the
data directly from the server.
\****************************************************/
#define IDTYPE_ISVALID 0x00000001 // Set if TYPE is valid
#define IDTYPE_SERVER (0x00000002 | IDTYPE_ISVALID) // Server
#define IDTYPE_DIR (0x00000004 | IDTYPE_ISVALID) // Folder/Dir
#define IDTYPE_FILE (0x00000008 | IDTYPE_ISVALID) // File
#define IDTYPE_FILEORDIR (0x00000010 | IDTYPE_ISVALID) // File or Dir. Wasn't specified.
#define IDTYPE_FRAGMENT (0x00000020 | IDTYPE_ISVALID) // File Fragment (i.e. foobar.htm#SECTION_3)
// These are bits that indicate
// For Server ItemIDs
#define IDVALID_PORT_NUM 0x00000100 // Was the port number specified
#define IDVALID_USERNAME 0x00000200 // Was the login name specified
#define IDVALID_PASSWORD 0x00000400 // Was the password specified
#define IDVALID_DLTYPE 0x00000800 // Download Type is specified.
#define IDVALID_DL_ASCII 0x00001000 // Download as ASCII if set, otherwise, download as BINARY.
#define IDVALID_HIDE_PASSWORD 0x00002000 // The Password entry is invalid so use the sessionkey to look it up.
#define VALID_SERVER_BITS (IDTYPE_ISVALID|IDTYPE_SERVER|IDVALID_PORT_NUM|IDVALID_USERNAME|IDVALID_PASSWORD|IDVALID_DLTYPE|IDVALID_DL_ASCII|IDVALID_HIDE_PASSWORD)
#define IS_VALID_SERVER_ITEMID(pItemId) (!(pItemId & ~VALID_SERVER_BITS))
// For Dir/File ItemIDs
#define IDVALID_FILESIZE 0x00010000 // Did we get the file size from the server?
#define IDVALID_MOD_DATE 0x00020000 // Did we get the modification date from the server?
#define VALID_DIRORFILE_BITS (IDTYPE_ISVALID|IDTYPE_DIR|IDTYPE_FILE|IDTYPE_FILEORDIR|IDTYPE_FRAGMENT|IDVALID_FILESIZE|IDVALID_MOD_DATE)
#define IS_VALID_DIRORFILE_ITEMID(pItemId) (!(pItemId & (~VALID_DIRORFILE_BITS & ~IDTYPE_ISVALID)))
#define IS_FRAGMENT(pFtpIDList) (IDTYPE_ISVALID != (IDTYPE_FRAGMENT & pFtpIDList->dwIDType))
///////////////////////////////////////////////////////////
// FTP Pidl Helper Functions
///////////////////////////////////////////////////////////
/*****************************************************************************\
FUNCTION: UrlGetAbstractPathFromPidl
DESCRIPTION:
pszUrlPath will be UNEscaped and in Wire Bytes.
\*****************************************************************************/
HRESULT UrlGetAbstractPathFromPidl(LPCITEMIDLIST pidl, BOOL fDirsOnly, BOOL fInWireBytes, void * pvPath, DWORD cchUrlPathSize)
{
HRESULT hr = S_OK;
LPWIRESTR pwWirePath = (LPWIRESTR) pvPath;
LPWSTR pwzDisplayPath = (LPWSTR) pvPath;
if (!EVAL(FtpPidl_IsValid(pidl)))
return E_INVALIDARG;
ASSERT(pvPath && (0 < cchUrlPathSize));
ASSERT(IsValidPIDL(pidl));
if (fInWireBytes)
{
pwWirePath[0] = '/';
pwWirePath[1] = '\0'; // Make this path absolute.
}
else
{
pwzDisplayPath[0] = L'/';
pwzDisplayPath[1] = L'\0'; // Make this path absolute.
}
if (!ILIsEmpty(pidl) && FtpID_IsServerItemID(pidl)) // If it's not a server, we are in trouble.
pidl = _ILNext(pidl); // Skip past the Server Pidl.
for (; !ILIsEmpty(pidl); pidl = _ILNext(pidl))
{
if (!fDirsOnly || FtpItemID_IsDirectory(pidl, TRUE) || !ILIsEmpty(_ILNext(pidl)))
{
if (!FtpItemID_IsFragment(pidl))
{
if (fInWireBytes)
{
LPCWIRESTR pwWireName = FtpItemID_GetWireNameReference(pidl);
if (pwWireName)
{
// The caller should never need the URL Path escaped because
// that will happen when it's converted into an URL.
WirePathAppend(pwWirePath, cchUrlPathSize, pwWireName);
}
}
else
{
WCHAR szDisplayName[MAX_PATH];
if (SUCCEEDED(FtpItemID_GetDisplayName(pidl, szDisplayName, ARRAYSIZE(szDisplayName))))
{
// The caller should never need the URL Path escaped because
// that will happen when it's converted into an URL.
DisplayPathAppend(pwzDisplayPath, cchUrlPathSize, szDisplayName);
}
}
}
}
if (SUCCEEDED(hr) &&
(FtpItemID_IsDirectory(pidl, FALSE) || (FtpItemID_GetCompatFlags(pidl) & COMPAT_APPENDSLASHTOURL)))
{
if (fInWireBytes)
WirePathAppendSlash(pwWirePath, cchUrlPathSize); // Always make sure dirs end in '/'.
else
DisplayPathAppendSlash(pwzDisplayPath, cchUrlPathSize); // Always make sure dirs end in '/'.
}
}
return hr;
}
/*****************************************************************************\
FUNCTION: GetDisplayPathFromPidl
DESCRIPTION:
pwzDisplayPath will be UNEscaped and in display unicode.
\*****************************************************************************/
HRESULT GetDisplayPathFromPidl(LPCITEMIDLIST pidl, LPWSTR pwzDisplayPath, DWORD cchUrlPathSize, BOOL fDirsOnly)
{
return UrlGetAbstractPathFromPidl(pidl, fDirsOnly, FALSE, (void *) pwzDisplayPath, cchUrlPathSize);
}
/*****************************************************************************\
FUNCTION: GetWirePathFromPidl
DESCRIPTION:
pszUrlPath will be UNEscaped and in Wire Bytes.
\*****************************************************************************/
HRESULT GetWirePathFromPidl(LPCITEMIDLIST pidl, LPWIRESTR pwWirePath, DWORD cchUrlPathSize, BOOL fDirsOnly)
{
return UrlGetAbstractPathFromPidl(pidl, fDirsOnly, TRUE, (void *) pwWirePath, cchUrlPathSize);
}
#ifndef UNICODE
/*****************************************************************************\
FUNCTION: UrlCreateFromPidlW
DESCRIPTION:
\*****************************************************************************/
HRESULT UrlCreateFromPidlW(LPCITEMIDLIST pidl, DWORD shgno, LPWSTR pwzUrl, DWORD cchSize, DWORD dwFlags, BOOL fHidePassword)
{
HRESULT hr;
TCHAR szUrl[MAX_URL_STRING];
hr = UrlCreateFromPidl(pidl, shgno, szUrl, ARRAYSIZE(szUrl), dwFlags, fHidePassword);
if (SUCCEEDED(hr))
SHTCharToUnicode(szUrl, pwzUrl, cchSize);
return hr;
}
#else // UNICODE
/*****************************************************************************\
FUNCTION: UrlCreateFromPidlA
DESCRIPTION:
\*****************************************************************************/
HRESULT UrlCreateFromPidlA(LPCITEMIDLIST pidl, DWORD shgno, LPSTR pszUrl, DWORD cchSize, DWORD dwFlags, BOOL fHidePassword)
{
HRESULT hr;
TCHAR szUrl[MAX_URL_STRING];
hr = UrlCreateFromPidl(pidl, shgno, szUrl, ARRAYSIZE(szUrl), dwFlags, fHidePassword);
if (SUCCEEDED(hr))
SHTCharToAnsi(szUrl, pszUrl, cchSize);
return hr;
}
#endif // UNICODE
BOOL IncludePassword(void)
{
if (NOT_INITIALIZED == g_fNoPasswordsInAddressBar)
g_fNoPasswordsInAddressBar = !SHRegGetBoolUSValue(SZ_REGKEY_FTPFOLDER, SZ_REGVALUE_PASSWDSIN_ADDRBAR, FALSE, TRUE);
return g_fNoPasswordsInAddressBar;
}
HRESULT ParseUrlCreateFromPidl(LPCITEMIDLIST pidl, LPTSTR pszUrl, DWORD cchSize, DWORD dwFlags, BOOL fHidePassword)
{
HRESULT hr = S_OK;
TCHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH];
TCHAR szUrlPath[MAX_URL_STRING];
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH];
TCHAR szPassword[INTERNET_MAX_PASSWORD_LENGTH];
TCHAR szFragment[MAX_PATH];
TCHAR szDownloadType[MAX_PATH] = TEXT("");
INTERNET_PORT ipPortNum = INTERNET_DEFAULT_FTP_PORT;
if (ILIsEmpty(pidl))
{
ASSERT(0); // We should never have an empty pidl. Get BryanSt if we hit this. Why does CFtpFolder have ILIsEmpty(m_pidlHere).
szServer[0] = szUrlPath[0] = szUserName[0] = szPassword[0] = TEXT('\0');
hr = E_FAIL;
}
else
{
FtpPidl_GetServer(pidl, szServer, ARRAYSIZE(szServer));
GetDisplayPathFromPidl(pidl, szUrlPath, ARRAYSIZE(szUrlPath), FALSE);
FtpPidl_GetUserName(pidl, szUserName, ARRAYSIZE(szUserName));
if (FAILED(FtpPidl_GetPassword(pidl, szPassword, ARRAYSIZE(szPassword), !fHidePassword)))
szPassword[0] = 0;
FtpPidl_GetFragment(pidl, szFragment, ARRAYSIZE(szPassword));
FtpPidl_GetDownloadTypeStr(pidl, szDownloadType, ARRAYSIZE(szDownloadType));
UrlPathAdd(szUrlPath, ARRAYSIZE(szUrlPath), szDownloadType);
ipPortNum = FtpPidl_GetPortNum(pidl);
}
if (SUCCEEDED(hr))
{
TCHAR szUserNameEscaped[INTERNET_MAX_USER_NAME_LENGTH];
szUserNameEscaped[0] = 0;
if (szUserName[0])
EscapeString(szUserName, szUserNameEscaped, ARRAYSIZE(szUserNameEscaped));
hr = UrlCreateEx(szServer, NULL_FOR_EMPTYSTR(szUserNameEscaped), szPassword, szUrlPath, szFragment, ipPortNum, szDownloadType, pszUrl, cchSize, dwFlags);
}
return hr;
}
/*****************************************************************************\
FUNCTION: GetFullPrettyName
DESCRIPTION:
The user wants a pretty name so these are the cases we need to worry
about:
URL: Pretty Name:
---------------------------------- ---------------------
ftp://joe:psswd@serv/ serv
ftp://joe:psswd@serv/dir1/ dir1 on serv
ftp://joe:psswd@serv/dir1/dir2/ dir2 on serv
ftp://joe:psswd@serv/dir1/dir2/file.txt file.txt on serv
\*****************************************************************************/
HRESULT GetFullPrettyName(LPCITEMIDLIST pidl, LPTSTR pszUrl, DWORD cchSize)
{
HRESULT hr = S_OK;
TCHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH];
FtpPidl_GetServer(pidl, szServer, ARRAYSIZE(szServer));
// Is there anything after the ServerItemID?
if (!ILIsEmpty(_ILNext(pidl)))
{
// Yes, so let's get the name of the last item and
// make the string "<LastItemName> on <Server>".
WCHAR szLastItem[MAX_PATH];
FtpItemID_GetDisplayName(ILFindLastID(pidl), szLastItem, ARRAYSIZE(szLastItem));
LPTSTR pszStrArray[] = {szServer, (LPTSTR)szLastItem};
// IE #56648: Akabir found that FormatMessageW & FormatMessageWrapW() do not
// correctly handle UNICODE strings on Win9x. Therefore, we need to use
// FormatMessageA() in that case.
if (IsOSNT())
{
TCHAR szTemplate[MAX_PATH];
LoadString(HINST_THISDLL, IDS_PRETTYNAMEFORMAT, szTemplate, ARRAYSIZE(szTemplate));
EVAL(FormatMessage((FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY), (LPVOID)szTemplate,
0, 0, pszUrl, cchSize, (va_list*)pszStrArray));
}
else
{
CHAR szTemplateAnsi[MAX_PATH];
CHAR szURLAnsi[MAX_URL_STRING];
CHAR szServerAnsi[INTERNET_MAX_HOST_NAME_LENGTH];
CHAR szFileNameAnsi[MAX_PATH];
LPCSTR pszStrArrayAnsi[] = {szServerAnsi, szFileNameAnsi};
SHTCharToAnsi(szServer, szServerAnsi, ARRAYSIZE(szServerAnsi));
SHUnicodeToAnsi(szLastItem, szFileNameAnsi, ARRAYSIZE(szFileNameAnsi));
LoadStringA(HINST_THISDLL, IDS_PRETTYNAMEFORMATA, szTemplateAnsi, ARRAYSIZE(szTemplateAnsi));
EVAL(FormatMessageA((FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY), (LPVOID)szTemplateAnsi,
0, 0, szURLAnsi, ARRAYSIZE(szURLAnsi), (va_list*)pszStrArrayAnsi));
SHAnsiToTChar(szURLAnsi, pszUrl, cchSize);
}
}
else
{
// No, so we are done.
StrCpyN(pszUrl, szServer, cchSize);
}
return hr;
}
/*****************************************************************************\
FUNCTION: UrlCreateFromPidl
DESCRIPTION:
Common worker that handles SHGDN_FORPARSING style GetDisplayNameOf's.
Note! that since we do not support junctions (duh), we can
safely walk down the pidl generating goop as we go, secure
in the knowledge that we are in charge of every subpidl.
_CHARSET_: Since FTP filenames are always in the ANSI character
set, by RFC 1738, we can return ANSI display names without loss
of fidelity. In a general folder implementation, we should be
using cStr to return display names, so that the UNICODE
version of the shell extension can handle UNICODE names.
\*****************************************************************************/
HRESULT UrlCreateFromPidl(LPCITEMIDLIST pidl, DWORD shgno, LPTSTR pszUrl, DWORD cchSize, DWORD dwFlags, BOOL fHidePassword)
{
HRESULT hr = S_OK;
pszUrl[0] = 0;
if (!EVAL(pidl) ||
!EVAL(IsValidPIDL(pidl)) ||
!FtpPidl_IsValid(pidl) ||
!FtpID_IsServerItemID(pidl) ||
!EVAL(pszUrl && (0 < cchSize)))
{
return E_INVALIDARG;
}
if (shgno & SHGDN_INFOLDER)
{
// shgno & SHGDN_INFOLDER ?
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (EVAL(pidlLast && !ILIsEmpty(pidlLast)))
{
hr = FtpPidl_GetDisplayName(pidlLast, pszUrl, cchSize);
// Do they want to reparse it later? If they do and it's
// a server, we need to give out the scheme also.
// (SHGDN_INFOLDER) = "ServerName"
// (SHGDN_INFOLDER|SHGDN_FORPARSING) = "ftp://ServerName/"
if ((shgno & SHGDN_FORPARSING) &&
(FtpID_IsServerItemID(pidlLast)))
{
// Yes, so we need to add the server name.
TCHAR szServerName[MAX_PATH];
StrCpyN(szServerName, pszUrl, ARRAYSIZE(szServerName));
wnsprintf(pszUrl, cchSize, TEXT("ftp://%s/"), szServerName);
}
}
else
hr = E_FAIL;
}
else
{
// Assume they want the full URL.
if (!EVAL((shgno & SHGDN_FORPARSING) ||
(shgno & SHGDN_FORADDRESSBAR) ||
(shgno == SHGDN_NORMAL)))
{
TraceMsg(TF_ALWAYS, "UrlCreateFromPidl() shgno=%#08lx and I dont know what to do with that.", shgno);
}
if ((shgno & SHGDN_FORPARSING) || (shgno & SHGDN_FORADDRESSBAR))
{
hr = ParseUrlCreateFromPidl(pidl, pszUrl, cchSize, dwFlags, fHidePassword);
}
else
hr = GetFullPrettyName(pidl, pszUrl, cchSize);
}
// TraceMsg(TF_FTPURL_UTILS, "UrlCreateFromPidl() pszUrl=%ls, shgno=%#08lX", pszUrl, shgno);
return hr;
}
/*****************************************************************************\
FUNCTION: CreateFtpPidlFromDisplayPathHelper
DESCRIPTION:
The work done in CreateFtpPidlFromUrlPath requires a fair amount of
stack space so we do most of the work in CreateFtpPidlFromDisplayPathHelper
to prevent overflowing the stack.
\*****************************************************************************/
HRESULT CreateFtpPidlFromDisplayPathHelper(LPCWSTR pwzFullPath, CWireEncoding * pwe, ULONG *pcchEaten, LPITEMIDLIST * ppidl, BOOL fIsTypeKnown, BOOL fIsDir, LPITEMIDLIST * ppidlCurrentID, LPWSTR * ppwzRemaining)
{
HRESULT hr = E_FAIL;
LPITEMIDLIST pidl;
WCHAR wzFirstItem[MAX_PATH];
WIRECHAR wFirstWireItem[MAX_PATH];
WCHAR wzRemaining[MAX_PATH];
BOOL fIsCurrSegmentADir = FALSE;
BOOL fIsCurrSegmentTypeKnown = fIsTypeKnown;
BOOL fIsFragSeparator = FALSE;
*ppwzRemaining = NULL;
*ppidl = 0;
if (pcchEaten)
*pcchEaten = 0; // The caller will parse the entire URL so we don't need to fill this in.
if (L'/' == pwzFullPath[0])
pwzFullPath = (LPWSTR) CharNextW(pwzFullPath);
DisplayPathGetFirstSegment(pwzFullPath, wzFirstItem, ARRAYSIZE(wzFirstItem), NULL, wzRemaining, ARRAYSIZE(wzRemaining), &fIsCurrSegmentADir);
// Is this the last segment?
if (!wzRemaining[0])
{
// Yes, so if the caller knows the type of the last segment, use it now.
if (fIsTypeKnown)
fIsCurrSegmentADir = fIsDir;
}
else
{
// No, so we are assured that fIsDirCurrent is correct because it must have been followed
// by a '/', or how could it be followed by another path segment?
fIsCurrSegmentTypeKnown = TRUE;
ASSERT(fIsCurrSegmentADir);
}
// NOTE: If the user entered "ftp://serv/Dir1/Dir2" fIsDir will be false for Dir2.
// It will be marked as ambigious. (TODO: Check for extension?)
EVAL(SUCCEEDED(pwe->UnicodeToWireBytes(NULL, wzFirstItem, ((pwe && pwe->IsUTF8Supported()) ? WIREENC_USE_UTF8 : WIREENC_NONE), wFirstWireItem, ARRAYSIZE(wFirstWireItem))));
hr = FtpItemID_CreateFake(wzFirstItem, wFirstWireItem, fIsCurrSegmentTypeKnown, !fIsCurrSegmentADir, FALSE, &pidl);
ASSERT(IsValidPIDL(pidl));
if (SUCCEEDED(hr))
{
if (wzRemaining[0])
{
Str_SetPtrW(ppwzRemaining, wzRemaining);
*ppidlCurrentID = pidl;
}
else
*ppidl = pidl;
}
return hr;
}
/*****************************************************************************\
FUNCTION: CreateFtpPidlFromUrlPath
DESCRIPTION:
This function will be passed the 'Path' of the URL and will create
each of the IDs for each path segment. This will happen by creating an ID
for the first path segment and then Combining that with the remaining
IDs which are obtained by a recursive call.
URL = "ftp://<UserName>:<Password>@<HostName>:<PortNum>/Dir1/Dir2/Dir3/file.txt[;Type=[a|b|d]]"
Url Path = "Dir1/Dir2/Dir3/file.txt"
pszFullPath - This URL will contain an URL Path (/Dir1/Dir2/MayBeFileOrDir).
fIsTypeKnown - We can detect all directories w/o ambiguity because they end
end '/' except for the last directory. fIsTypeKnown is used
if this information is known. If TRUE, fIsDir will be used to
disambiguate the last item. If FALSE, the last item will be marked
a directory if it doesn't have an extension.
The incoming name is %-encoded, but if we see an illegal %-sequence,
just leave the % alone.
Note that we return E_FAIL when given an unparseable path,
not E_INVALIDARG.
\*****************************************************************************/
HRESULT CreateFtpPidlFromDisplayPath(LPCWSTR pwzFullPath, CWireEncoding * pwe, ULONG *pcchEaten, LPITEMIDLIST * ppidl, BOOL fIsTypeKnown, BOOL fIsDir)
{
HRESULT hr = E_FAIL;
LPWSTR pwzRemaining = NULL;
LPITEMIDLIST pidlCurrentID = NULL;
hr = CreateFtpPidlFromDisplayPathHelper(pwzFullPath, pwe, pcchEaten, ppidl, fIsTypeKnown, fIsDir, &pidlCurrentID, &pwzRemaining);
if (SUCCEEDED(hr) && pwzRemaining)
{
LPITEMIDLIST pidlSub;
hr = CreateFtpPidlFromDisplayPath(pwzRemaining, pwe, pcchEaten, &pidlSub, fIsTypeKnown, fIsDir);
if (SUCCEEDED(hr))
{
*ppidl = ILCombine(pidlCurrentID, pidlSub);
hr = *ppidl ? S_OK : E_OUTOFMEMORY;
ILFree(pidlSub);
}
ILFree(pidlCurrentID);
Str_SetPtrW(&pwzRemaining, NULL);
}
return hr;
}
/*****************************************************************************\
FUNCTION: CreateFtpPidlFromDisplayPathHelper
DESCRIPTION:
The work done in CreateFtpPidlFromUrlPath requires a fair amount of
stack space so we do most of the work in CreateFtpPidlFromDisplayPathHelper
to prevent overflowing the stack.
\*****************************************************************************/
HRESULT CreateFtpPidlFromFtpWirePathHelper(LPCWIRESTR pwFtpWirePath, CWireEncoding * pwe, ULONG *pcchEaten, LPITEMIDLIST * ppidl, BOOL fIsTypeKnown, BOOL fIsDir, LPITEMIDLIST * ppidlCurrentID, LPWIRESTR * ppwRemaining)
{
HRESULT hr = E_FAIL;
LPITEMIDLIST pidl;
WIRECHAR wFirstItem[MAX_PATH];
WCHAR wzFirstItemDisplayName[MAX_PATH];
WIRECHAR wRemaining[MAX_PATH];
BOOL fIsCurrSegmentADir = FALSE;
BOOL fIsCurrSegmentTypeKnown = fIsTypeKnown;
BOOL fIsFragSeparator = FALSE;
*ppwRemaining = NULL;
*ppidl = 0;
if (pcchEaten)
*pcchEaten = 0; // The caller will parse the entire URL so we don't need to fill this in.
if ('/' == pwFtpWirePath[0])
pwFtpWirePath = (LPWIRESTR) CharNextA(pwFtpWirePath);
WirePathGetFirstSegment(pwFtpWirePath, wFirstItem, ARRAYSIZE(wFirstItem), NULL, wRemaining, ARRAYSIZE(wRemaining), &fIsCurrSegmentADir);
// Is this the last segment?
if (!wRemaining[0])
{
// Yes, so if the caller knows the type of the last segment, use it now.
if (fIsTypeKnown)
fIsCurrSegmentADir = fIsDir;
}
else
{
// No, so we are assured that fIsDirCurrent is correct because it must have been followed
// by a '/', or how could it be followed by another path segment?
fIsCurrSegmentTypeKnown = TRUE;
ASSERT(fIsCurrSegmentADir);
}
// NOTE: If the user entered "ftp://serv/Dir1/Dir2" fIsDir will be false for Dir2.
// It will be marked as ambigious. (TODO: Check for extension?)
EVAL(SUCCEEDED(pwe->WireBytesToUnicode(NULL, wFirstItem, WIREENC_IMPROVE_ACCURACY, wzFirstItemDisplayName, ARRAYSIZE(wzFirstItemDisplayName))));
hr = FtpItemID_CreateFake(wzFirstItemDisplayName, wFirstItem, fIsCurrSegmentTypeKnown, !fIsCurrSegmentADir, FALSE, &pidl);
ASSERT(IsValidPIDL(pidl));
if (SUCCEEDED(hr))
{
if (wRemaining[0])
{
Str_SetPtrA(ppwRemaining, wRemaining);
*ppidlCurrentID = pidl;
}
else
*ppidl = pidl;
}
return hr;
}
HRESULT CreateFtpPidlFromFtpWirePath(LPCWIRESTR pwFtpWirePath, CWireEncoding * pwe, ULONG *pcchEaten, LPITEMIDLIST * ppidl, BOOL fIsTypeKnown, BOOL fIsDir)
{
HRESULT hr = E_FAIL;
LPWIRESTR pwRemaining = NULL;
LPITEMIDLIST pidlCurrentID = NULL;
*ppidl = NULL;
if (!pwFtpWirePath[0] || (0 == StrCmpA(pwFtpWirePath, SZ_URL_SLASHA)))
return S_OK;
hr = CreateFtpPidlFromFtpWirePathHelper(pwFtpWirePath, pwe, pcchEaten, ppidl, fIsTypeKnown, fIsDir, &pidlCurrentID, &pwRemaining);
if (SUCCEEDED(hr) && pwRemaining)
{
LPITEMIDLIST pidlSub;
hr = CreateFtpPidlFromFtpWirePath(pwRemaining, pwe, pcchEaten, &pidlSub, fIsTypeKnown, fIsDir);
if (SUCCEEDED(hr))
{
*ppidl = ILCombine(pidlCurrentID, pidlSub);
hr = *ppidl ? S_OK : E_OUTOFMEMORY;
ILFree(pidlSub);
}
ILFree(pidlCurrentID);
Str_SetPtrA(&pwRemaining, NULL);
}
return hr;
}
HRESULT CreateFtpPidlFromUrlPathAndPidl(LPCITEMIDLIST pidl, CWireEncoding * pwe, LPCWIRESTR pwFtpWirePath, LPITEMIDLIST * ppidl)
{
HRESULT hr = E_FAIL;
LPITEMIDLIST pidlNew = ILClone(pidl);
if (pidlNew)
{
LPITEMIDLIST pidlLast = (LPITEMIDLIST) ILGetLastID(pidlNew);
while (!FtpID_IsServerItemID(pidlLast))
{
pidlLast->mkid.cb = 0; // Remove this ID.
pidlLast = (LPITEMIDLIST) ILGetLastID(pidlNew);
}
LPITEMIDLIST pidlUrlPath = NULL;
hr = CreateFtpPidlFromFtpWirePath(pwFtpWirePath, pwe, NULL, &pidlUrlPath, TRUE, TRUE);
if (SUCCEEDED(hr))
{
*ppidl = ILCombine(pidlNew, pidlUrlPath);
}
if (pidlLast)
ILFree(pidlLast);
if (pidlUrlPath)
ILFree(pidlUrlPath);
}
return hr;
}
/*****************************************************************************\
CreateFtpPidlFromUrl
The incoming name is %-encoded, but if we see an illegal %-sequence,
just leave the % alone.
Note that we return E_FAIL when given an unparseable path,
not E_INVALIDARG.
\*****************************************************************************/
HRESULT CreateFtpPidlFromUrl(LPCTSTR pszUrl, CWireEncoding * pwe, ULONG *pcchEaten, LPITEMIDLIST * ppidl, IMalloc * pm, BOOL fHidePassword)
{
return CreateFtpPidlFromUrlEx(pszUrl, pwe, pcchEaten, ppidl, pm, fHidePassword, FALSE, FALSE);
}
/*****************************************************************************\
FUNCTION: CreateFtpPidlFromUrlEx
DESCRIPTION:
pszUrl - This URL will contain an URL Path (/Dir1/Dir2/MayBeFileOrDir).
fIsTypeKnown - We can detect all directories w/o ambiguity because they end
end '/' except for the last directory. fIsTypeKnown is used
if this information is known. If TRUE, fIsDir will be used to
disambiguate the last item. If FALSE, the last item will be marked
a directory if it doesn't have an extension.
The incoming name is %-encoded, but if we see an illegal %-sequence,
just leave the % alone.
Note that we return E_FAIL when given an unparseable path,
not E_INVALIDARG.
\*****************************************************************************/
HRESULT CreateFtpPidlFromUrlEx(LPCTSTR pszUrl, CWireEncoding * pwe, ULONG *pcchEaten, LPITEMIDLIST * ppidl, IMalloc * pm, BOOL fHidePassword, BOOL fIsTypeKnown, BOOL fIsDir)
{
URL_COMPONENTS urlComps = {0};
HRESULT hr = E_FAIL;
// URL = "ftp://<UserName>:<Password>@<HostName>:<PortNum>/Dir1/Dir2/Dir3/file.txt[;Type=[a|b|d]]"
TCHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH];
TCHAR szUrlPath[MAX_URL_STRING];
TCHAR szExtraInfo[MAX_PATH]; // Includes Port Number and download type (ASCII, Binary, Detect)
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH];
TCHAR szPassword[INTERNET_MAX_PASSWORD_LENGTH];
*ppidl = 0;
urlComps.dwStructSize = sizeof(urlComps);
urlComps.lpszHostName = szServer;
urlComps.dwHostNameLength = ARRAYSIZE(szServer);
urlComps.lpszUrlPath = szUrlPath;
urlComps.dwUrlPathLength = ARRAYSIZE(szUrlPath);
urlComps.lpszUserName = szUserName;
urlComps.dwUserNameLength = ARRAYSIZE(szUserName);
urlComps.lpszPassword = szPassword;
urlComps.dwPasswordLength = ARRAYSIZE(szPassword);
urlComps.lpszExtraInfo = szExtraInfo;
urlComps.dwExtraInfoLength = ARRAYSIZE(szExtraInfo);
BOOL fResult = InternetCrackUrl(pszUrl, 0, ICU_DECODE, &urlComps);
if (fResult && (INTERNET_SCHEME_FTP == urlComps.nScheme))
{
LPITEMIDLIST pidl;
DWORD dwDownloadType = 0; // Indicate that it hasn't yet been specified.
BOOL fASCII;
ASSERT(INTERNET_SCHEME_FTP == urlComps.nScheme);
// NOTE:
// If the user is trying to give an NT UserName/DomainName pair, a bug will be encountered.
// Url in AddressBand="ftp://DomainName\UserName:Password@ServerName/"
// Url passed to us="ftp://DomainName/UserName:Password@ServerName/"
// We need to detect this case and fix it because this will cause "DomainName" to become
// the server name and the rest will become the UrlPath.
// ASSERT(!StrChr(szUrlPath, TEXT(':')) && !StrChr(szUrlPath, TEXT('@')));
if (S_OK == UrlRemoveDownloadType(szUrlPath, NULL, &fASCII))
{
if (fASCII)
dwDownloadType = (IDVALID_DLTYPE | IDVALID_DL_ASCII);
else
dwDownloadType = IDVALID_DLTYPE;
}
if (!szServer[0])
{
TraceMsg(TF_FTPURL_UTILS, "CreateFtpPidlFromUrl() failed because szServer=%s", szServer);
hr = E_FAIL; // Bad URL so fail.
}
else
{
//TraceMsg(TF_FTPURL_UTILS, "CreateFtpPidlFromUrl() szServer=%s, szUrlPath=%s, szUserName=%s, szPassword=%s", szServer, szUrlPath, szUserName, szPassword);
hr = FtpServerID_Create(szServer, szUserName, szPassword, dwDownloadType, urlComps.nPort, &pidl, pm, fHidePassword);
if (SUCCEEDED(hr))
{
ASSERT(IsValidPIDL(pidl));
if (szUrlPath[0] && StrCmp(szUrlPath, SZ_URL_SLASH))
{
LPITEMIDLIST pidlSub;
hr = CreateFtpPidlFromDisplayPath(szUrlPath, pwe, pcchEaten, &pidlSub, fIsTypeKnown, fIsDir);
if (SUCCEEDED(hr))
{
// Wininet chokes during requests through Netscape proxies when the GET is
// redirected by the proxy to include the slash. Both FTP folder and
// web-based FTP navigations are affected by this.
if (szUrlPath[lstrlen(szUrlPath)-1] == TEXT(CH_URL_URL_SLASHA))
{
LPCITEMIDLIST pidlLast = ILGetLastID(pidlSub);
if (pidlLast)
FtpItemID_SetCompatFlags(pidlLast, FtpItemID_GetCompatFlags(pidlLast) | COMPAT_APPENDSLASHTOURL);
}
*ppidl = ILCombine(pidl, pidlSub);
if (szExtraInfo[0])
{
LPITEMIDLIST pidlFragment;
WIRECHAR wFragment[MAX_PATH];
// The code page is just whatever the user is using but oh well, I don't
// care about fragments.
SHUnicodeToAnsi(szExtraInfo, wFragment, ARRAYSIZE(wFragment));
// There is a fragment, so we need to add it.
hr = FtpItemID_CreateFake(szExtraInfo, wFragment, TRUE, FALSE, TRUE, &pidlFragment);
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidlPrevious = *ppidl;
*ppidl = ILCombine(pidlPrevious, pidlFragment);
ILFree(pidlPrevious);
ILFree(pidlFragment);
}
}
hr = *ppidl ? S_OK : E_OUTOFMEMORY;
ILFree(pidlSub);
}
ILFree(pidl);
}
else
*ppidl = pidl;
if (SUCCEEDED(hr))
{
ASSERT(IsValidPIDL(*ppidl));
if (pcchEaten)
*pcchEaten = lstrlen(pszUrl); // TODO: Someday we can do this recursively.
}
}
}
}
else
TraceMsg(TF_FTPURL_UTILS, "CreateFtpPidlFromUrl() failed InternetCrackUrl() because pszUrl=%s, fResult=%d, urlComps.nScheme=%d", pszUrl, fResult, urlComps.nScheme);
//TraceMsg(TF_FTPURL_UTILS, "CreateFtpPidlFromUrl() is returning, hr=%#08lx", hr);
return hr;
}
/*****************************************************************************\
FUNCTION: Win32FindDataFromPidl
DESCRIPTION:
Fill in the WIN32_FIND_DATA data structure from the info in the pidl.
\*****************************************************************************/
HRESULT Win32FindDataFromPidl(LPCITEMIDLIST pidl, LPWIN32_FIND_DATAW pwfd, BOOL fFullPath, BOOL fInDisplayFormat)
{
HRESULT hr = E_INVALIDARG;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
ASSERT(pwfd);
if (!EVAL(FtpPidl_IsValid(pidl)))
return E_INVALIDARG;
// I don't want to lie when I pass out File Size and Date info.
if ((IDVALID_FILESIZE | IDVALID_MOD_DATE) & FtpItemID_GetTypeID(pidlLast))
{
pwfd->dwReserved0 = 0;
pwfd->dwReserved1 = 0;
pwfd->cAlternateFileName[0] = 0;
pwfd->nFileSizeLow = FtpItemID_GetFileSizeLo(pidlLast);
pwfd->nFileSizeHigh = FtpItemID_GetFileSizeHi(pidlLast);
pwfd->dwFileAttributes = FtpItemID_GetAttributes(pidlLast);
// See the notes in priv.h on how time works.
pwfd->ftCreationTime = FtpPidl_GetFTPFileTime(pidlLast);
pwfd->ftLastWriteTime = pwfd->ftCreationTime;
pwfd->ftLastAccessTime = pwfd->ftCreationTime;
if (fFullPath)
{
if (fInDisplayFormat)
hr = GetDisplayPathFromPidl(pidl, pwfd->cFileName, ARRAYSIZE(pwfd->cFileName), FALSE);
else
hr = GetWirePathFromPidl(pidl, (LPWIRESTR)pwfd->cFileName, ARRAYSIZE(pwfd->cFileName), FALSE);
}
else
{
hr = S_OK;
if (fInDisplayFormat)
{
FtpPidl_GetLastFileDisplayName(pidl, pwfd->cFileName, ARRAYSIZE(pwfd->cFileName));
}
else
{
LPCWIRESTR pszName = FtpPidl_GetLastItemWireName(pidl);
StrCpyNA((LPWIRESTR)pwfd->cFileName, (pszName ? pszName : ""), ARRAYSIZE(pwfd->cFileName));
}
}
}
return hr;
}
STDAPI_(UINT) ILGetSizeOfFirst(LPCITEMIDLIST pidl)
{
return pidl->mkid.cb;
}
/****************************************************\
FTP Server ItemIDs
\****************************************************/
/****************************************************\
FTP PIDL Cooking functions
\****************************************************/
/*****************************************************************************\
DATA STRUCTURE: FTPIDLIST
DESCRIPTION:
What our private IDLIST looks like for a file, a dir, or a fragment.
The bytes sent to an ftp server or received from an FTP server are
wire bytes (could be UTF-8 or DBCS/MBCS) encoded. We also store
a unicode version that has already been converted after trying to guess
the code page.
Note that the use of any TCHAR inside an IDLIST is COMPLETELY WRONG!
IDLISTs can be saved in a file and reloaded later. If it were saved
by an ANSI version of the shell extension but loaded by a UNICODE
version, things would turn ugly real fast.
\*****************************************************************************/
/*****************************************************************************\
FTPSERVERIDLIST structure
A typical full pidl looks like this:
<Not Our ItemID> [Our ItemID]
<The Internet>\[server,username,password,port#,downloadtype]\[subdir]\...\[file]
The <The Internet> part is whatever the shell gives us in our
CFtpFolder::_Initialize, telling us where in the namespace
we are rooted.
We are concerned only with the parts after the <The Internet> root,
the offset to which is remembered in the CFtpFolder class
in m_ibPidlRoot. Ways of accessing various bits of
information related to our full pidl are provided by our
CFtpFolder implementation, qv.
The first FTP IDList entry describes the server. The remaining
entries describe objects (files or folders) on the server.
\*****************************************************************************/
typedef struct tagFTPSERVERIDLIST
{
DWORD dwIDType; // Server ItemID or Dir ItemID? Which Bits are valid?
DWORD dwVersion; // version
SESSIONKEY sessionKey; // Session Key
DWORD dwPasswordCookie; // Password Cookie
DWORD dwReserved1; // for future use
DWORD dwReserved2; // for future use
DWORD dwReserved3; // for future use
DWORD dwPortNumber; // Port Number on server
DWORD cchServerSize; // StrLen of szServer
CHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH]; // Server
DWORD cchUserNameSize; // StrLen of szUserName
CHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH]; // User Name for Login
DWORD cchPasswordSize; // StrLen of szPassword
CHAR szPassword[INTERNET_MAX_PASSWORD_LENGTH]; // Password for Login
} FTPSERVERIDLIST;
typedef UNALIGNED FTPSERVERIDLIST * LPFTPSERVERIDLIST;
/*****************************************************************************\
DESCRIPTION:
On ia64, we need to worry about alignment issues. The easiest way is
to allocate the struct we have in our PIDL so it's quad word aligned.
We can then use existing code to read out of it. The problem is that
we need to be compatible with old pidls from pre-whistler that are only
DWORD aligned (for alpha machines).
\*****************************************************************************/
LPFTPSERVERIDLIST FtpServerID_GetDataThunk(LPCITEMIDLIST pidl)
{
#ifndef ALIGNMENT_MACHINE
LPFTPSERVERIDLIST pFtpServerItemId = (LPFTPSERVERIDLIST) ProtocolIdlInnerData(pidl);
if (!FtpPidl_IsValid(pidl) ||
!IS_VALID_SERVER_ITEMID(pFtpServerItemId->dwIDType)) // If any other bits are sit, it's invalid.
{
pFtpServerItemId = NULL;
}
#else
LPFTPSERVERIDLIST pFtpServerItemId = NULL;
LPFTPSERVERIDLIST pLocation = (LPFTPSERVERIDLIST) ProtocolIdlInnerData(pidl);
if (FtpPidl_IsValid(pidl) &&
IS_VALID_SERVER_ITEMID(pLocation->dwIDType)) // If any other bits are sit, it's invalid.
{
DWORD cbOffset = (DWORD) (((BYTE *)pLocation - (BYTE *)pidl) % ALIGN_QUAD);
DWORD cbSize = ILGetSizeOfFirst(pidl);
pFtpServerItemId = (LPFTPSERVERIDLIST) LocalAlloc(LPTR, cbSize + cbOffset);
if (pFtpServerItemId)
{
CopyMemory(pFtpServerItemId, pLocation, cbSize-cbOffset);
}
}
#endif // ALIGNMENT_MACHINE
return pFtpServerItemId;
}
void FtpServerID_FreeThunk(LPFTPSERVERIDLIST pFtpServerItemId)
{
#ifndef ALIGNMENT_MACHINE
// We don't need to do anything.
#else
if (pFtpServerItemId)
{
LocalFree(pFtpServerItemId);
}
#endif // ALIGNMENT_MACHINE
}
LPFTPSERVERIDLIST FtpServerID_GetDataSafe(LPCITEMIDLIST pidl)
{
LPFTPSERVERIDLIST pFtpServerItemId = NULL;
if (EVAL(pidl) && !ILIsEmpty(pidl))
{
pFtpServerItemId = (LPFTPSERVERIDLIST) ProtocolIdlInnerData(pidl);
}
return pFtpServerItemId;
}
LPFTPSERVERIDLIST FtpServerID_GetDataSafeThunk(LPCITEMIDLIST pidl)
{
LPFTPSERVERIDLIST pFtpServerItemId = NULL;
if (pidl && !ILIsEmpty(pidl))
{
pFtpServerItemId = FtpServerID_GetDataThunk(pidl);
}
return pFtpServerItemId;
}
BOOL FtpID_IsServerItemID(LPCITEMIDLIST pidl)
{
LPFTPSERVERIDLIST pFtpServerItemID = FtpServerID_GetDataSafeThunk(pidl);
BOOL fIsServerItemID = FALSE;
if (pFtpServerItemID && IS_VALID_SERVER_ITEMID(pFtpServerItemID->dwIDType))
fIsServerItemID = TRUE;
FtpServerID_FreeThunk(pFtpServerItemID);
return fIsServerItemID;
}
LPCITEMIDLIST FtpID_GetLastIDReferense(LPCITEMIDLIST pidl)
{
LPCITEMIDLIST pidlCurrent = pidl;
LPCITEMIDLIST pidlNext = pidl;
if (!pidl || ILIsEmpty(pidl))
return pidl;
for (; !ILIsEmpty(pidlNext); pidl = _ILNext(pidl))
{
pidlCurrent = pidlNext;
pidlNext = _ILNext(pidlNext);
}
return pidlCurrent;
}
CCookieList * g_pCookieList = NULL;
CCookieList * GetCookieList(void)
{
ENTERCRITICAL;
if (!g_pCookieList)
g_pCookieList = new CCookieList();
ASSERT(g_pCookieList);
LEAVECRITICAL;
return g_pCookieList;
}
SESSIONKEY g_SessionKey = {-1, -1};
HRESULT PurgeSessionKey(void)
{
GetSystemTimeAsFileTime(&g_SessionKey);
return S_OK;
}
SESSIONKEY GetSessionKey(void)
{
if (-1 == g_SessionKey.dwHighDateTime)
PurgeSessionKey();
return g_SessionKey;
}
BOOL AreSessionKeysEqual(SESSIONKEY sk1, SESSIONKEY sk2)
{
if ((sk1.dwHighDateTime == sk2.dwHighDateTime) &&
(sk1.dwLowDateTime == sk2.dwLowDateTime))
{
return TRUE;
}
return FALSE;
}
// This is used in order to make sure Alpha machines don't get DWORD mis-aligned.
#define LENGTH_AFTER_ALIGN(nLen, nAlignSize) (((nLen) % (nAlignSize)) ? ((nLen) + ((nAlignSize) - ((nLen) % (nAlignSize)))) : (nLen))
/****************************************************\
FUNCTION: FtpServerID_Create
DESCRIPTION:
Create a Ftp Server ItemID and fill it in.
\****************************************************/
HRESULT FtpServerID_Create(LPCTSTR pszServer, LPCTSTR pszUserName, LPCTSTR pszPassword,
DWORD dwFlags, INTERNET_PORT ipPortNum, LPITEMIDLIST * ppidl, IMalloc *pm, BOOL fHidePassword)
{
HRESULT hr;
DWORD cb;
LPITEMIDLIST pidl = NULL;
DWORD cchServerLen = lstrlen(pszServer);
DWORD cchUserNameLen = lstrlen(pszUserName);
DWORD cchPasswordLen = lstrlen(pszPassword);
LPFTPSERVERIDLIST pFtpServerID = NULL;
cchServerLen = LENGTH_AFTER_ALIGN(cchServerLen + 1, sizeof(DWORD));
cchUserNameLen = LENGTH_AFTER_ALIGN(cchUserNameLen + 1, sizeof(DWORD));
cchPasswordLen = LENGTH_AFTER_ALIGN(cchPasswordLen + 1, sizeof(DWORD));
if (!(EVAL(ppidl) && pszServer[0]))
return E_FAIL;
// Set bits in dwFlags that are appropriate
if (pszUserName[0])
dwFlags |= IDVALID_USERNAME;
if (pszPassword[0])
dwFlags |= IDVALID_PASSWORD;
// Find lenght of FTPSERVERIDLIST struct without the MAX_PATH strings
cb = (sizeof(*pFtpServerID) - sizeof(pFtpServerID->szServer) - sizeof(pFtpServerID->szUserName) - sizeof(pFtpServerID->szPassword));
// Add the size of the strings.
cb += (cchServerLen + cchUserNameLen + cchPasswordLen);
ASSERT(0 == (cb % sizeof(DWORD))); // Make sure it's DWORD aligned for Alpha machines.
pFtpServerID = (LPFTPSERVERIDLIST) LocalAlloc(LPTR, cb);
if (pFtpServerID)
{
LPSTR pszNext;
pszNext = pFtpServerID->szServer;
ZeroMemory(pFtpServerID, cb);
pFtpServerID->dwIDType = (dwFlags | IDTYPE_ISVALID | IDTYPE_SERVER | IDVALID_PORT_NUM);
ASSERT(IS_VALID_SERVER_ITEMID(pFtpServerID->dwIDType));
pFtpServerID->dwVersion = PIDL_VERSION_NUMBER;
pFtpServerID->sessionKey = GetSessionKey();
pFtpServerID->dwPasswordCookie = -1;
pFtpServerID->dwPortNumber = ipPortNum;
pFtpServerID->cchServerSize = cchServerLen;
SHTCharToAnsi(pszServer, pszNext, pFtpServerID->cchServerSize);
pszNext += cchServerLen; // Advance to cchUserNameSize
*((LPDWORD) pszNext) = cchUserNameLen; // Fill in cchUserNameSize
pszNext = (LPSTR)(((UNALIGNED BYTE *) pszNext) + sizeof(DWORD)); // Advance to szUserName
SHTCharToAnsi(pszUserName, pszNext, cchUserNameLen);
if (fHidePassword)
{
pFtpServerID->dwIDType |= IDVALID_HIDE_PASSWORD;
if (EVAL(GetCookieList()))
pFtpServerID->dwPasswordCookie = GetCookieList()->GetCookie(pszPassword);
ASSERT(-1 != pFtpServerID->dwPasswordCookie);
pszPassword = TEXT("");
}
// TraceMsg(TF_FTPURL_UTILS, "FtpServerID_Create(\"ftp://%s:%s@%s/\") dwIDType=%#80lx", pszUserName, pszPassword, pszServer, pFtpServerID->dwIDType);
pszNext += cchUserNameLen; // Advance to cchPasswordLen
*((LPDWORD) pszNext) = cchPasswordLen; // Fill in cchPasswordLen
pszNext = (LPSTR)(((UNALIGNED BYTE *) pszNext) + sizeof(DWORD)); // Advance to szPassword
SHTCharToAnsi(pszPassword, pszNext, cchPasswordLen); // Fill in pszPassword
pidl = (LPITEMIDLIST) pm->Alloc(cb);
if (pidl)
{
LPFTPSERVERIDLIST pFtpServerIDDest = FtpServerID_GetDataSafe(pidl);
if (pFtpServerIDDest)
{
CopyMemory(pFtpServerIDDest, pFtpServerID, cb);
}
}
LocalFree(pFtpServerID);
}
*ppidl = pidl;
hr = pidl ? S_OK : E_OUTOFMEMORY;
ASSERT(IsValidPIDL(*ppidl));
return hr;
}
DWORD FtpServerID_GetTypeID(LPCITEMIDLIST pidl)
{
DWORD dwResult = 0;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
ASSERT(FtpID_IsServerItemID(pidl));
if (pFtpServerID &&
EVAL(FtpPidl_IsValid(pidl)))
{
dwResult = pFtpServerID->dwIDType;
}
FtpServerID_FreeThunk(pFtpServerID);
return dwResult;
}
HRESULT FtpServerID_GetServer(LPCITEMIDLIST pidl, LPTSTR pszServer, DWORD cchSize)
{
HRESULT hr = E_FAIL;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
if (pFtpServerID)
{
SHAnsiToTChar(pFtpServerID->szServer, pszServer, cchSize);
FtpServerID_FreeThunk(pFtpServerID);
hr = S_OK;
}
return hr;
}
BOOL FtpServerID_ServerStrCmp(LPCITEMIDLIST pidl, LPCTSTR pszServer)
{
BOOL fMatch = FALSE;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
#ifdef UNICODE
CHAR szServerAnsi[MAX_PATH];
SHUnicodeToAnsi(pszServer, szServerAnsi, ARRAYSIZE(szServerAnsi));
#endif // UNICODE
if (pFtpServerID)
{
#ifdef UNICODE
fMatch = (0 == StrCmpA(pFtpServerID->szServer, szServerAnsi));
#else // UNICODE
fMatch = (0 == StrCmpA(pFtpServerID->szServer, pszServer));
#endif // UNICODE
}
FtpServerID_FreeThunk(pFtpServerID);
return fMatch;
}
HRESULT FtpServerID_GetUserName(LPCITEMIDLIST pidl, LPTSTR pszUserName, DWORD cchSize)
{
HRESULT hr = E_FAIL;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
if (pFtpServerID)
{
LPCSTR pszSourceUserName = pFtpServerID->szServer + pFtpServerID->cchServerSize + sizeof(DWORD);
SHAnsiToTChar(pszSourceUserName, pszUserName, cchSize);
hr = S_OK;
}
FtpServerID_FreeThunk(pFtpServerID);
return hr;
}
HRESULT FtpServerID_GetPassword(LPCITEMIDLIST pidl, LPTSTR pszPassword, DWORD cchSize, BOOL fIncludingHiddenPassword)
{
HRESULT hr = E_FAIL;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
pszPassword[0] = 0;
if (pFtpServerID)
{
// Was the password hidden?
if (fIncludingHiddenPassword &&
(IDVALID_HIDE_PASSWORD & pFtpServerID->dwIDType))
{
// Yes, so get it out of the cookie jar (list)
if (EVAL(GetCookieList()) &&
AreSessionKeysEqual(pFtpServerID->sessionKey, GetSessionKey()))
{
hr = GetCookieList()->GetString(pFtpServerID->dwPasswordCookie, pszPassword, cchSize);
}
}
else
{
// No, so what's in the pidl is the real password.
BYTE * pvSizeOfUserName = (BYTE *) (pFtpServerID->szServer + pFtpServerID->cchServerSize);
DWORD dwSizeOfUserName = *(DWORD *) pvSizeOfUserName;
LPCSTR pszSourcePassword = (LPCSTR) (pvSizeOfUserName + dwSizeOfUserName + 2*sizeof(DWORD));
SHAnsiToTChar(pszSourcePassword, pszPassword, cchSize);
hr = S_OK;
}
}
FtpServerID_FreeThunk(pFtpServerID);
return hr;
}
INTERNET_PORT FtpServerID_GetPortNum(LPCITEMIDLIST pidl)
{
INTERNET_PORT portReturn = INTERNET_DEFAULT_FTP_PORT;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
ASSERT(FtpID_IsServerItemID(pidl));
if (pFtpServerID)
{
portReturn = (INTERNET_PORT)pFtpServerID->dwPortNumber;
FtpServerID_FreeThunk(pFtpServerID);
}
return portReturn;
}
HRESULT FtpServerID_SetHiddenPassword(LPITEMIDLIST pidl, LPCTSTR pszPassword)
{
HRESULT hr = E_INVALIDARG;
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
ASSERT(FtpID_IsServerItemID(pidl));
if (pFtpServerID)
{
pFtpServerID->sessionKey = GetSessionKey();
pFtpServerID->dwIDType |= IDVALID_HIDE_PASSWORD;
if (EVAL(GetCookieList()))
pFtpServerID->dwPasswordCookie = GetCookieList()->GetCookie(pszPassword);
hr = S_OK;
}
FtpServerID_FreeThunk(pFtpServerID);
return hr;
}
HRESULT FtpServerID_GetStrRet(LPCITEMIDLIST pidl, LPSTRRET lpName)
{
LPFTPSERVERIDLIST pFtpServerID = FtpServerID_GetDataThunk(pidl);
ASSERT(FtpID_IsServerItemID(pidl));
if (pFtpServerID)
{
lpName->uType = STRRET_OFFSET;
lpName->uOffset = (DWORD) (sizeof(FTPSERVERIDLIST) - sizeof(pFtpServerID->szServer) + (LPBYTE)pFtpServerID - (LPBYTE)pidl);
}
else
{
lpName->uType = STRRET_CSTR;
lpName->cStr[0] = '\0';
}
FtpServerID_FreeThunk(pFtpServerID);
return S_OK;
}
/****************************************************\
FTP File/Dir ItemIDs
\****************************************************/
typedef struct tagFTPIDLIST
{
DWORD dwIDType; // Server ItemID or Dir ItemID? Which Bits are valid?
DWORD dwAttributes; // What are the file/dir attributes
ULARGE_INTEGER uliFileSize;
FILETIME ftModified; // Stored in Local Time Zone. (FTP Time)
DWORD dwUNIXPermission; // UNIX CHMOD Permissions (0x00000777, 4=Read, 2=Write, 1=Exec, <Owner><Group><All>)
DWORD dwCompatFlags; // Special case handling
WIRECHAR szWireName[MAX_PATH]; // Needs to go last.
WCHAR wzDisplayName[MAX_PATH]; // Converted to unicode to be displayed in the UI.
} FTPIDLIST;
typedef UNALIGNED FTPIDLIST * LPFTPIDLIST;
HRESULT FtpItemID_Alloc(LPFTPIDLIST pfi, LPITEMIDLIST * ppidl);
typedef struct _FTPIDLIST_WITHHEADER
{
USHORT cb; // size
FTPIDLIST fidListData;
USHORT cbTerminator; // size of next ID (Empty)
} FTPIDLIST_WITHHEADER;
LPFTPIDLIST FtpItemID_GetDataInternal(LPCITEMIDLIST pidl)
{
BYTE * pbData = (BYTE *) pidl;
pbData += SIZE_ITEMID_SIZEFIELD; // Skip over the size.
LPFTPIDLIST pFtpItemId = (LPFTPIDLIST) pbData;
if (!EVAL(IS_VALID_DIRORFILE_ITEMID(pFtpItemId->dwIDType))) // If any other bits are sit, it's invalid.
pFtpItemId = NULL;
return pFtpItemId;
}
/*****************************************************************************\
DESCRIPTION:
On ia64, we need to worry about alignment issues. The easiest way is
to allocate the struct we have in our PIDL so it's quad word aligned.
We can then use existing code to read out of it. The problem is that
we need to be compatible with old pidls from pre-whistler that are only
DWORD aligned (for alpha machines).
\*****************************************************************************/
LPFTPIDLIST FtpItemID_GetDataThunk(LPCITEMIDLIST pidl)
{
#ifndef ALIGNMENT_MACHINE
LPFTPIDLIST pFtpItemId = FtpItemID_GetDataInternal(pidl);
#else
LPFTPIDLIST pFtpItemId = NULL;
LPFTPIDLIST pLocation = FtpItemID_GetDataInternal(pidl);
if (pLocation)
{
DWORD cbSize = ILGetSizeOfFirst(pidl);
pFtpItemId = (LPFTPIDLIST) LocalAlloc(LPTR, cbSize);
if (pFtpItemId)
{
CopyMemory(pFtpItemId, pLocation, cbSize - SIZE_ITEMID_SIZEFIELD);
}
}
#endif // ALIGNMENT_MACHINE
return pFtpItemId;
}
void FtpItemID_FreeThunk(LPFTPIDLIST pFtpItemId)
{
#ifndef ALIGNMENT_MACHINE
// We don't need to do anything.
#else
if (pFtpItemId)
{
LocalFree(pFtpItemId);
}
#endif // ALIGNMENT_MACHINE
}
LPCUWSTR FtpItemID_GetDisplayNameReference(LPCITEMIDLIST pidl)
{
BYTE * pbData = (BYTE *) pidl;
LPCUWSTR pwzDisplayName = NULL;
DWORD cbWireName;
// Is the version OK?
// if (PIDL_VERSION_NUMBER > FtpPidl_GetVersion(pidl))
// return NULL;
pbData += SIZE_ITEMID_SIZEFIELD; // Skip over the size.
LPFTPIDLIST pFtpItemId = (LPFTPIDLIST) pbData;
cbWireName = LENGTH_AFTER_ALIGN((lstrlenA(pFtpItemId->szWireName) + 1), sizeof(DWORD));
pwzDisplayName = (LPCUWSTR) ((BYTE *)(&pFtpItemId->szWireName[0]) + cbWireName);
if (!EVAL(IS_VALID_DIRORFILE_ITEMID(pFtpItemId->dwIDType))) // If any other bits are sit, it's invalid.
pwzDisplayName = NULL;
return pwzDisplayName;
}
DWORD FtpItemID_GetTypeID(LPCITEMIDLIST pidl)
{
LPFTPIDLIST pFtpItemId = FtpItemID_GetDataThunk(pidl);
DWORD dwType = (pFtpItemId ? pFtpItemId->dwIDType : 0);
FtpItemID_FreeThunk(pFtpItemId);
return dwType;
}
void FtpItemID_SetTypeID(LPITEMIDLIST pidl, DWORD dwNewTypeID)
{
LPFTPIDLIST pFtpItemId = FtpItemID_GetDataInternal(pidl);
if (EVAL(pFtpItemId))
pFtpItemId->dwIDType = dwNewTypeID;
}
/****************************************************\
FUNCTION: FtpItemID_Alloc
DESCRIPTION:
We are passed a pointer to a FTPIDLIST data
structure and our goal is to create a ItemID from
it. This mainly includes making it only big enough
for the current string(s).
\****************************************************/
HRESULT FtpItemID_Alloc(LPFTPIDLIST pfi, LPITEMIDLIST * ppidl)
{
HRESULT hr;
WORD cbTotal;
WORD cbDataFirst;
WORD cbData;
BYTE * pbMemory;
DWORD cchSizeOfName = lstrlenA(pfi->szWireName);
DWORD cchSizeOfDispName = ualstrlenW(pfi->wzDisplayName);
ASSERT(pfi && ppidl);
// Find lenght of FTPIDLIST struct if the szName member only needed enought room
// for the string, not the full MAX_PATH.
// Size EQUALS: (Everything in the struct) - (the 2 full statusly sized strings) + (the 2 packed strings + alignment)
cbDataFirst = (WORD)((sizeof(*pfi) - sizeof(pfi->szWireName) - sizeof(pfi->wzDisplayName)) + LENGTH_AFTER_ALIGN(cchSizeOfName + 1, sizeof(DWORD)) - sizeof(DWORD));
cbData = cbDataFirst + (WORD) LENGTH_AFTER_ALIGN((cchSizeOfDispName + 1) * sizeof(WCHAR), sizeof(DWORD));
ASSERT((cbData % sizeof(DWORD)) == 0); // Verify it's DWORD aligned.
cbTotal = (SIZE_ITEMID_SIZEFIELD + cbData + SIZE_ITEMID_TERMINATOR);
pbMemory = (BYTE *) CoTaskMemAlloc(cbTotal);
if (pbMemory)
{
USHORT * pIDSize = (USHORT *)pbMemory;
BYTE * pbData = (pbMemory + SIZE_ITEMID_SIZEFIELD); // the Data starts at the second DWORD.
USHORT * pIDTerminator = (USHORT *)(pbMemory + SIZE_ITEMID_SIZEFIELD + cbData);
pIDSize[0] = (cbTotal - SIZE_ITEMID_TERMINATOR); // Set the size of the ItemID (including the next ItemID as terminator)
ASSERT(cbData <= sizeof(*pfi)); // Don't let me copy too much.
CopyMemory(pbData, pfi, cbDataFirst);
CopyMemory((pbData + cbDataFirst), &(pfi->wzDisplayName), ((cchSizeOfDispName + 1) * sizeof(WCHAR)));
pIDTerminator[0] = 0; // Terminate the next ID.
// TraceMsg(TF_FTPURL_UTILS, "FtpItemID_Alloc(\"%ls\") dwIDType=%#08lx, dwAttributes=%#08lx", pfi->wzDisplayName, pfi->dwIDType, pfi->dwAttributes);
}
*ppidl = (LPITEMIDLIST) pbMemory;
hr = pbMemory ? S_OK : E_OUTOFMEMORY;
ASSERT(IsValidPIDL(*ppidl));
ASSERT_POINTER_MATCHES_HRESULT(*ppidl, hr);
return hr;
}
/*****************************************************************************\
FUNCTION: FtpItemID_CreateReal
DESCRIPTION:
Cook up a pidl based on a WIN32_FIND_DATA.
The cFileName field is itself MAX_PATH characters long,
so its length cannot possibly exceed MAX_PATH...
\*****************************************************************************/
HRESULT FtpItemID_CreateReal(const LPFTP_FIND_DATA pwfd, LPCWSTR pwzDisplayName, LPITEMIDLIST * ppidl)
{
HRESULT hr;
FTPIDLIST fi = {0};
// Fill in fi.
fi.dwIDType = (IDTYPE_ISVALID | IDVALID_FILESIZE | IDVALID_MOD_DATE);
fi.uliFileSize.LowPart = pwfd->nFileSizeLow;
fi.uliFileSize.HighPart = pwfd->nFileSizeHigh;
fi.ftModified = pwfd->ftLastWriteTime;
fi.dwAttributes = pwfd->dwFileAttributes;
fi.dwUNIXPermission = pwfd->dwReserved0; // Set by WININET
StrCpyNA(fi.szWireName, pwfd->cFileName, ARRAYSIZE(fi.szWireName));
StrCpyN(fi.wzDisplayName, pwzDisplayName, ARRAYSIZE(fi.wzDisplayName));
if (pwfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
fi.dwIDType |= IDTYPE_DIR;
else
fi.dwIDType |= IDTYPE_FILE;
hr = FtpItemID_Alloc(&fi, ppidl);
ASSERT(IsValidPIDL(*ppidl));
return hr;
}
/****************************************************\
FUNCTION: FtpItemID_CreateFake
DESCRIPTION:
Create a ItemID but we are only setting the
name. We don't know the true file attributes,
file size, or modification date yet because
we haven't touched the server yet. If we did,
we would use the returned WIN32_FIND_DATA struct
to create the ItemID by using FtpItemID_CreateReal().
\****************************************************/
HRESULT FtpItemID_CreateFake(LPCWSTR pwzDisplayName, LPCWIRESTR pwWireName, BOOL fTypeKnown, BOOL fIsFile, BOOL fIsFragment, LPITEMIDLIST * ppidl)
{
HRESULT hr;
DWORD dwType = IDTYPE_ISVALID;
FTPIDLIST fi = {0};
// Is it unknown?
if (!fTypeKnown)
{
// HACK: We will assume everything w/o a file extension is a Dir
// and everything w/an extension is a file.
fTypeKnown = TRUE;
fIsFile = (!pwzDisplayName || (0 == *PathFindExtension(pwzDisplayName))) ? FALSE : TRUE;
}
if (fTypeKnown)
{
if (fIsFile)
dwType |= IDTYPE_FILE;
else if (fIsFragment)
dwType |= IDTYPE_FRAGMENT;
else
dwType |= IDTYPE_DIR;
}
else
{
// You need to know if it's a fragment because there is no
// heuristic to find out.
ASSERT(!fIsFragment);
dwType |= IDTYPE_FILEORDIR;
}
fi.dwIDType = dwType;
fi.dwAttributes = (fIsFile ? FILE_ATTRIBUTE_NORMAL : FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_DIRECTORY);
fi.uliFileSize.QuadPart = 0;
StrCpyNW(fi.wzDisplayName, pwzDisplayName, ARRAYSIZE(fi.wzDisplayName));
StrCpyNA(fi.szWireName, pwWireName, ARRAYSIZE(fi.szWireName));
hr = FtpItemID_Alloc(&fi, ppidl);
ASSERT(IsValidPIDL(*ppidl));
ASSERT_POINTER_MATCHES_HRESULT(*ppidl, hr);
return hr;
}
/*****************************************************************************\
FUNCTION: FtpItemID_SetName
DESCRIPTION:
The user chose a new name for the ftp file or dir (in unicode). We
now need to create the name in wire bytes and we will use the original
wire byte name to decide how to do that (from pidl).
\*****************************************************************************/
HRESULT FtpItemID_CreateWithNewName(LPCITEMIDLIST pidl, LPCWSTR pwzDisplayName, LPCWIRESTR pwWireName, LPITEMIDLIST * ppidlOut)
{
HRESULT hr = E_FAIL;
FTPIDLIST fi;
const FTPIDLIST UNALIGNED * pfi = FtpItemID_GetDataThunk(pidl);
if (pfi)
{
CWireEncoding cWireEncoding;
CopyMemory(&fi, pfi, sizeof(FTPIDLIST) - sizeof(fi.szWireName) - sizeof(fi.wzDisplayName));
StrCpyNW(fi.wzDisplayName, pwzDisplayName, ARRAYSIZE(fi.wzDisplayName));
StrCpyNA(fi.szWireName, pwWireName, ARRAYSIZE(fi.szWireName));
hr = FtpItemID_Alloc(&fi, ppidlOut);
ASSERT(IsValidPIDL(*ppidlOut));
FtpItemID_FreeThunk((FTPIDLIST UNALIGNED *) pfi);
}
return hr;
}
HRESULT Private_GetFileInfo(SHFILEINFO *psfi, DWORD rgf, LPCTSTR pszName, DWORD dwFileAttributes)
{
HRESULT hr = E_FAIL;
if (SHGetFileInfo(pszName, dwFileAttributes, psfi, sizeof(*psfi), rgf | SHGFI_USEFILEATTRIBUTES))
hr = S_OK;
return hr;
}
/*****************************************************************************\
FUNCTION: FtpPidl_GetFileInfo
DESCRIPTION:
_UNDOCUMENTED_: We strip the Hidden and System bits so
that SHGetFileInfo won't think that we're passing something
that might be a junction.
We also force the SHGFI_USEFILEATTRIBUTES bit to remind the shell
that this isn't a file.
\*****************************************************************************/
HRESULT FtpPidl_GetFileInfo(LPCITEMIDLIST pidl, SHFILEINFO *psfi, DWORD rgf)
{
HRESULT hr = E_FAIL;
TCHAR szDisplayName[MAX_PATH];
psfi->iIcon = 0;
psfi->hIcon = NULL;
psfi->dwAttributes = 0;
psfi->szDisplayName[0] = 0;
psfi->szTypeName[0] = 0;
ASSERT(IsValidPIDL(pidl));
if (FtpID_IsServerItemID(pidl))
{
FtpServerID_GetServer(pidl, szDisplayName, ARRAYSIZE(szDisplayName));
hr = Private_GetFileInfo(psfi, rgf, szDisplayName, FILE_ATTRIBUTE_DIRECTORY);
if (psfi->hIcon)
DestroyIcon(psfi->hIcon);
psfi->hIcon = LoadIcon(HINST_THISDLL, MAKEINTRESOURCE(IDI_FTPFOLDER));
ASSERT(psfi->hIcon);
// Now replace the type (szTypeName) with "FTP Server" because
// it could go in the Properties dialog
EVAL(LoadString(HINST_THISDLL, IDS_ITEMTYPE_SERVER, psfi->szTypeName, ARRAYSIZE(psfi->szTypeName)));
}
else
{
LPFTPIDLIST pfi = FtpItemID_GetDataThunk(pidl);
if (pfi)
{
FtpItemID_GetDisplayName(pidl, szDisplayName, ARRAYSIZE(szDisplayName));
hr = Private_GetFileInfo(psfi, rgf, szDisplayName, (pfi->dwAttributes & ~(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)));
FtpItemID_FreeThunk(pfi);
}
}
return hr;
}
HRESULT FtpPidl_GetFileType(LPCITEMIDLIST pidl, LPTSTR pszType, DWORD cchSize)
{
SHFILEINFO sfi;
HRESULT hr;
ASSERT(IsValidPIDL(pidl));
hr = FtpPidl_GetFileInfo(pidl, &sfi, SHGFI_TYPENAME);
if (SUCCEEDED(hr))
{
StrCpyN(pszType, sfi.szTypeName, cchSize);
if (sfi.hIcon)
DestroyIcon(sfi.hIcon);
}
return hr;
}
HRESULT FtpPidl_GetFileTypeStrRet(LPCITEMIDLIST pidl, LPSTRRET pstr)
{
WCHAR szType[MAX_URL_STRING];
HRESULT hr;
ASSERT(IsValidPIDL(pidl));
hr = FtpPidl_GetFileType(pidl, szType, ARRAYSIZE(szType));
if (EVAL(SUCCEEDED(hr)))
StringToStrRetW(szType, pstr);
return hr;
}
/*****************************************************************************\
FUNCTION: _FtpItemID_CompareOneID
DESCRIPTION:
ici - attribute (column) to compare
Note! that UNIX filenames are case-*sensitive*.
We make two passes on the name. If the names are different in other
than case, we return the result of that comparison. Otherwise,
we return the result of a case-sensitive comparison.
This algorithm ensures that the items sort themselves in a
case-insensitive way, with ties broken by a case-sensitive
comparison. This makes ftp folders act "mostly" like normal
folders.
_UNDOCUMENTED_: The documentation says that the ici parameter
is undefined and must be zero. In reality, it is the column
number (defined by IShellView) for which the comparison is to
be made.
\*****************************************************************************/
HRESULT _FtpItemID_CompareOneID(LPARAM ici, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwCompFlags)
{
int iRc = 0; // 0 means we don't know.
HRESULT hr = S_OK;
ASSERT(IsValidPIDL(pidl1));
ASSERT(IsValidPIDL(pidl2));
// Are they both the same type? (Both Dirs or both files?)
if (!(dwCompFlags & FCMP_GROUPDIRS) || (!FtpPidl_IsDirectory(pidl1, FALSE) == !FtpPidl_IsDirectory(pidl2, FALSE)))
{
switch (ici & SHCIDS_COLUMNMASK)
{
case COL_NAME:
{
// Yes they are the same, so we will key off the name...
WIRECHAR szName1[MAX_PATH];
WIRECHAR szName2[MAX_PATH];
szName1[0] = TEXT('\0');
szName2[0] = TEXT('\0');
FtpPidl_GetWireName(pidl1, szName1, ARRAYSIZE(szName1));
FtpPidl_GetWireName(pidl2, szName2, ARRAYSIZE(szName2));
iRc = StrCmpIA(szName1, szName2);
if (0 == iRc)
{
if (!(dwCompFlags & FCMP_CASEINSENSE))
iRc = StrCmpA(szName1, szName2);
/*
// They are the same name, so now lets check on the username
// if they are Server IDs.
if ((0 == iRc) && (FtpID_IsServerItemID(pidl1)))
{
FtpPidl_GetUserName(pidl1, szName1, ARRAYSIZE(szName1));
FtpPidl_GetUserName(pidl2, szName2, ARRAYSIZE(szName2));
iRc = StrCmp(szName1, szName2);
}
*/
}
}
break;
case COL_SIZE:
if (FtpPidl_GetFileSize(pidl1) < FtpPidl_GetFileSize(pidl2))
iRc = -1;
else if (FtpPidl_GetFileSize(pidl1) > FtpPidl_GetFileSize(pidl2))
iRc = +1;
else
iRc = 0; // I don't know
break;
case COL_TYPE:
if (!FtpID_IsServerItemID(pidl1) && !FtpID_IsServerItemID(pidl2))
{
TCHAR szType1[MAX_PATH];
hr = FtpPidl_GetFileType(pidl1, szType1, ARRAYSIZE(szType1));
if (EVAL(SUCCEEDED(hr)))
{
TCHAR szType2[MAX_PATH];
hr = FtpPidl_GetFileType(pidl2, szType2, ARRAYSIZE(szType2));
if (EVAL(SUCCEEDED(hr)))
iRc = StrCmpI(szType1, szType2);
}
}
break;
case COL_MODIFIED:
{
FILETIME ft1 = FtpPidl_GetFileTime(pidl1);
FILETIME ft2 = FtpPidl_GetFileTime(pidl2);
iRc = CompareFileTime(&ft1, &ft2);
}
break;
default:
hr = E_NOTIMPL;
break;
}
}
else
{
// No they are different. We want the Folder to always come first.
// This doesn't seam right, but it forces folders to bubble to the top
// in the most frequent case and it matches DefView's Behavior.
if (FtpPidl_IsDirectory(pidl1, FALSE))
iRc = -1;
else
iRc = 1;
}
if (S_OK == hr)
hr = HRESULT_FROM_SUCCESS_VALUE(iRc); // encode the sort value in the return code.
return hr;
}
/*****************************************************************************\
FUNCTION: FtpItemID_CompareIDs
DESCRIPTION:
ici - attribute (column) to compare
Note! that we rely on the fact that IShellFolders are
uniform; we do not need to bind to the shell folder in
order to compare its sub-itemids.
_UNDOCUMENTED_: The documentation does not say whether or not
complex pidls can be received. In fact, they can.
The reason why the shell asks you to handle complex pidls
is that you can often short-circuit the comparison by walking
the ID list directly. (Formally speaking, you need to bind
to each ID and then call yourself recursively. But if your
pidls are uniform, you can just use a loop like the one below.)
\*****************************************************************************/
HRESULT FtpItemID_CompareIDs(LPARAM ici, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwCompFlags)
{
HRESULT hr;
if (!pidl1 || ILIsEmpty(pidl1))
{
if (!pidl2 || ILIsEmpty(pidl2))
hr = HRESULT_FROM_SUCCESS_VALUE(0); // Both ID lists are empty
else
hr = HRESULT_FROM_SUCCESS_VALUE(-1); // pidl1 is empty, pidl2 is nonempty
}
else
{
if (!pidl2 || ILIsEmpty(pidl2))
hr = HRESULT_FROM_SUCCESS_VALUE(1); // pidl1 is nonempty, pidl2 is empty
else
{
ASSERT(IsValidPIDL(pidl1));
ASSERT(IsValidPIDL(pidl2));
hr = _FtpItemID_CompareOneID(ici, pidl1, pidl2, dwCompFlags); // both are nonempty
}
}
// If this level of ItemsIDs are equal, then we will compare the next
// level of ItemIDs
if ((hr == HRESULT_FROM_SUCCESS_VALUE(0)) && pidl1 && !ILIsEmpty(pidl1))
hr = FtpItemID_CompareIDs(ici, _ILNext(pidl1), _ILNext(pidl2), dwCompFlags);
return hr;
}
int FtpItemID_CompareIDsInt(LPARAM ici, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwCompFlags)
{
HRESULT hr = FtpItemID_CompareIDs(ici, pidl1, pidl2, dwCompFlags);
int nResult = (DWORD)(short)hr;
return nResult;
}
DWORD FtpItemID_GetAttributes(LPCITEMIDLIST pidl)
{
DWORD dwAttributes = 0;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (pFtpIDList)
{
dwAttributes = pFtpIDList->dwAttributes;
FtpItemID_FreeThunk(pFtpIDList);
}
return dwAttributes;
}
HRESULT FtpItemID_SetAttributes(LPCITEMIDLIST pidl, DWORD dwAttribs)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (!pFtpIDList)
return E_INVALIDARG;
pFtpIDList->dwAttributes = dwAttribs;
return S_OK;
}
DWORD FtpItemID_GetUNIXPermissions(LPCITEMIDLIST pidl)
{
DWORD dwPermissions = 0;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (pFtpIDList)
{
dwPermissions = pFtpIDList->dwUNIXPermission;
FtpItemID_FreeThunk(pFtpIDList);
}
return dwPermissions;
}
HRESULT FtpItemID_SetUNIXPermissions(LPCITEMIDLIST pidl, DWORD dwUNIXPermission)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (!pFtpIDList)
return E_INVALIDARG;
pFtpIDList->dwUNIXPermission = dwUNIXPermission;
return S_OK;
}
DWORD FtpItemID_GetCompatFlags(LPCITEMIDLIST pidl)
{
DWORD dwCompatFlags = 0;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (pFtpIDList)
{
dwCompatFlags = pFtpIDList->dwCompatFlags;
FtpItemID_FreeThunk(pFtpIDList);
}
return dwCompatFlags;
}
HRESULT FtpItemID_SetCompatFlags(LPCITEMIDLIST pidl, DWORD dwCompatFlags)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (!pFtpIDList)
return E_INVALIDARG;
pFtpIDList->dwCompatFlags = dwCompatFlags;
return S_OK;
}
ULONGLONG FtpItemID_GetFileSize(LPCITEMIDLIST pidl)
{
ULONGLONG uliFileSize = 0;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (pFtpIDList)
{
ASSERT(IsFlagSet(pFtpIDList->dwIDType, IDVALID_FILESIZE));
uliFileSize = pFtpIDList->uliFileSize.QuadPart;
FtpItemID_FreeThunk(pFtpIDList);
}
return uliFileSize;
}
void FtpItemID_SetFileSize(LPCITEMIDLIST pidl, ULARGE_INTEGER uliFileSize)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (!pFtpIDList)
return;
pFtpIDList->uliFileSize = uliFileSize;
pFtpIDList->dwIDType |= IDVALID_FILESIZE;
}
DWORD FtpItemID_GetFileSizeLo(LPCITEMIDLIST pidl)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (!pFtpIDList)
return NULL;
ASSERT(IsFlagSet(pFtpIDList->dwIDType, IDVALID_FILESIZE));
DWORD dwSize = pFtpIDList->uliFileSize.LowPart;
FtpItemID_FreeThunk(pFtpIDList);
return dwSize;
}
DWORD FtpItemID_GetFileSizeHi(LPCITEMIDLIST pidl)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (!pFtpIDList)
return NULL;
ASSERT(IsFlagSet(pFtpIDList->dwIDType, IDVALID_FILESIZE));
DWORD dwSize = pFtpIDList->uliFileSize.HighPart;
FtpItemID_FreeThunk(pFtpIDList);
return dwSize;
}
// Return value is in Local Time Zone.
FILETIME FtpItemID_GetFileTime(LPCITEMIDLIST pidl)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
FILETIME ftEmpty = {0};
if (pFtpIDList)
{
ASSERT(IsFlagSet(pFtpIDList->dwIDType, IDVALID_MOD_DATE));
ftEmpty = pFtpIDList->ftModified;
FtpItemID_FreeThunk(pFtpIDList);
}
return ftEmpty;
}
LPCWIRESTR FtpItemID_GetWireNameReference(LPCITEMIDLIST pidl)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (!pFtpIDList || IS_FRAGMENT(pFtpIDList))
return NULL;
return pFtpIDList->szWireName;
}
HRESULT FtpItemID_GetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwzName, DWORD cchSize)
{
HRESULT hr = S_OK;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (pFtpIDList)
{
if (!IS_FRAGMENT(pFtpIDList))
{
LPCUWSTR pszUnalignedName = FtpItemID_GetDisplayNameReference(pidl);
if (pszUnalignedName)
{
// The display name wasn't stored in v3
ualstrcpynW(pwzName, pszUnalignedName, cchSize);
}
}
else
{
pwzName[0] = TEXT('\0');
hr = E_FAIL;
}
FtpItemID_FreeThunk(pFtpIDList);
}
return hr;
}
HRESULT FtpItemID_GetWireName(LPCITEMIDLIST pidl, LPWIRESTR pszName, DWORD cchSize)
{
HRESULT hr = S_OK;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (pFtpIDList && !IS_FRAGMENT(pFtpIDList))
StrCpyNA(pszName, pFtpIDList->szWireName, cchSize);
else
{
pszName[0] = TEXT('\0');
hr = E_FAIL;
}
return hr;
}
HRESULT FtpItemID_GetFragment(LPCITEMIDLIST pidl, LPWSTR pwzFragmentStr, DWORD cchSize)
{
HRESULT hr = E_FAIL;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (pFtpIDList && IS_FRAGMENT(pFtpIDList))
{
LPCUWSTR pszUnalignedName = FtpItemID_GetDisplayNameReference(pidl);
if (pszUnalignedName)
{
// The display name wasn't stored in v3
ualstrcpynW(pwzFragmentStr, pszUnalignedName, cchSize);
hr = S_OK;
}
}
else
{
pwzFragmentStr[0] = TEXT('\0');
hr = E_FAIL;
}
return hr;
}
BOOL FtpItemID_IsFragment(LPCITEMIDLIST pidl)
{
BOOL fIsFrag = FALSE;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (pFtpIDList && IS_FRAGMENT(pFtpIDList))
fIsFrag = TRUE;
return fIsFrag;
}
// fileTime In UTC
void FtpItemID_SetFileTime(LPCITEMIDLIST pidl, FILETIME fileTime)
{
FILETIME fileTimeLocal;
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataInternal(pidl);
if (!pFtpIDList)
return;
FileTimeToLocalFileTime(&fileTime, &fileTimeLocal);
pFtpIDList->ftModified = fileTimeLocal;
pFtpIDList->dwIDType |= IDVALID_MOD_DATE;
}
BOOL FtpItemID_IsDirectory(LPCITEMIDLIST pidl, BOOL fAssumeDirForUnknown)
{
LPFTPIDLIST pFtpIDList = FtpItemID_GetDataThunk(pidl);
if (!pFtpIDList)
return NULL;
BOOL fIsDir = (IsFlagSet(pFtpIDList->dwIDType, IDTYPE_DIR));
if (fAssumeDirForUnknown && (IDTYPE_FILEORDIR == pFtpIDList->dwIDType))
{
// TraceMsg(TF_FTPURL_UTILS, "FtpItemID_IsDirectory() IDTYPE_FILEORDIR is set, so we assume %s", (fAssumeDirForUnknown ? TEXT("DIR") : TEXT("FILE")));
fIsDir = TRUE;
}
else
{
// TraceMsg(TF_FTPURL_UTILS, "FtpItemID_IsDirectory() It is known to be a %s", (fIsDir ? TEXT("DIR") : TEXT("FILE")));
}
FtpItemID_FreeThunk(pFtpIDList);
return fIsDir;
}
/****************************************************\
Functions to work on an entire FTP PIDLs
\****************************************************/
#define SZ_ASCII_DOWNLOAD_TYPE TEXT("a")
#define SZ_BINARY_DOWNLOAD_TYPE TEXT("b")
HRESULT FtpPidl_GetDownloadTypeStr(LPCITEMIDLIST pidl, LPTSTR szDownloadType, DWORD cchTypeStrSize)
{
HRESULT hr = S_FALSE; // We may not have a type.
DWORD dwTypeID = FtpServerID_GetTypeID(pidl);
szDownloadType[0] = TEXT('\0');
if (IDVALID_DLTYPE & dwTypeID)
{
hr = S_OK;
StrCpyN(szDownloadType, SZ_FTP_URL_TYPE, cchTypeStrSize);
if (IDVALID_DL_ASCII & dwTypeID)
StrCatBuff(szDownloadType, SZ_ASCII_DOWNLOAD_TYPE, cchTypeStrSize);
else
StrCatBuff(szDownloadType, SZ_BINARY_DOWNLOAD_TYPE, cchTypeStrSize);
}
return hr;
}
DWORD FtpPidl_GetDownloadType(LPCITEMIDLIST pidl)
{
DWORD dwAttribs = FTP_TRANSFER_TYPE_UNKNOWN;
DWORD dwTypeID = FtpServerID_GetTypeID(pidl);
ASSERT(FtpID_IsServerItemID(pidl));
if (IDVALID_DLTYPE & dwTypeID)
{
if (IDVALID_DL_ASCII & dwTypeID)
dwAttribs = FTP_TRANSFER_TYPE_ASCII;
else
dwAttribs = FTP_TRANSFER_TYPE_BINARY;
}
return dwAttribs;
}
INTERNET_PORT FtpPidl_GetPortNum(LPCITEMIDLIST pidl)
{
ASSERT(FtpID_IsServerItemID(pidl));
return FtpServerID_GetPortNum(pidl);
}
BOOL FtpPidl_IsDirectory(LPCITEMIDLIST pidl, BOOL fAssumeDirForUnknown)
{
BOOL fIsDir = FALSE;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (!FtpID_IsServerItemID(pidlLast))
fIsDir = FtpItemID_IsDirectory(pidlLast, fAssumeDirForUnknown);
return fIsDir;
}
BOOL FtpPidl_IsAnonymous(LPCITEMIDLIST pidl)
{
BOOL fIsAnonymous = TRUE;
if (IDVALID_USERNAME & FtpServerID_GetTypeID(pidl))
fIsAnonymous = FALSE;
return fIsAnonymous;
}
HRESULT FtpPidl_GetServer(LPCITEMIDLIST pidl, LPTSTR pszServer, DWORD cchSize)
{
if (!FtpID_IsServerItemID(pidl)) // Will fail if we are handed a non-server ID.
return E_FAIL;
return FtpServerID_GetServer(pidl, pszServer, cchSize);
}
BOOL FtpPidl_IsDNSServerName(LPCITEMIDLIST pidl)
{
BOOL fIsDNSServer = FALSE;
TCHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH];
if (EVAL(SUCCEEDED(FtpPidl_GetServer(pidl, szServer, ARRAYSIZE(szServer)))))
fIsDNSServer = !IsIPAddressStr(szServer);
return fIsDNSServer;
}
HRESULT FtpPidl_GetUserName(LPCITEMIDLIST pidl, LPTSTR pszUserName, DWORD cchSize)
{
ASSERT(FtpID_IsServerItemID(pidl));
return FtpServerID_GetUserName(pidl, pszUserName, cchSize);
}
HRESULT FtpPidl_GetPassword(LPCITEMIDLIST pidl, LPTSTR pszPassword, DWORD cchSize, BOOL fIncludingHiddenPassword)
{
ASSERT(FtpID_IsServerItemID(pidl));
return FtpServerID_GetPassword(pidl, pszPassword, cchSize, fIncludingHiddenPassword);
}
ULONGLONG FtpPidl_GetFileSize(LPCITEMIDLIST pidl)
{
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
ULONGLONG ullFileSize;
ullFileSize = 0;
if (!FtpID_IsServerItemID(pidlLast))
ullFileSize = FtpItemID_GetFileSize(pidlLast);
return ullFileSize;
}
HRESULT FtpPidl_SetFileSize(LPCITEMIDLIST pidl, DWORD dwSizeHigh, DWORD dwSizeLow)
{
HRESULT hr = E_INVALIDARG;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (!FtpID_IsServerItemID(pidlLast))
{
ULARGE_INTEGER uliFileSize;
uliFileSize.HighPart = dwSizeHigh;
uliFileSize.LowPart = dwSizeLow;
FtpItemID_SetFileSize(pidlLast, uliFileSize);
hr = S_OK;
}
return hr;
}
// Return value in UTC time.
FILETIME FtpPidl_GetFileTime(LPCITEMIDLIST pidl)
{
FILETIME fileTimeFTP = FtpPidl_GetFTPFileTime(pidl); // This is what servers will be.
FILETIME fileTime;
EVAL(LocalFileTimeToFileTime(&fileTimeFTP, &fileTime));
return fileTime;
}
// Return value is in Local Time Zone.
FILETIME FtpPidl_GetFTPFileTime(LPCITEMIDLIST pidl)
{
FILETIME fileTime = {0}; // This is what servers will be.
if (!FtpID_IsServerItemID(pidl))
fileTime = FtpItemID_GetFileTime(pidl);
return fileTime;
}
HRESULT FtpPidl_GetDisplayName(LPCITEMIDLIST pidl, LPWSTR pwzName, DWORD cchSize)
{
HRESULT hr = E_INVALIDARG;
if (pidl)
{
if (FtpID_IsServerItemID(pidl))
hr = FtpServerID_GetServer(pidl, pwzName, cchSize);
else
hr = FtpItemID_GetDisplayName(pidl, pwzName, cchSize);
}
return hr;
}
HRESULT FtpPidl_GetWireName(LPCITEMIDLIST pidl, LPWIRESTR pwName, DWORD cchSize)
{
HRESULT hr = E_INVALIDARG;
if (pidl)
{
if (FtpID_IsServerItemID(pidl))
{
WCHAR wzServerName[INTERNET_MAX_HOST_NAME_LENGTH];
// It's a good thing Server Names need to be in US ANSI
hr = FtpServerID_GetServer(pidl, wzServerName, ARRAYSIZE(wzServerName));
SHUnicodeToAnsi(wzServerName, pwName, cchSize);
}
else
hr = FtpItemID_GetWireName(pidl, pwName, cchSize);
}
return hr;
}
HRESULT FtpPidl_GetFragment(LPCITEMIDLIST pidl, LPTSTR pszFragment, DWORD cchSize)
{
HRESULT hr = E_INVALIDARG;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (!FtpID_IsServerItemID(pidlLast))
hr = FtpItemID_GetFragment(pidlLast, pszFragment, cchSize);
else
{
pszFragment[0] = 0;
}
return hr;
}
DWORD FtpPidl_GetAttributes(LPCITEMIDLIST pidl)
{
DWORD dwAttribs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_TEMPORARY;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (!FtpID_IsServerItemID(pidlLast))
dwAttribs = FtpItemID_GetAttributes(pidlLast);
else
dwAttribs = FILE_ATTRIBUTE_DIRECTORY;
return dwAttribs;
}
HRESULT FtpPidl_SetAttributes(LPCITEMIDLIST pidl, DWORD dwAttribs)
{
HRESULT hr = E_INVALIDARG;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (!FtpID_IsServerItemID(pidlLast))
hr = FtpItemID_SetAttributes(pidlLast, dwAttribs);
return hr;
}
// ftTimeDate In UTC
HRESULT FtpPidl_SetFileTime(LPCITEMIDLIST pidl, FILETIME ftTimeDate)
{
HRESULT hr = E_INVALIDARG;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (!FtpID_IsServerItemID(pidlLast))
{
FtpItemID_SetFileTime(pidlLast, ftTimeDate);
hr = S_OK;
}
return hr;
}
/****************************************************\
FUNCTION: FtpPidl_GetFileWireName
DESCRIPTION:
Get the file name.
\****************************************************/
LPCWIRESTR FtpPidl_GetFileWireName(LPCITEMIDLIST pidl)
{
if (EVAL(!FtpID_IsServerItemID(pidl)) &&
!FtpItemID_IsFragment(pidl))
{
return FtpItemID_GetWireNameReference(pidl);
}
return NULL;
}
/****************************************************\
FUNCTION: FtpPidl_GetLastItemDisplayName
DESCRIPTION:
This will get the last item name, even if that
last item is a fragment.
\****************************************************/
HRESULT FtpPidl_GetLastItemDisplayName(LPCITEMIDLIST pidl, LPWSTR pwzName, DWORD cchSize)
{
HRESULT hr = E_FAIL;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (EVAL(!FtpID_IsServerItemID(pidlLast)) &&
FtpItemID_GetDisplayNameReference(pidlLast))
{
hr = FtpItemID_GetDisplayName(pidlLast, pwzName, cchSize);
}
return hr;
}
/****************************************************\
FUNCTION: FtpPidl_GetLastItemWireName
DESCRIPTION:
This will get the last item name, even if that
last item is a fragment.
\****************************************************/
LPCWIRESTR FtpPidl_GetLastItemWireName(LPCITEMIDLIST pidl)
{
LPCWIRESTR pszName = NULL;
if (pidl)
{
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (FtpItemID_IsFragment(pidlLast) && (pidlLast != pidl))
{
// Oops, we went to far. Step back one.
LPCITEMIDLIST pidlFrag = pidlLast;
pidlLast = pidl; // Start back at the beginning.
while (!FtpItemID_IsEqual(_ILNext(pidlLast), pidlFrag))
{
if (ILIsEmpty(pidlLast))
return NULL; // Break infinite loop.
pidlLast = _ILNext(pidlLast);
}
}
pszName = FtpPidl_GetFileWireName(pidlLast);
}
return pszName;
}
/****************************************************\
FUNCTION: FtpPidl_GetLastFileDisplayName
DESCRIPTION:
This will get the last item name, even if that
last item is a fragment.
\****************************************************/
HRESULT FtpPidl_GetLastFileDisplayName(LPCITEMIDLIST pidl, LPWSTR pwzName, DWORD cchSize)
{
HRESULT hr = E_INVALIDARG;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
if (FtpItemID_IsFragment(pidlLast) && (pidlLast != pidl))
{
// Oops, we went to far. Step back one.
LPCITEMIDLIST pidlFrag = pidlLast;
pidlLast = pidl; // Start back at the beginning.
while (!FtpItemID_IsEqual(_ILNext(pidlLast), pidlFrag))
{
if (ILIsEmpty(pidlLast))
return NULL; // Break infinite loop.
pidlLast = _ILNext(pidlLast);
}
}
if (EVAL(!FtpID_IsServerItemID(pidlLast)))
{
LPCUWSTR pszUnalignedName = FtpItemID_GetDisplayNameReference(pidlLast);
if (pszUnalignedName)
{
ualstrcpynW(pwzName, pszUnalignedName, cchSize);
hr = S_OK;
}
}
return hr;
}
/****************************************************\
FUNCTION: FtpPidl_InsertVirtualRoot
DESCRIPTION:
This function will insert the virtual root path
(pidlVirtualRoot) into pidlFtpPath.
PARAMETERS:
pidlVirtualRoot: Does not have a ServerID
pidlFtpPath: Can have a ServerID
*ppidl: Will be pidlVirtualRoot with item ItemIDs from
pidlFtpPath behind it. (No ServerID)
\****************************************************/
HRESULT FtpPidl_InsertVirtualRoot(LPCITEMIDLIST pidlVirtualRoot, LPCITEMIDLIST pidlFtpPath, LPITEMIDLIST * ppidl)
{
HRESULT hr = E_OUTOFMEMORY;
if (FtpID_IsServerItemID(pidlFtpPath))
pidlFtpPath = _ILNext(pidlFtpPath);
*ppidl = ILCombine(pidlVirtualRoot, pidlFtpPath);
if (*ppidl)
hr = S_OK;
return hr;
}
DWORD FtpPidl_GetVersion(LPCITEMIDLIST pidl)
{
DWORD dwVersion = 0;
if (EVAL(FtpID_IsServerItemID(pidl)))
{
LPFTPSERVERIDLIST pFtpServerItemID = FtpServerID_GetDataSafeThunk(pidl);
if (pFtpServerItemID)
{
dwVersion = pFtpServerItemID->dwVersion;
FtpServerID_FreeThunk(pFtpServerItemID);
}
}
return dwVersion;
}
BOOL FtpPidl_IsValid(LPCITEMIDLIST pidl)
{
if (!EVAL(IsValidPIDL(pidl)))
return FALSE;
return TRUE;
}
BOOL FtpPidl_IsValidFull(LPCITEMIDLIST pidl)
{
if (!EVAL(FtpID_IsServerItemID(pidl)))
return FALSE;
if (!EVAL(FtpPidl_IsValid(pidl)))
return FALSE;
// We consider anything older than PIDL_VERSION_NUMBER_UPGRADE
// to be invalid.
return ((PIDL_VERSION_NUMBER_UPGRADE - 1) < FtpPidl_GetVersion(pidl));
}
BOOL FtpPidl_IsValidRelative(LPCITEMIDLIST pidl)
{
if (!EVAL(!FtpID_IsServerItemID(pidl)))
return FALSE; // This is a server item id which is not relative.
return FtpPidl_IsValid(pidl);
}
LPITEMIDLIST ILCloneFirstItemID(LPITEMIDLIST pidl)
{
LPITEMIDLIST pidlCopy = ILClone(pidl);
if (pidlCopy && pidlCopy->mkid.cb)
{
LPITEMIDLIST pSecondID = (LPITEMIDLIST)_ILNext(pidlCopy);
ASSERT(pSecondID);
// Remove the last one
pSecondID->mkid.cb = 0; // null-terminator
}
return pidlCopy;
}
BOOL FtpPidl_HasPath(LPCITEMIDLIST pidl)
{
BOOL fResult = TRUE;
if (!FtpPidl_IsValid(pidl) || !EVAL(FtpID_IsServerItemID(pidl)))
return FALSE;
if (!ILIsEmpty(pidl) && ILIsEmpty(_ILNext(pidl)))
fResult = FALSE;
return fResult;
}
HRESULT FtpPidl_SetFileItemType(LPITEMIDLIST pidl, BOOL fIsDir)
{
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
HRESULT hr = E_INVALIDARG;
if (EVAL(FtpPidl_IsValid(pidl)) && EVAL(!FtpID_IsServerItemID(pidlLast)))
{
DWORD dwIDType = FtpItemID_GetTypeID(pidlLast);
ClearFlag(dwIDType, (IDTYPE_FILEORDIR | IDTYPE_DIR | IDTYPE_FILE));
SetFlag(dwIDType, (fIsDir ? IDTYPE_DIR : IDTYPE_FILE));
FtpItemID_SetTypeID((LPITEMIDLIST) pidlLast, dwIDType);
hr = S_OK;
}
return hr;
}
BOOL IsFtpPidlQuestionable(LPCITEMIDLIST pidl)
{
BOOL fIsQuestionable = FALSE;
LPCITEMIDLIST pidlLast = ILGetLastID(pidl);
// Is it a Server Pidl? (All Server pidls aren't questionable)
if (FtpPidl_IsValid(pidl) && !FtpID_IsServerItemID(pidlLast))
{
// No, so it might be questionable.
// Does it have "File or Dir" bit set?
if (IsFlagSet(FtpItemID_GetTypeID(pidlLast), IDTYPE_FILEORDIR))
fIsQuestionable = TRUE;
}
return fIsQuestionable;
}
LPITEMIDLIST FtpCloneServerID(LPCITEMIDLIST pidl)
{
LPITEMIDLIST pidlResult = NULL;
if (EVAL(FtpID_IsServerItemID(pidl)))
{
pidlResult = ILClone(pidl);
while (!ILIsEmpty(_ILNext(pidlResult)))
ILRemoveLastID(pidlResult);
}
return pidlResult;
}
/*****************************************************************************\
FUNCTION: FtpPidl_ReplacePath
DESCRIPTION:
This function will fill in *ppidlOut with a pidl that contains the
FtpServerID from pidlServer and the FtpItemIDs from pidlFtpPath.
\*****************************************************************************/
HRESULT FtpPidl_ReplacePath(LPCITEMIDLIST pidlServer, LPCITEMIDLIST pidlFtpPath, LPITEMIDLIST * ppidlOut)
{
HRESULT hr = E_INVALIDARG;
*ppidlOut = NULL;
if (EVAL(FtpID_IsServerItemID(pidlServer)))
{
LPITEMIDLIST pidlServerOnly = FtpCloneServerID(pidlServer);
if (pidlServerOnly)
{
if (FtpID_IsServerItemID(pidlFtpPath))
pidlFtpPath = _ILNext(pidlFtpPath);
*ppidlOut = ILCombine(pidlServerOnly, pidlFtpPath);
if (*ppidlOut)
hr = S_OK;
else
hr = E_FAIL;
ILFree(pidlServerOnly);
}
}
ASSERT_POINTER_MATCHES_HRESULT(*ppidlOut, hr);
return hr;
}
BOOL FtpItemID_IsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
// Don't repeat recursively.
return (S_OK == _FtpItemID_CompareOneID(COL_NAME, pidl1, pidl2, FALSE));
}
BOOL FtpPidl_IsPathEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
// This works recursively.
return ((0 == FtpItemID_CompareIDsInt(COL_NAME, pidl1, pidl2, FCMP_NORMAL)) ? TRUE : FALSE);
}
// is pidlChild a child of pidlParent
BOOL FtpItemID_IsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild)
{
BOOL fIsChild = TRUE;
if (pidlChild)
{
LPITEMIDLIST pidl1Iterate = (LPITEMIDLIST) pidlParent;
LPITEMIDLIST pidl2Iterate = (LPITEMIDLIST) pidlChild;
ASSERT(!FtpID_IsServerItemID(pidl1Iterate) && pidlParent && !FtpID_IsServerItemID(pidl2Iterate));
// Let's see if pidl starts off with
while (fIsChild && pidl1Iterate && !ILIsEmpty(pidl1Iterate) &&
pidl2Iterate && !ILIsEmpty(pidl2Iterate) &&
FtpItemID_IsEqual(pidl1Iterate, pidl2Iterate))
{
fIsChild = FtpItemID_IsEqual(pidl1Iterate, pidl2Iterate);
pidl1Iterate = _ILNext(pidl1Iterate);
pidl2Iterate = _ILNext(pidl2Iterate);
}
if (!(ILIsEmpty(pidl1Iterate) && !ILIsEmpty(pidl2Iterate)))
fIsChild = FALSE;
}
else
fIsChild = FALSE;
return fIsChild;
}
// is pidlChild a child of pidlParent, so all the itemIDs in
// pidlParent are in pidlChild, but pidlChild has more.
// This will return a pointer to those itemIDs.
LPCITEMIDLIST FtpItemID_FindDifference(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild)
{
LPCITEMIDLIST pidlDiff = (LPITEMIDLIST) pidlChild;
if (pidlChild)
{
LPITEMIDLIST pidl1Iterate = (LPITEMIDLIST) pidlParent;
if (FtpID_IsServerItemID(pidl1Iterate))
pidl1Iterate = _ILNext(pidl1Iterate);
if (FtpID_IsServerItemID(pidlDiff))
pidlDiff = _ILNext(pidlDiff);
// Let's see if pidl starts off with
while (pidl1Iterate && !ILIsEmpty(pidl1Iterate) &&
pidlDiff && !ILIsEmpty(pidlDiff) &&
FtpItemID_IsEqual(pidl1Iterate, pidlDiff))
{
pidlDiff = _ILNext(pidlDiff);
pidl1Iterate = _ILNext(pidl1Iterate);
}
}
return pidlDiff;
}
Reference in a new issue Copy permalink