mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2062 lines
48 KiB
2062 lines
48 KiB
/*
|
|
* urlprop.cpp - Implementation for URLProp class.
|
|
*/
|
|
|
|
|
|
#include "priv.h"
|
|
#include "ishcut.h"
|
|
|
|
STDAPI_(LPITEMIDLIST) IEILCreate(UINT cbSize);
|
|
|
|
#define MAX_BUF_INT (1 + 10 + 1) // -2147483647
|
|
|
|
const TCHAR c_szIntshcut[] = ISHCUT_INISTRING_SECTION;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
BOOL IsValidPCURLProp(PCURLProp pcurlprop)
|
|
{
|
|
return (IS_VALID_READ_PTR(pcurlprop, CURLProp) &&
|
|
(NULL == pcurlprop->m_hstg ||
|
|
IS_VALID_HANDLE(pcurlprop->m_hstg, PROPSTG)));
|
|
}
|
|
|
|
|
|
BOOL IsValidPCIntshcutProp(PCIntshcutProp pcisprop)
|
|
{
|
|
return (IS_VALID_READ_PTR(pcisprop, CIntshcutProp) &&
|
|
IS_VALID_STRUCT_PTR(pcisprop, CURLProp));
|
|
}
|
|
|
|
BOOL IsValidPCIntsiteProp(PCIntsiteProp pcisprop)
|
|
{
|
|
return (IS_VALID_READ_PTR(pcisprop, CIntsiteProp) &&
|
|
IS_VALID_STRUCT_PTR(pcisprop, CURLProp));
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|
|
BOOL AnyMeatW(LPCWSTR pcsz)
|
|
{
|
|
ASSERT(! pcsz || IS_VALID_STRING_PTRW(pcsz, -1));
|
|
|
|
return(pcsz ? StrSpnW(pcsz, L" \t") < lstrlenW(pcsz) : FALSE);
|
|
}
|
|
|
|
|
|
BOOL AnyMeatA(LPCSTR pcsz)
|
|
{
|
|
ASSERT(! pcsz || IS_VALID_STRING_PTRA(pcsz, -1));
|
|
|
|
return(pcsz ? StrSpnA(pcsz, " \t") < lstrlenA(pcsz) : FALSE);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read an arbitrary named string from the .ini file.
|
|
|
|
Returns: S_OK if the name exists
|
|
S_FALSE if it doesn't
|
|
|
|
E_OUTOFMEMORY
|
|
*/
|
|
HRESULT ReadStringFromFile(IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
OUT LPWSTR * ppwsz,
|
|
IN CHAR * pszBuf)
|
|
{
|
|
HRESULT hres = E_OUTOFMEMORY;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppwsz, PWSTR));
|
|
|
|
*ppwsz = (LPWSTR)LocalAlloc(LPTR, SIZEOF(WCHAR) * INTERNET_MAX_URL_LENGTH);
|
|
if (*ppwsz)
|
|
{
|
|
DWORD cch;
|
|
|
|
hres = S_OK;
|
|
|
|
cch = SHGetIniString(pszSectionName, pszName,
|
|
*ppwsz, INTERNET_MAX_URL_LENGTH, pszFile);
|
|
if (0 == cch)
|
|
{
|
|
hres = S_FALSE;
|
|
LocalFree(*ppwsz);
|
|
*ppwsz = NULL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read an arbitrary named string from the .ini file.
|
|
Return a BSTR
|
|
|
|
Returns: S_OK if the name exists
|
|
S_FALSE if it doesn't
|
|
|
|
E_OUTOFMEMORY
|
|
*/
|
|
HRESULT ReadBStrFromFile(IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
OUT BSTR * pBStr)
|
|
{
|
|
CHAR szTempBuf[INTERNET_MAX_URL_LENGTH];
|
|
WCHAR *pwsz;
|
|
HRESULT hres = E_OUTOFMEMORY;
|
|
*pBStr = NULL;
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
ASSERT(IS_VALID_WRITE_PTR(pBStr, PWSTR));
|
|
|
|
// (Pass in an empty string so we can determine from the return
|
|
// value whether there is any text associated with this name.)
|
|
hres = ReadStringFromFile(pszFile, pszSectionName, pszName, &pwsz, szTempBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
*pBStr = SysAllocString(pwsz);
|
|
LocalFree(pwsz);
|
|
pwsz = NULL;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: read an arbitrary named unsigend int from the .ini file. note in order to implement
|
|
ReadSignedFromFile one'll need to use ReadStringFromFile and then StrToIntEx. this is
|
|
because GetPrivateProfileInt can't return a negative.
|
|
|
|
Returns: S_OK if the name exists
|
|
S_FALSE if it doesn't
|
|
|
|
E_OUTOFMEMORY
|
|
*/
|
|
HRESULT
|
|
ReadUnsignedFromFile(
|
|
IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
IN LPDWORD pdwVal)
|
|
{
|
|
HRESULT hr;
|
|
int iValue;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszSectionName, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
|
|
if (NULL == pdwVal)
|
|
return E_INVALIDARG;
|
|
*pdwVal = 0;
|
|
|
|
hr = S_OK;
|
|
iValue = GetPrivateProfileInt(pszSectionName, pszName, 1, pszFile);
|
|
if (1 == iValue) {
|
|
iValue = GetPrivateProfileInt(pszSectionName, pszName, 2, pszFile);
|
|
hr = (2 != iValue) ? S_OK : S_FALSE;
|
|
ASSERT(S_FALSE == hr || 1 == iValue);
|
|
}
|
|
|
|
if (S_OK == hr)
|
|
*pdwVal = (DWORD)iValue;
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write number to URL (ini) file
|
|
|
|
*/
|
|
HRESULT WriteSignedToFile(IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
IN int nVal)
|
|
{
|
|
HRESULT hres;
|
|
TCHAR szVal[MAX_BUF_INT];
|
|
int cch;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
|
|
cch = wnsprintf(szVal, ARRAYSIZE(szVal), TEXT("%d"), nVal);
|
|
ASSERT(cch > 0);
|
|
ASSERT(cch < SIZECHARS(szVal));
|
|
ASSERT(cch == lstrlen(szVal));
|
|
|
|
hres = WritePrivateProfileString(pszSectionName, pszName, szVal,
|
|
pszFile) ? S_OK : E_FAIL;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write number to URL (ini) file
|
|
|
|
*/
|
|
HRESULT WriteUnsignedToFile(IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
IN DWORD nVal)
|
|
{
|
|
HRESULT hres;
|
|
TCHAR szVal[MAX_BUF_INT];
|
|
int cch;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
|
|
cch = wnsprintf(szVal, ARRAYSIZE(szVal), TEXT("%u"), nVal);
|
|
ASSERT(cch > 0);
|
|
ASSERT(cch < SIZECHARS(szVal));
|
|
ASSERT(cch == lstrlen(szVal));
|
|
|
|
hres = WritePrivateProfileString(pszSectionName, pszName, szVal,
|
|
pszFile) ? S_OK : E_FAIL;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write binary data to URL (ini) file
|
|
|
|
*/
|
|
HRESULT WriteBinaryToFile(IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
IN LPVOID pvData,
|
|
IN DWORD cbSize)
|
|
{
|
|
HRESULT hres;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
|
|
hres = (WritePrivateProfileStruct(pszSectionName, pszName, pvData, cbSize, pszFile))
|
|
? S_OK : E_FAIL;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read the hotkey from the URL (ini) file
|
|
|
|
*/
|
|
HRESULT ReadBinaryFromFile(IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
IN LPVOID pvData,
|
|
IN DWORD cbData)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
|
|
memset(pvData, 0, cbData);
|
|
|
|
if (GetPrivateProfileStruct(pszSectionName, pszName, pvData, cbData, pszFile))
|
|
hres = S_OK;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Real the URL from the URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
ReadURLFromFile(
|
|
IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
OUT LPTSTR * ppsz)
|
|
{
|
|
HRESULT hres = E_OUTOFMEMORY;
|
|
|
|
*ppsz = (LPTSTR)LocalAlloc(LPTR, SIZEOF(TCHAR) * INTERNET_MAX_URL_LENGTH);
|
|
if (*ppsz)
|
|
{
|
|
DWORD cch;
|
|
|
|
cch = SHGetIniString(pszSectionName, ISHCUT_INISTRING_URL,
|
|
*ppsz, INTERNET_MAX_URL_LENGTH, pszFile);
|
|
if (0 != cch)
|
|
{
|
|
PathRemoveBlanks(*ppsz);
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
LocalFree(*ppsz);
|
|
*ppsz = NULL;
|
|
hres = S_FALSE;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read the icon location from the URL (ini) file
|
|
|
|
Returns: S_OK value was obtained from file
|
|
S_FALSE value wasn't in file
|
|
|
|
E_OUTOFMEMORY
|
|
*/
|
|
HRESULT
|
|
ReadIconLocation(
|
|
IN LPCTSTR pszFile,
|
|
OUT LPWSTR * ppwsz,
|
|
OUT int * pniIcon,
|
|
IN CHAR * pszBuf)
|
|
{
|
|
HRESULT hres = E_OUTOFMEMORY;
|
|
DWORD cch;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppwsz, PTSTR));
|
|
ASSERT(IS_VALID_WRITE_PTR(pniIcon, INT));
|
|
|
|
*ppwsz = NULL;
|
|
*pniIcon = 0;
|
|
|
|
*ppwsz = (LPWSTR)LocalAlloc(LPTR, SIZEOF(WCHAR) * MAX_PATH);
|
|
if (*ppwsz)
|
|
{
|
|
hres = S_FALSE; // assume no value exists in the file
|
|
|
|
cch = SHGetIniString(c_szIntshcut,
|
|
ISHCUT_INISTRING_ICONFILE, *ppwsz,
|
|
MAX_PATH, pszFile);
|
|
|
|
if (0 != cch)
|
|
{
|
|
TCHAR szIndex[MAX_BUF_INT];
|
|
// The icon index is all ASCII so don't need SHGetIniString
|
|
cch = GetPrivateProfileString(c_szIntshcut,
|
|
ISHCUT_INISTRING_ICONINDEX, c_szNULL,
|
|
szIndex, SIZECHARS(szIndex),
|
|
pszFile);
|
|
if (0 != cch)
|
|
{
|
|
if (StrToIntEx(szIndex, 0, pniIcon))
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
if (S_OK != hres)
|
|
{
|
|
LocalFree(*ppwsz);
|
|
*ppwsz = NULL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write icon location to URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
WriteIconFile(
|
|
IN LPCTSTR pszFile,
|
|
IN LPCWSTR pszIconFile)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(! pszIconFile ||
|
|
IS_VALID_STRING_PTRW(pszIconFile, -1));
|
|
|
|
if (*pszFile)
|
|
{
|
|
if (AnyMeatW(pszIconFile))
|
|
{
|
|
hres = SHSetIniString(c_szIntshcut, ISHCUT_INISTRING_ICONFILE, pszIconFile,
|
|
pszFile) ? S_OK : E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
// NOTE: since this function removes both the file and the index
|
|
// values, then this function must be called *after* any call
|
|
// to WriteIconIndex. One way to do this is make sure
|
|
// PID_IS_ICONINDEX < PID_IS_ICONFILE, since the index will
|
|
// be enumerated first.
|
|
|
|
hres = (SHDeleteIniString(c_szIntshcut, ISHCUT_INISTRING_ICONFILE,
|
|
pszFile) &&
|
|
DeletePrivateProfileString(c_szIntshcut, ISHCUT_INISTRING_ICONINDEX,
|
|
pszFile))
|
|
? S_OK : E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write icon index to URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
WriteIconIndex(
|
|
IN LPCTSTR pszFile,
|
|
IN int niIcon)
|
|
{
|
|
HRESULT hres;
|
|
|
|
if (*pszFile)
|
|
hres = WriteSignedToFile(pszFile, c_szIntshcut, ISHCUT_INISTRING_ICONINDEX, niIcon);
|
|
else
|
|
hres = S_FALSE;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read the hotkey from the URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
ReadHotkey(
|
|
IN LPCTSTR pszFile,
|
|
IN WORD * pwHotkey)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
TCHAR szHotkey[MAX_BUF_INT];
|
|
DWORD cch;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_WRITE_PTR(pwHotkey, WORD));
|
|
|
|
*pwHotkey = 0;
|
|
|
|
cch = GetPrivateProfileString(c_szIntshcut,
|
|
TEXT("Hotkey"), c_szNULL,
|
|
szHotkey, SIZECHARS(szHotkey),
|
|
pszFile);
|
|
if (0 != cch)
|
|
{
|
|
int nVal;
|
|
|
|
if (StrToIntEx(szHotkey, 0, &nVal))
|
|
{
|
|
*pwHotkey = nVal;
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write hotkey to URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
WriteHotkey(
|
|
IN LPCTSTR pszFile,
|
|
IN WORD wHotkey)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
|
|
if (*pszFile)
|
|
{
|
|
if (wHotkey)
|
|
{
|
|
hres = WriteUnsignedToFile(pszFile, c_szIntshcut, TEXT("Hotkey"), wHotkey);
|
|
}
|
|
else
|
|
{
|
|
hres = DeletePrivateProfileString(c_szIntshcut, TEXT("Hotkey"), pszFile)
|
|
? S_OK
|
|
: E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read the working directory from the URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
ReadWorkingDirectory(
|
|
IN LPCTSTR pszFile,
|
|
OUT LPWSTR * ppwsz)
|
|
{
|
|
HRESULT hres = E_OUTOFMEMORY;
|
|
TCHAR szPath[MAX_PATH];
|
|
DWORD cch;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_WRITE_PTR(ppwsz, PWSTR));
|
|
|
|
*ppwsz = NULL;
|
|
|
|
*ppwsz = (LPWSTR)LocalAlloc(LPTR, SIZEOF(WCHAR) * MAX_PATH);
|
|
if (*ppwsz)
|
|
{
|
|
hres = S_FALSE;
|
|
|
|
cch = SHGetIniString(c_szIntshcut,
|
|
ISHCUT_INISTRING_WORKINGDIR,
|
|
szPath, SIZECHARS(szPath), pszFile);
|
|
if (0 != cch)
|
|
{
|
|
TCHAR szFullPath[MAX_PATH];
|
|
PTSTR pszFileName;
|
|
|
|
if (0 < GetFullPathName(szPath, SIZECHARS(szFullPath), szFullPath,
|
|
&pszFileName))
|
|
{
|
|
SHTCharToUnicode(szFullPath, *ppwsz, MAX_PATH);
|
|
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
if (S_OK != hres)
|
|
{
|
|
LocalFree(*ppwsz);
|
|
*ppwsz = NULL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write the working directory to the URL (ini) file.
|
|
|
|
*/
|
|
HRESULT
|
|
WriteGenericString(
|
|
IN LPCTSTR pszFile,
|
|
IN LPCTSTR pszSectionName,
|
|
IN LPCTSTR pszName,
|
|
IN LPCWSTR pwsz) OPTIONAL
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_STRING_PTR(pszName, -1));
|
|
ASSERT(! pwsz || IS_VALID_STRING_PTRW(pwsz, -1));
|
|
|
|
if (*pszFile)
|
|
{
|
|
if (AnyMeatW(pwsz))
|
|
{
|
|
hres = (SHSetIniString(pszSectionName, pszName, pwsz,
|
|
pszFile)) ? S_OK : E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
hres = (SHDeleteIniString(pszSectionName, pszName, pszFile))
|
|
? S_OK : E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read the show-command flag from the URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
ReadShowCmd(
|
|
IN LPCTSTR pszFile,
|
|
OUT PINT pnShowCmd)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
TCHAR szT[MAX_BUF_INT];
|
|
DWORD cch;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
ASSERT(IS_VALID_WRITE_PTR(pnShowCmd, INT));
|
|
|
|
*pnShowCmd = SW_NORMAL;
|
|
|
|
cch = GetPrivateProfileString(c_szIntshcut,
|
|
TEXT("ShowCommand"), c_szNULL, szT,
|
|
SIZECHARS(szT), pszFile);
|
|
if (0 != cch)
|
|
{
|
|
if (StrToIntEx(szT, 0, pnShowCmd))
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write showcmd to URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
WriteShowCmd(
|
|
IN LPCTSTR pszFile,
|
|
IN int nShowCmd)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
|
|
if (*pszFile)
|
|
{
|
|
if (SW_NORMAL != nShowCmd)
|
|
{
|
|
hres = WriteSignedToFile(pszFile, c_szIntshcut, TEXT("ShowCommand"), nShowCmd);
|
|
}
|
|
else
|
|
{
|
|
hres = DeletePrivateProfileString(c_szIntshcut, TEXT("ShowCommand"), pszFile)
|
|
? S_OK
|
|
: E_FAIL;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Read the IDList from the URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
ReadIDList(
|
|
IN LPCTSTR pszFile,
|
|
OUT LPITEMIDLIST *ppidl)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
ULONG cb;
|
|
|
|
ASSERT(ppidl);
|
|
|
|
// Delete the old one if any.
|
|
if (*ppidl)
|
|
{
|
|
ILFree(*ppidl);
|
|
*ppidl = NULL;
|
|
}
|
|
|
|
// Read the size of the IDLIST
|
|
cb = GetPrivateProfileInt(c_szIntshcut, TEXT("ILSize"), 0, pszFile);
|
|
if (cb)
|
|
{
|
|
// Create a IDLIST
|
|
LPITEMIDLIST pidl = IEILCreate(cb);
|
|
if (pidl)
|
|
{
|
|
// Read its contents
|
|
if (GetPrivateProfileStruct(c_szIntshcut, TEXT("IDList"), (LPVOID)pidl, cb, pszFile))
|
|
{
|
|
*ppidl = pidl;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
ILFree(pidl);
|
|
hres = E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT
|
|
WriteStream(
|
|
IN LPCTSTR pszFile,
|
|
IN IStream *pStream,
|
|
IN LPCTSTR pszStreamName,
|
|
IN LPCTSTR pszSizeName)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
ULARGE_INTEGER li = {0};
|
|
|
|
if(pStream)
|
|
IStream_Size(pStream, &li);
|
|
|
|
if (li.LowPart)
|
|
{
|
|
ASSERT(!li.HighPart);
|
|
LPVOID pv = LocalAlloc(LPTR, li.LowPart);
|
|
|
|
if (pv && SUCCEEDED(hr = IStream_Read(pStream, pv, li.LowPart)))
|
|
{
|
|
// we have loaded the data properly, time to write it out
|
|
|
|
if (SUCCEEDED(hr = WriteUnsignedToFile(pszFile, c_szIntshcut, pszSizeName, li.LowPart)))
|
|
hr = WriteBinaryToFile(pszFile, c_szIntshcut, pszStreamName, pv, li.LowPart);
|
|
}
|
|
|
|
if (pv)
|
|
{
|
|
LocalFree(pv);
|
|
pv = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// delete the keys if
|
|
// 1. pStream is NULL, or
|
|
// 2. pStream in empty (cbPidl == 0).
|
|
if (DeletePrivateProfileString(c_szIntshcut, pszSizeName, pszFile) &&
|
|
DeletePrivateProfileString(c_szIntshcut, pszStreamName, pszFile))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Write IDList to URL (ini) file
|
|
|
|
*/
|
|
HRESULT
|
|
WriteIDList(
|
|
IN LPCTSTR pszFile,
|
|
IN IStream *pStream)
|
|
{
|
|
return WriteStream(pszFile, pStream, TEXT("IDList"), TEXT("ILSize"));
|
|
}
|
|
|
|
|
|
|
|
|
|
/********************************** Methods **********************************/
|
|
|
|
|
|
|
|
//==========================================================================================
|
|
// URLProp class implementation
|
|
//==========================================================================================
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Dump the properties in this object
|
|
|
|
*/
|
|
STDMETHODIMP_(void) URLProp::Dump(void)
|
|
{
|
|
if (IsFlagSet(g_dwDumpFlags, DF_URLPROP))
|
|
{
|
|
PropStg_Dump(m_hstg, 0);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Constructor for URLProp
|
|
|
|
*/
|
|
URLProp::URLProp(void) : m_cRef(1)
|
|
{
|
|
// Don't validate this until after construction.
|
|
|
|
m_hstg = NULL;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CURLProp));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Destructor for URLProp
|
|
|
|
*/
|
|
URLProp::~URLProp(void)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CURLProp));
|
|
|
|
if (m_hstg)
|
|
{
|
|
PropStg_Destroy(m_hstg);
|
|
m_hstg = NULL;
|
|
}
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CURLProp));
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) URLProp::AddRef()
|
|
{
|
|
return ++m_cRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) URLProp::Release()
|
|
{
|
|
m_cRef--;
|
|
if (m_cRef > 0)
|
|
return m_cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IUnknown::QueryInterface method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP URLProp::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
if (IsEqualIID(riid, IID_IUnknown) ||
|
|
IsEqualIID(riid, IID_IPropertyStorage))
|
|
{
|
|
*ppvObj = SAFECAST(this, IPropertyStorage *);
|
|
}
|
|
else
|
|
{
|
|
*ppvObj = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Initialize the object
|
|
|
|
Returns: S_OK
|
|
E_OUTOFMEMORY
|
|
*/
|
|
STDMETHODIMP URLProp::Init(void)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
// Don't stomp on ourselves if this has already been initialized
|
|
if (NULL == m_hstg)
|
|
{
|
|
hres = PropStg_Create(&m_hstg, PSTGF_DEFAULT);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that retrieves the string property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::GetProp(
|
|
IN PROPID pid,
|
|
IN LPTSTR pszBuf,
|
|
IN int cchBuf)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
ASSERT(pszBuf);
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
*pszBuf = TEXT('\0');
|
|
|
|
hres = ReadMultiple(1, &propspec, &propvar);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (VT_LPWSTR == propvar.vt)
|
|
{
|
|
SHUnicodeToTChar(propvar.pwszVal, pszBuf, cchBuf);
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
if (VT_EMPTY != propvar.vt && VT_ILLEGAL != propvar.vt)
|
|
TraceMsg(TF_WARNING, "URLProp::GetProp: expected propid %#lx to be VT_LPWSTR, but is %s", pid, Dbg_GetVTName(propvar.vt));
|
|
hres = S_FALSE;
|
|
}
|
|
|
|
PropVariantClear(&propvar);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that retrieves the word property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::GetProp(
|
|
IN PROPID pid,
|
|
IN int * piVal)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
ASSERT(piVal);
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
*piVal = 0;
|
|
|
|
hres = ReadMultiple(1, &propspec, &propvar);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (VT_I4 == propvar.vt)
|
|
{
|
|
*piVal = propvar.lVal;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
if (VT_EMPTY != propvar.vt && VT_ILLEGAL != propvar.vt)
|
|
TraceMsg(TF_WARNING, "URLProp::GetProp: expected propid %#lx to be VT_I4, but is %s", pid, Dbg_GetVTName(propvar.vt));
|
|
hres = S_FALSE;
|
|
}
|
|
|
|
PropVariantClear(&propvar);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that retrieves the word property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::GetProp(
|
|
IN PROPID pid,
|
|
IN LPDWORD pdwVal)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
ASSERT(pdwVal);
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
*pdwVal = 0;
|
|
|
|
hres = ReadMultiple(1, &propspec, &propvar);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (VT_UI4 == propvar.vt)
|
|
{
|
|
*pdwVal = propvar.ulVal;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
if (VT_EMPTY != propvar.vt && VT_ILLEGAL != propvar.vt)
|
|
TraceMsg(TF_WARNING, "URLProp::GetProp: expected propid %#lx to be VT_UI4, but is %s", pid, Dbg_GetVTName(propvar.vt));
|
|
hres = S_FALSE;
|
|
}
|
|
|
|
PropVariantClear(&propvar);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that retrieves the word property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::GetProp(
|
|
IN PROPID pid,
|
|
IN WORD * pwVal)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
ASSERT(pwVal);
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
*pwVal = 0;
|
|
|
|
hres = ReadMultiple(1, &propspec, &propvar);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (VT_UI2 == propvar.vt)
|
|
{
|
|
*pwVal = propvar.uiVal;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
if (VT_EMPTY != propvar.vt && VT_ILLEGAL != propvar.vt)
|
|
TraceMsg(TF_WARNING, "URLProp::GetProp: expected propid %#lx to be VT_UI2, but is %s", pid, Dbg_GetVTName(propvar.vt));
|
|
hres = S_FALSE;
|
|
}
|
|
|
|
PropVariantClear(&propvar);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that retrieves the IStream property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::GetProp(
|
|
IN PROPID pid,
|
|
IN IStream **ppStream)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
ASSERT(ppStream);
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
*ppStream = 0;
|
|
|
|
hres = ReadMultiple(1, &propspec, &propvar);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (VT_STREAM == propvar.vt)
|
|
{
|
|
*ppStream = propvar.pStream;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
if (VT_EMPTY != propvar.vt && VT_ILLEGAL != propvar.vt && propvar.lVal != 0)
|
|
TraceMsg(TF_WARNING, "URLProp::GetProp: expected propid %#lx to be VT_STREAM, but is %s", pid, Dbg_GetVTName(propvar.vt));
|
|
hres = S_FALSE;
|
|
}
|
|
|
|
// Do not PropVariantClear(&propvar), because it will call pStream->Release().
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the string property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetProp(
|
|
IN PROPID pid,
|
|
IN LPCTSTR psz) OPTIONAL
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
// WARNING:: this function gets called as part of ShellExecute which can be
|
|
// called by 16 bit apps so don't put mondo strings on stack...
|
|
WCHAR *pwsz = NULL;
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
if (psz && *psz)
|
|
{
|
|
SHStrDup(psz, &pwsz);
|
|
propvar.vt = VT_LPWSTR;
|
|
propvar.pwszVal = pwsz;
|
|
}
|
|
else
|
|
propvar.vt = VT_EMPTY;
|
|
|
|
hres = WriteMultiple(1, &propspec, &propvar, 0);
|
|
|
|
if (pwsz)
|
|
CoTaskMemFree(pwsz);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the int property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetProp(
|
|
IN PROPID pid,
|
|
IN int iVal)
|
|
{
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
propvar.vt = VT_I4;
|
|
propvar.lVal = iVal;
|
|
|
|
return WriteMultiple(1, &propspec, &propvar, 0);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the dword property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetProp(
|
|
IN PROPID pid,
|
|
IN DWORD dwVal)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
propvar.vt = VT_UI4;
|
|
propvar.ulVal = dwVal;
|
|
|
|
hres = WriteMultiple(1, &propspec, &propvar, 0);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the word property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetProp(
|
|
IN PROPID pid,
|
|
IN WORD wVal)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
propvar.vt = VT_UI2;
|
|
propvar.uiVal = wVal;
|
|
|
|
hres = WriteMultiple(1, &propspec, &propvar, 0);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the IStream* property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetProp(
|
|
IN PROPID pid,
|
|
IN IStream *pStream)
|
|
{
|
|
HRESULT hres;
|
|
PROPSPEC propspec;
|
|
PROPVARIANT propvar;
|
|
|
|
propspec.ulKind = PRSPEC_PROPID;
|
|
propspec.propid = pid;
|
|
|
|
propvar.vt = VT_STREAM;
|
|
propvar.pStream = pStream;
|
|
|
|
hres = WriteMultiple(1, &propspec, &propvar, 0);
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
STDMETHODIMP URLProp::IsDirty(void)
|
|
{
|
|
return PropStg_IsDirty(m_hstg);
|
|
}
|
|
|
|
|
|
STDMETHODIMP URLProp::ReadMultiple(IN ULONG cpspec,
|
|
IN const PROPSPEC rgpropspec[],
|
|
IN PROPVARIANT rgpropvar[])
|
|
{
|
|
HRESULT hres = PropStg_ReadMultiple(m_hstg, cpspec, rgpropspec, rgpropvar);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Set the accessed time
|
|
SYSTEMTIME st;
|
|
|
|
GetSystemTime(&st);
|
|
SystemTimeToFileTime(&st, &m_ftAccessed);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
STDMETHODIMP URLProp::WriteMultiple(IN ULONG cpspec,
|
|
IN const PROPSPEC rgpropspec[],
|
|
IN const PROPVARIANT rgpropvar[],
|
|
IN PROPID propidFirst)
|
|
{
|
|
HRESULT hres = PropStg_WriteMultiple(m_hstg, cpspec, rgpropspec,
|
|
rgpropvar, propidFirst);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Set the modified time
|
|
SYSTEMTIME st;
|
|
|
|
GetSystemTime(&st);
|
|
SystemTimeToFileTime(&st, &m_ftModified);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
STDMETHODIMP URLProp::DeleteMultiple(ULONG cpspec, const PROPSPEC rgpropspec[])
|
|
{
|
|
return PropStg_DeleteMultiple(m_hstg, cpspec, rgpropspec);
|
|
}
|
|
|
|
|
|
STDMETHODIMP URLProp::ReadPropertyNames(ULONG cpropid, const PROPID rgpropid[], LPWSTR rgpwszName[])
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP URLProp::WritePropertyNames(ULONG cpropid, const PROPID rgpropid[], const LPWSTR rgpwszName[])
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::DeletePropertyNames method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::DeletePropertyNames(
|
|
IN ULONG cpropid,
|
|
IN const PROPID rgpropid[])
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::SetClass method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetClass(
|
|
IN REFCLSID rclsid)
|
|
{
|
|
CopyMemory(&m_clsid, &rclsid, SIZEOF(m_clsid));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::Commit method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::Commit(
|
|
IN DWORD dwFlags)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::Revert method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP URLProp::Revert(void)
|
|
{
|
|
#ifdef DEBUG
|
|
Dump();
|
|
#endif
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::Enum method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP URLProp::Enum(IEnumSTATPROPSTG ** ppenum)
|
|
{
|
|
*ppenum = NULL;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::Stat method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::Stat(
|
|
IN STATPROPSETSTG * pstat)
|
|
{
|
|
HRESULT hres = STG_E_INVALIDPARAMETER;
|
|
|
|
if (IS_VALID_WRITE_PTR(pstat, STATPROPSETSTG))
|
|
{
|
|
pstat->fmtid = m_fmtid;
|
|
pstat->clsid = m_clsid;
|
|
pstat->grfFlags = m_grfFlags;
|
|
pstat->mtime = m_ftModified;
|
|
pstat->ctime = m_ftCreated;
|
|
pstat->atime = m_ftAccessed;
|
|
|
|
hres = S_OK;
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::SetTimes method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
URLProp::SetTimes(
|
|
IN const FILETIME * pftModified, OPTIONAL
|
|
IN const FILETIME * pftCreated, OPTIONAL
|
|
IN const FILETIME * pftAccessed) OPTIONAL
|
|
{
|
|
HRESULT hres;
|
|
|
|
if (pftModified && !IS_VALID_READ_PTR(pftModified, FILETIME) ||
|
|
pftCreated && !IS_VALID_READ_PTR(pftCreated, FILETIME) ||
|
|
pftAccessed && !IS_VALID_READ_PTR(pftAccessed, FILETIME))
|
|
{
|
|
hres = STG_E_INVALIDPARAMETER;
|
|
}
|
|
else
|
|
{
|
|
if (pftModified)
|
|
m_ftModified = *pftModified;
|
|
|
|
if (pftCreated)
|
|
m_ftCreated = *pftCreated;
|
|
|
|
if (pftAccessed)
|
|
m_ftAccessed = *pftAccessed;
|
|
|
|
hres = S_OK;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
|
|
STDMETHODIMP_(void) IntshcutProp::Dump(void)
|
|
{
|
|
if (IsFlagSet(g_dwDumpFlags, DF_URLPROP))
|
|
{
|
|
TraceMsg(TF_ALWAYS, " IntshcutProp obj: %s", m_szFile);
|
|
URLProp::Dump();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
IntshcutProp::IntshcutProp(void)
|
|
{
|
|
// Don't validate this until after construction.
|
|
|
|
*m_szFile = 0;
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CIntshcutProp));
|
|
}
|
|
|
|
IntshcutProp::~IntshcutProp(void)
|
|
{
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CIntshcutProp));
|
|
|
|
ASSERT(IS_VALID_STRUCT_PTR(this, CIntshcutProp));
|
|
}
|
|
|
|
|
|
// (These are not related to PID_IS_*)
|
|
#define IPROP_ICONINDEX 0
|
|
#define IPROP_ICONFILE 1
|
|
#define IPROP_HOTKEY 2
|
|
#define IPROP_WORKINGDIR 3
|
|
#define IPROP_SHOWCMD 4
|
|
#define IPROP_WHATSNEW 5
|
|
#define IPROP_AUTHOR 6
|
|
#define IPROP_DESC 7
|
|
#define IPROP_COMMENT 8
|
|
#define IPROP_URL 9 // these two must be the last
|
|
#define IPROP_SCHEME 10 // in this list. See LoadFromFile.
|
|
#define CPROP_INTSHCUT 11 // Count of properties
|
|
|
|
// (we don't write the URL or the scheme in the massive write sweep)
|
|
#define CPROP_INTSHCUT_WRITE (CPROP_INTSHCUT - 2)
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Load the basic property info like URL.
|
|
|
|
Returns:
|
|
Cond: --
|
|
*/
|
|
STDMETHODIMP IntshcutProp::LoadFromFile(LPCTSTR pszFile)
|
|
{
|
|
HRESULT hres;
|
|
LPWSTR pwszBuf;
|
|
LPTSTR pszBuf;
|
|
CHAR *pszTempBuf;
|
|
static const PROPSPEC rgpropspec[CPROP_INTSHCUT] =
|
|
{
|
|
// This must be initialized in the same order as how the
|
|
// IPROP_* values were defined.
|
|
{ PRSPEC_PROPID, PID_IS_ICONINDEX },
|
|
{ PRSPEC_PROPID, PID_IS_ICONFILE },
|
|
{ PRSPEC_PROPID, PID_IS_HOTKEY },
|
|
{ PRSPEC_PROPID, PID_IS_WORKINGDIR },
|
|
{ PRSPEC_PROPID, PID_IS_SHOWCMD },
|
|
{ PRSPEC_PROPID, PID_IS_WHATSNEW },
|
|
{ PRSPEC_PROPID, PID_IS_AUTHOR },
|
|
{ PRSPEC_PROPID, PID_IS_DESCRIPTION },
|
|
{ PRSPEC_PROPID, PID_IS_COMMENT },
|
|
{ PRSPEC_PROPID, PID_IS_URL },
|
|
{ PRSPEC_PROPID, PID_IS_SCHEME },
|
|
};
|
|
PROPVARIANT rgpropvar[CPROP_INTSHCUT] = { 0 };
|
|
|
|
ASSERT(pszFile);
|
|
|
|
// try to allocate a temporary buffer, don't put on stack as this may be called
|
|
// by 16 bit apps through the shellexecute thunk
|
|
pszTempBuf = (CHAR*)LocalAlloc(LMEM_FIXED, INTERNET_MAX_URL_LENGTH * sizeof(CHAR));
|
|
if (!pszTempBuf)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (!g_fRunningOnNT)
|
|
{
|
|
// Flush the cache first to encourage Win95 kernel to zero-out
|
|
// its buffer. Kernel GP-faults with hundreds of writes made to
|
|
// ini files.
|
|
WritePrivateProfileString(NULL, NULL, NULL, pszFile);
|
|
}
|
|
|
|
// Get the URL
|
|
hres = ReadURLFromFile(pszFile, c_szIntshcut, &pszBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
// Call this method because it does more work before
|
|
// setting the property
|
|
SetURLProp(pszBuf, (IURL_SETURL_FL_GUESS_PROTOCOL | IURL_SETURL_FL_USE_DEFAULT_PROTOCOL));
|
|
|
|
LocalFree(pszBuf);
|
|
pszBuf = NULL;
|
|
}
|
|
|
|
// Get the IDList
|
|
LPITEMIDLIST pidl = NULL;
|
|
hres = ReadIDList(pszFile, &pidl);
|
|
if (S_OK == hres)
|
|
{
|
|
// Call this method because it does more work before
|
|
// setting the property
|
|
SetIDListProp(pidl);
|
|
|
|
ILFree(pidl);
|
|
}
|
|
|
|
#ifndef UNIX
|
|
|
|
// Get icon location
|
|
int nVal;
|
|
hres = ReadIconLocation(pszFile, &pwszBuf, &nVal, pszTempBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_ICONFILE].vt = VT_LPWSTR;
|
|
rgpropvar[IPROP_ICONFILE].pwszVal = pwszBuf;
|
|
|
|
rgpropvar[IPROP_ICONINDEX].vt = VT_I4;
|
|
rgpropvar[IPROP_ICONINDEX].lVal = nVal;
|
|
}
|
|
|
|
// Get the hotkey
|
|
WORD wHotkey;
|
|
hres = ReadHotkey(pszFile, &wHotkey);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_HOTKEY].vt = VT_UI2;
|
|
rgpropvar[IPROP_HOTKEY].uiVal = wHotkey;
|
|
}
|
|
|
|
// Get the working directory
|
|
hres = ReadWorkingDirectory(pszFile, &pwszBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_WORKINGDIR].vt = VT_LPWSTR;
|
|
rgpropvar[IPROP_WORKINGDIR].pwszVal = pwszBuf;
|
|
}
|
|
|
|
// Get the showcmd flag
|
|
hres = ReadShowCmd(pszFile, &nVal);
|
|
rgpropvar[IPROP_SHOWCMD].vt = VT_I4;
|
|
if (S_OK == hres)
|
|
rgpropvar[IPROP_SHOWCMD].lVal = nVal;
|
|
else
|
|
rgpropvar[IPROP_SHOWCMD].lVal = SW_NORMAL;
|
|
|
|
|
|
// Get the What's New bulletin
|
|
hres = ReadStringFromFile(pszFile, c_szIntshcut, ISHCUT_INISTRING_WHATSNEW, &pwszBuf, pszTempBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_WHATSNEW].vt = VT_LPWSTR;
|
|
rgpropvar[IPROP_WHATSNEW].pwszVal = pwszBuf;
|
|
}
|
|
|
|
// Get the Author
|
|
hres = ReadStringFromFile(pszFile, c_szIntshcut, ISHCUT_INISTRING_AUTHOR, &pwszBuf, pszTempBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_AUTHOR].vt = VT_LPWSTR;
|
|
rgpropvar[IPROP_AUTHOR].pwszVal = pwszBuf;
|
|
}
|
|
|
|
// Get the Description
|
|
hres = ReadStringFromFile(pszFile, c_szIntshcut, ISHCUT_INISTRING_DESC, &pwszBuf, pszTempBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_DESC].vt = VT_LPWSTR;
|
|
rgpropvar[IPROP_DESC].pwszVal = pwszBuf;
|
|
}
|
|
|
|
// Get the Comment
|
|
hres = ReadStringFromFile(pszFile, c_szIntshcut, ISHCUT_INISTRING_COMMENT, &pwszBuf, pszTempBuf);
|
|
if (S_OK == hres)
|
|
{
|
|
rgpropvar[IPROP_COMMENT].vt = VT_LPWSTR;
|
|
rgpropvar[IPROP_COMMENT].pwszVal = pwszBuf;
|
|
}
|
|
|
|
#endif /* !UNIX */
|
|
|
|
// Write it all out to our in-memory storage. Note we're using
|
|
// CPROP_INTSHCUT_WRITE, which should be the size of the array minus the
|
|
// url and scheme propids, since they were written separately
|
|
// above.
|
|
hres = WriteMultiple(CPROP_INTSHCUT_WRITE, (PROPSPEC *)rgpropspec, rgpropvar, 0);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Unmark *all* these properties, since we're initializing from
|
|
// the file
|
|
PropStg_DirtyMultiple(m_hstg, ARRAYSIZE(rgpropspec), rgpropspec, FALSE);
|
|
}
|
|
|
|
// Get the times. We don't support the Accessed time for internet
|
|
// shortcuts updating this field would cause the shortcut to be
|
|
// constantly written to disk to record the Accessed time simply
|
|
// when a property is read. A huge perf hit!
|
|
|
|
ZeroMemory(&m_ftAccessed, sizeof(m_ftAccessed));
|
|
|
|
DWORD cbData = SIZEOF(m_ftModified);
|
|
ReadBinaryFromFile(pszFile, c_szIntshcut, ISHCUT_INISTRING_MODIFIED, &m_ftModified, cbData);
|
|
|
|
// Free up the buffers that we allocated
|
|
int cprops;
|
|
PROPVARIANT * ppropvar;
|
|
for (cprops = ARRAYSIZE(rgpropvar), ppropvar = rgpropvar; 0 < cprops; cprops--)
|
|
{
|
|
if (VT_LPWSTR == ppropvar->vt)
|
|
{
|
|
ASSERT(ppropvar->pwszVal);
|
|
LocalFree(ppropvar->pwszVal);
|
|
ppropvar->pwszVal = NULL;
|
|
}
|
|
ppropvar++;
|
|
}
|
|
|
|
LocalFree((HLOCAL)pszTempBuf);
|
|
pszTempBuf = NULL;
|
|
|
|
return hres;
|
|
}
|
|
|
|
STDMETHODIMP IntshcutProp::Init(void)
|
|
{
|
|
return URLProp::Init();
|
|
}
|
|
|
|
STDMETHODIMP IntshcutProp::InitFromFile(LPCTSTR pszFile)
|
|
{
|
|
// Initialize the in-memory property storage from the file
|
|
// and database
|
|
HRESULT hres = Init();
|
|
if (SUCCEEDED(hres) && pszFile)
|
|
{
|
|
StrCpyN(m_szFile, pszFile, SIZECHARS(m_szFile));
|
|
hres = LoadFromFile(m_szFile);
|
|
}
|
|
else
|
|
m_szFile[0] = 0;
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pszFile;
|
|
} COMMITISDATA;
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Commit the values for any known properties to the file
|
|
|
|
Note this callback is called only for dirty values.
|
|
|
|
Returns: S_OK if alright
|
|
S_FALSE to skip this value
|
|
error to stop
|
|
|
|
*/
|
|
STDAPI CommitISProp(
|
|
IN PROPID propid,
|
|
IN PROPVARIANT * ppropvar,
|
|
IN LPARAM lParam)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
COMMITISDATA * pcd = (COMMITISDATA *)lParam;
|
|
|
|
ASSERT(ppropvar);
|
|
ASSERT(pcd);
|
|
|
|
LPWSTR pwsz;
|
|
USHORT uiVal;
|
|
LONG lVal;
|
|
IStream *pStream;
|
|
|
|
switch (propid)
|
|
{
|
|
case PID_IS_URL:
|
|
case PID_IS_ICONFILE:
|
|
case PID_IS_WORKINGDIR:
|
|
case PID_IS_WHATSNEW:
|
|
case PID_IS_AUTHOR:
|
|
case PID_IS_DESCRIPTION:
|
|
case PID_IS_COMMENT:
|
|
if (VT_LPWSTR == ppropvar->vt)
|
|
pwsz = ppropvar->pwszVal;
|
|
else
|
|
pwsz = NULL;
|
|
|
|
switch (propid)
|
|
{
|
|
case PID_IS_URL:
|
|
hres = WriteGenericString(pcd->pszFile, c_szIntshcut, ISHCUT_INISTRING_URL, pwsz);
|
|
break;
|
|
|
|
case PID_IS_ICONFILE:
|
|
hres = WriteIconFile(pcd->pszFile, pwsz);
|
|
break;
|
|
|
|
case PID_IS_WORKINGDIR:
|
|
hres = WriteGenericString(pcd->pszFile, c_szIntshcut, ISHCUT_INISTRING_WORKINGDIR, pwsz);
|
|
break;
|
|
|
|
case PID_IS_WHATSNEW:
|
|
hres = WriteGenericString(pcd->pszFile, c_szIntshcut, ISHCUT_INISTRING_WHATSNEW, pwsz);
|
|
break;
|
|
|
|
case PID_IS_AUTHOR:
|
|
hres = WriteGenericString(pcd->pszFile, c_szIntshcut, ISHCUT_INISTRING_AUTHOR, pwsz);
|
|
break;
|
|
|
|
case PID_IS_DESCRIPTION:
|
|
hres = WriteGenericString(pcd->pszFile, c_szIntshcut, ISHCUT_INISTRING_DESC, pwsz);
|
|
break;
|
|
|
|
case PID_IS_COMMENT:
|
|
hres = WriteGenericString(pcd->pszFile, c_szIntshcut, ISHCUT_INISTRING_COMMENT, pwsz);
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0); // should never get here
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case PID_IS_ICONINDEX:
|
|
if (VT_I4 == ppropvar->vt)
|
|
hres = WriteIconIndex(pcd->pszFile, ppropvar->lVal);
|
|
break;
|
|
|
|
case PID_IS_HOTKEY:
|
|
if (VT_UI2 == ppropvar->vt)
|
|
uiVal = ppropvar->uiVal;
|
|
else
|
|
uiVal = 0;
|
|
|
|
hres = WriteHotkey(pcd->pszFile, uiVal);
|
|
break;
|
|
|
|
case PID_IS_SHOWCMD:
|
|
if (VT_I4 == ppropvar->vt)
|
|
lVal = ppropvar->lVal;
|
|
else
|
|
lVal = SW_NORMAL;
|
|
|
|
hres = WriteShowCmd(pcd->pszFile, lVal);
|
|
break;
|
|
|
|
case PID_IS_SCHEME:
|
|
// Don't write this one out
|
|
break;
|
|
|
|
case PID_IS_IDLIST:
|
|
if (VT_STREAM == ppropvar->vt)
|
|
pStream = ppropvar->pStream;
|
|
else
|
|
pStream = NULL;
|
|
|
|
hres = WriteIDList(pcd->pszFile, pStream);
|
|
break;
|
|
|
|
|
|
default:
|
|
TraceMsg(TF_WARNING, "Don't know how to commit url property (%#lx)", propid);
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (FAILED(hres))
|
|
TraceMsg(TF_WARNING, "Failed to save url property (%#lx) to file %s", propid, pcd->pszFile);
|
|
#endif
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: IPropertyStorage::Commit method for URLProp
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
IntshcutProp::Commit(
|
|
IN DWORD dwFlags)
|
|
{
|
|
HRESULT hres;
|
|
COMMITISDATA cd;
|
|
|
|
TraceMsg(TF_INTSHCUT, "Writing properties to \"%s\"", m_szFile);
|
|
|
|
cd.pszFile = m_szFile;
|
|
|
|
// Enumerate thru the dirty property values that get saved to the
|
|
// file
|
|
hres = PropStg_Enum(m_hstg, PSTGEF_DIRTY, CommitISProp, (LPARAM)&cd);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Now mark everything clean
|
|
PropStg_DirtyAll(m_hstg, FALSE);
|
|
|
|
// Save the times. Don't write out the Accessed time for perf.
|
|
// See LoadFromFile.
|
|
EVAL(SUCCEEDED(WriteBinaryToFile(m_szFile, c_szIntshcut, ISHCUT_INISTRING_MODIFIED, &m_ftModified,
|
|
SIZEOF(m_ftModified))));
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
Dump();
|
|
#endif
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function to set the file name.
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
IntshcutProp::SetFileName(
|
|
IN LPCTSTR pszFile)
|
|
{
|
|
if(pszFile)
|
|
{
|
|
ASSERT(IS_VALID_STRING_PTR(pszFile, -1));
|
|
StrCpyN(m_szFile, pszFile, SIZECHARS(m_szFile));
|
|
}
|
|
else
|
|
{
|
|
*m_szFile = TEXT('\0');;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the URL.
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
IntshcutProp::SetIDListProp(
|
|
LPCITEMIDLIST pcidl)
|
|
{
|
|
HRESULT hres;
|
|
IStream *pstmPidl;
|
|
|
|
if (pcidl)
|
|
{
|
|
// ???
|
|
// PERF: This loads OLE. Is this OK?
|
|
|
|
hres = CreateStreamOnHGlobal(NULL, TRUE, &pstmPidl);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = ILSaveToStream(pstmPidl, pcidl);
|
|
|
|
if (SUCCEEDED(hres))
|
|
hres = SetProp(PID_IS_IDLIST, pstmPidl);
|
|
|
|
pstmPidl->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hres = SetProp(PID_IS_IDLIST, NULL);
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the URL. This function
|
|
optionally canonicalizes the string as well.
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
IntshcutProp::SetURLProp(
|
|
IN LPCTSTR pszURL, OPTIONAL
|
|
IN DWORD dwFlags)
|
|
{
|
|
HRESULT hres;
|
|
|
|
// Warning this function can be called as part of shellexecute which can be
|
|
// thunked up to by a 16 bit app, so be carefull what you put on stack...
|
|
|
|
BOOL bChanged;
|
|
|
|
struct tbufs
|
|
{
|
|
TCHAR szUrl[INTERNET_MAX_URL_LENGTH];
|
|
TCHAR szUrlT[INTERNET_MAX_URL_LENGTH];
|
|
};
|
|
|
|
struct tbufs *ptbufs;
|
|
|
|
ptbufs = (struct tbufs *)LocalAlloc(LMEM_FIXED, sizeof(struct tbufs));
|
|
if (!ptbufs)
|
|
return E_OUTOFMEMORY;
|
|
|
|
hres = GetProp(PID_IS_URL, ptbufs->szUrl, INTERNET_MAX_URL_LENGTH);
|
|
|
|
bChanged = !(( !pszURL && S_OK != hres) ||
|
|
(pszURL && S_OK == hres && 0 == StrCmp(pszURL, ptbufs->szUrl)));
|
|
|
|
hres = S_OK;
|
|
if (bChanged)
|
|
{
|
|
if (NULL == pszURL)
|
|
{
|
|
hres = SetProp(PID_IS_URL, pszURL);
|
|
if (S_OK == hres)
|
|
hres = SetProp(PID_IS_SCHEME, URL_SCHEME_UNKNOWN);
|
|
}
|
|
else
|
|
{
|
|
DWORD dwFlagsT = UQF_CANONICALIZE;
|
|
|
|
// Translate the URL
|
|
|
|
if (IsFlagSet(dwFlags, IURL_SETURL_FL_GUESS_PROTOCOL))
|
|
SetFlag(dwFlagsT, UQF_GUESS_PROTOCOL);
|
|
|
|
if (IsFlagSet(dwFlags, IURL_SETURL_FL_USE_DEFAULT_PROTOCOL))
|
|
SetFlag(dwFlagsT, UQF_USE_DEFAULT_PROTOCOL);
|
|
|
|
// Translate the URL
|
|
hres = IURLQualify(pszURL, dwFlagsT, ptbufs->szUrlT, NULL, NULL);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Is the URL different after being translated?
|
|
bChanged = (0 != StrCmp(ptbufs->szUrlT, ptbufs->szUrl));
|
|
|
|
hres = S_OK;
|
|
if (bChanged)
|
|
{
|
|
// Yes; validate and get the scheme
|
|
PARSEDURL pu;
|
|
|
|
pu.cbSize = SIZEOF(pu);
|
|
hres = ParseURL(ptbufs->szUrlT, &pu);
|
|
|
|
if (S_OK == hres)
|
|
hres = SetProp(PID_IS_URL, ptbufs->szUrlT);
|
|
|
|
if (S_OK == hres)
|
|
hres = SetProp(PID_IS_SCHEME, (DWORD)pu.nScheme);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFree((HLOCAL)ptbufs);
|
|
ptbufs = NULL;
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*----------------------------------------------------------
|
|
Purpose: Helper function that sets the string property
|
|
|
|
*/
|
|
STDMETHODIMP
|
|
IntshcutProp::SetProp(
|
|
IN PROPID pid,
|
|
IN LPCTSTR psz) OPTIONAL
|
|
{
|
|
HRESULT hr;
|
|
|
|
// WARNING:: this function gets called as part of ShellExecute which can be
|
|
// called by 16 bit apps so don't put mondo strings on stack...
|
|
LPCWSTR pszUrl = psz;
|
|
LPWSTR pszTemp = NULL;
|
|
|
|
// For URLs, we need to check for security spoofs
|
|
if (PID_IS_URL == pid && psz && IsSpecialUrl((LPWSTR)psz)) //FEATURE: remove cast
|
|
{
|
|
SHStrDup(psz, &pszTemp);
|
|
|
|
if (NULL != pszTemp)
|
|
{
|
|
// Unescape the url and look for a security context delimitor
|
|
hr = WrapSpecialUrlFlat(pszTemp, lstrlen(pszTemp)+1);
|
|
if (E_ACCESSDENIED == hr)
|
|
{
|
|
// Security delimitor found, so wack it off
|
|
SHRemoveURLTurd(pszTemp);
|
|
pszUrl = pszTemp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
hr = super::SetProp(pid, pszUrl);
|
|
|
|
if (pszTemp)
|
|
{
|
|
CoTaskMemFree(pszTemp);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDAPI CIntshcutProp_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppvOut)
|
|
{
|
|
HRESULT hres;
|
|
|
|
*ppvOut = NULL;
|
|
|
|
if (punkOuter)
|
|
{
|
|
// No
|
|
hres = CLASS_E_NOAGGREGATION;
|
|
}
|
|
else
|
|
{
|
|
IUnknown * piunk = (IUnknown *)(IPropertyStorage *)new IntshcutProp;
|
|
if ( !piunk )
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hres = piunk->QueryInterface(riid, ppvOut);
|
|
piunk->Release();
|
|
}
|
|
}
|
|
|
|
return hres; // S_OK or E_NOINTERFACE
|
|
}
|