static HRESULT WINAPI PropertySetStorage_Open(
IPropertySetStorage* iface,
REFFMTID rfmtid,
DWORD grfMode,
IPropertyStorage **ppprstg)
{
InternetShortcut *This = impl_from_IPropertySetStorage(iface);
TRACE("(%s, 0x%x, %p)\n", debugstr_guid(rfmtid), grfMode, ppprstg);
/* Note: The |STGM_SHARE_EXCLUSIVE is to cope with a bug in the implementation. Should be fixed in ole32. */
return IPropertySetStorage_Open(This->property_set_storage,
rfmtid,
grfMode|STGM_SHARE_EXCLUSIVE,
ppprstg);
}
/*************************************************************************
* SHPropStgCreate [SHELL32.685]
*/
HRESULT WINAPI SHPropStgCreate(IPropertySetStorage *psstg, REFFMTID fmtid,
const CLSID *pclsid, DWORD grfFlags, DWORD grfMode,
DWORD dwDisposition, IPropertyStorage **ppstg, UINT *puCodePage)
{
PROPSPEC prop;
PROPVARIANT ret;
HRESULT hres;
TRACE("%p %s %s %x %x %x %p %p\n", psstg, debugstr_guid(fmtid), debugstr_guid(pclsid),
grfFlags, grfMode, dwDisposition, ppstg, puCodePage);
hres = IPropertySetStorage_Open(psstg, fmtid, grfMode, ppstg);
switch(dwDisposition) {
case CREATE_ALWAYS:
if(SUCCEEDED(hres)) {
IPropertyStorage_Release(*ppstg);
hres = IPropertySetStorage_Delete(psstg, fmtid);
if(FAILED(hres))
return hres;
hres = E_FAIL;
}
case OPEN_ALWAYS:
case CREATE_NEW:
if(FAILED(hres))
hres = IPropertySetStorage_Create(psstg, fmtid, pclsid,
grfFlags, grfMode, ppstg);
case OPEN_EXISTING:
if(FAILED(hres))
return hres;
if(puCodePage) {
prop.ulKind = PRSPEC_PROPID;
prop.u.propid = PID_CODEPAGE;
hres = IPropertyStorage_ReadMultiple(*ppstg, 1, &prop, &ret);
if(FAILED(hres) || ret.vt!=VT_I2)
*puCodePage = 0;
else
*puCodePage = ret.u.iVal;
}
}
return S_OK;
}
/* FIXME: this creates an ANSI storage, try to find conditions under which
* Unicode translation fails
*/
static void testProps(void)
{
static const WCHAR szDot[] = { '.',0 };
static const WCHAR szPrefix[] = { 's','t','g',0 };
static WCHAR propName[] = { 'p','r','o','p',0 };
static char val[] = "l33t auth0r";
WCHAR filename[MAX_PATH];
HRESULT hr;
IStorage *storage = NULL;
IPropertySetStorage *propSetStorage = NULL;
IPropertyStorage *propertyStorage = NULL;
PROPSPEC spec;
PROPVARIANT var;
CLIPDATA clipdata;
unsigned char clipcontent[] = "foobar";
GUID anyOldGuid = { 0x12345678,0xdead,0xbeef, {
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 } };
if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
return;
DeleteFileW(filename);
hr = StgCreateDocfile(filename,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
if(!pStgCreatePropSetStg)
{
IStorage_Release(storage);
DeleteFileW(filename);
return;
}
hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
hr = IPropertySetStorage_Create(propSetStorage,
&FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI,
STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
&propertyStorage);
ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
hr = IPropertyStorage_WriteMultiple(propertyStorage, 0, NULL, NULL, 0);
ok(hr == S_OK, "WriteMultiple with 0 args failed: 0x%08x\n", hr);
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, NULL, NULL, 0);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
/* test setting one that I can't set */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_DICTIONARY;
var.vt = VT_I4;
U(var).lVal = 1;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == STG_E_INVALIDPARAMETER,
"Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
/* test setting one by name with an invalid propidNameFirst */
spec.ulKind = PRSPEC_LPWSTR;
U(spec).lpwstr = propName;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var,
PID_DICTIONARY);
ok(hr == STG_E_INVALIDPARAMETER,
"Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
/* test setting behavior (case-sensitive) */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_BEHAVIOR;
U(var).lVal = 1;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == STG_E_INVALIDPARAMETER,
"Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
/* set one by value.. */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_FIRST_USABLE;
U(var).lVal = 1;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
/* set one by name */
spec.ulKind = PRSPEC_LPWSTR;
U(spec).lpwstr = propName;
U(var).lVal = 2;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var,
PID_FIRST_USABLE);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
/* set a string value */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PIDSI_AUTHOR;
var.vt = VT_LPSTR;
U(var).pszVal = val;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
/* set a clipboard value */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PIDSI_THUMBNAIL;
var.vt = VT_CF;
clipdata.cbSize = sizeof clipcontent + sizeof (ULONG);
clipdata.ulClipFmt = CF_ENHMETAFILE;
clipdata.pClipData = clipcontent;
U(var).pclipdata = &clipdata;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
/* check reading */
hr = IPropertyStorage_ReadMultiple(propertyStorage, 0, NULL, NULL);
ok(hr == S_FALSE, "ReadMultiple with 0 args failed: 0x%08x\n", hr);
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, NULL, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
/* read by propid */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_FIRST_USABLE;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_I4 && U(var).lVal == 1,
"Didn't get expected type or value for property (got type %d, value %d)\n",
var.vt, U(var).lVal);
/* read by name */
spec.ulKind = PRSPEC_LPWSTR;
U(spec).lpwstr = propName;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_I4 && U(var).lVal == 2,
"Didn't get expected type or value for property (got type %d, value %d)\n",
var.vt, U(var).lVal);
/* read string value */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PIDSI_AUTHOR;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val),
"Didn't get expected type or value for property (got type %d, value %s)\n",
var.vt, U(var).pszVal);
PropVariantClear(&var);
/* read clipboard format */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PIDSI_THUMBNAIL;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_CF, "variant type wrong\n");
ok(U(var).pclipdata->ulClipFmt == CF_ENHMETAFILE,
"clipboard type wrong\n");
ok(U(var).pclipdata->cbSize == sizeof clipcontent + sizeof (ULONG),
"clipboard size wrong\n");
ok(!memcmp(U(var).pclipdata->pClipData, clipcontent, sizeof clipcontent),
"clipboard contents wrong\n");
ok(S_OK == PropVariantClear(&var), "failed to clear variant\n");
/* check deleting */
hr = IPropertyStorage_DeleteMultiple(propertyStorage, 0, NULL);
ok(hr == S_OK, "DeleteMultiple with 0 args failed: 0x%08x\n", hr);
hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
/* contrary to what the docs say, you can't delete the dictionary */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_DICTIONARY;
hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec);
ok(hr == STG_E_INVALIDPARAMETER,
"Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
/* now delete the first value.. */
U(spec).propid = PID_FIRST_USABLE;
hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec);
ok(hr == S_OK, "DeleteMultiple failed: 0x%08x\n", hr);
/* and check that it's no longer readable */
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr);
hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
/* check reverting */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_FIRST_USABLE;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
hr = IPropertyStorage_Revert(propertyStorage);
ok(hr == S_OK, "Revert failed: 0x%08x\n", hr);
/* now check that it's still not there */
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr);
/* set an integer value again */
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_FIRST_USABLE;
var.vt = VT_I4;
U(var).lVal = 1;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
/* commit it */
hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
/* set it to a string value */
var.vt = VT_LPSTR;
U(var).pszVal = val;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
/* revert it */
hr = IPropertyStorage_Revert(propertyStorage);
ok(hr == S_OK, "Revert failed: 0x%08x\n", hr);
/* Oddly enough, there's no guarantee that a successful revert actually
* implies the value wasn't saved. Maybe transactional mode needs to be
* used for that?
*/
IPropertyStorage_Release(propertyStorage);
propertyStorage = NULL;
IPropertySetStorage_Release(propSetStorage);
propSetStorage = NULL;
IStorage_Release(storage);
storage = NULL;
/* now open it again */
hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
NULL, 0, &storage);
ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr);
hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
hr = IPropertySetStorage_Open(propSetStorage, &FMTID_SummaryInformation,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage);
ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr);
/* check properties again */
spec.ulKind = PRSPEC_LPWSTR;
U(spec).lpwstr = propName;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_I4 && U(var).lVal == 2,
"Didn't get expected type or value for property (got type %d, value %d)\n",
var.vt, U(var).lVal);
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PIDSI_AUTHOR;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val),
"Didn't get expected type or value for property (got type %d, value %s)\n",
var.vt, U(var).pszVal);
PropVariantClear(&var);
IPropertyStorage_Release(propertyStorage);
IPropertySetStorage_Release(propSetStorage);
IStorage_Release(storage);
DeleteFileW(filename);
/* Test creating a property set storage with a random GUID */
hr = StgCreateDocfile(filename,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
if(!pStgCreatePropSetStg)
{
IStorage_Release(storage);
DeleteFileW(filename);
return;
}
hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
hr = IPropertySetStorage_Create(propSetStorage,
&anyOldGuid, NULL, PROPSETFLAG_ANSI,
STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
&propertyStorage);
ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_FIRST_USABLE;
var.vt = VT_I4;
U(var).lVal = 1;
hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
IPropertyStorage_Release(propertyStorage);
IPropertySetStorage_Release(propSetStorage);
IStorage_Release(storage);
propertyStorage = NULL;
/* now open it again */
hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
NULL, 0, &storage);
ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr);
hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
hr = IPropertySetStorage_Open(propSetStorage, &anyOldGuid,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage);
ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr);
spec.ulKind = PRSPEC_PROPID;
U(spec).propid = PID_FIRST_USABLE;
hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
ok(var.vt == VT_I4 && U(var).lVal == 1,
"Didn't get expected type or value for property (got type %d, value %d)\n",
var.vt, U(var).lVal);
IPropertyStorage_Release(propertyStorage);
IPropertySetStorage_Release(propSetStorage);
IStorage_Release(storage);
DeleteFileW(filename);
}
static HRESULT WINAPI PersistFile_Save(IPersistFile *pFile, LPCOLESTR pszFileName, BOOL fRemember)
{
HRESULT hr = S_OK;
INT len;
CHAR *url;
InternetShortcut *This = impl_from_IPersistFile(pFile);
TRACE("(%p, %s, %d)\n", pFile, debugstr_w(pszFileName), fRemember);
if (pszFileName != NULL && fRemember)
{
LPOLESTR oldFile = This->currentFile;
This->currentFile = co_strdupW(pszFileName);
if (This->currentFile == NULL)
{
This->currentFile = oldFile;
return E_OUTOFMEMORY;
}
CoTaskMemFree(oldFile);
}
if (This->url == NULL)
return E_FAIL;
/* Windows seems to always write:
* ASCII "[InternetShortcut]" headers
* ASCII names in "name=value" pairs
* An ASCII (probably UTF8?) value in "URL=..."
*/
len = WideCharToMultiByte(CP_UTF8, 0, This->url, -1, NULL, 0, 0, 0);
url = heap_alloc(len);
if (url != NULL)
{
HANDLE file;
WideCharToMultiByte(CP_UTF8, 0, This->url, -1, url, len, 0, 0);
file = CreateFileW(pszFileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (file != INVALID_HANDLE_VALUE)
{
DWORD bytesWritten;
char *iconfile;
char str_header[] = "[InternetShortcut]";
char str_URL[] = "URL=";
char str_ICONFILE[] = "ICONFILE=";
char str_eol[] = "\r\n";
IPropertyStorage *pPropStgRead;
PROPSPEC ps[2];
PROPVARIANT pvread[2];
ps[0].ulKind = PRSPEC_PROPID;
ps[0].u.propid = PID_IS_ICONFILE;
ps[1].ulKind = PRSPEC_PROPID;
ps[1].u.propid = PID_IS_ICONINDEX;
WriteFile(file, str_header, lstrlenA(str_header), &bytesWritten, NULL);
WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL);
WriteFile(file, str_URL, lstrlenA(str_URL), &bytesWritten, NULL);
WriteFile(file, url, lstrlenA(url), &bytesWritten, NULL);
WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL);
hr = IPropertySetStorage_Open(This->property_set_storage, &FMTID_Intshcut, STGM_READ|STGM_SHARE_EXCLUSIVE, &pPropStgRead);
if (SUCCEEDED(hr))
{
hr = IPropertyStorage_ReadMultiple(pPropStgRead, 2, ps, pvread);
if (hr == S_FALSE)
{
/* None of the properties are present, that's ok */
hr = S_OK;
IPropertyStorage_Release(pPropStgRead);
}
else if (SUCCEEDED(hr))
{
char indexString[50];
len = WideCharToMultiByte(CP_UTF8, 0, pvread[0].u.pwszVal, -1, NULL, 0, 0, 0);
iconfile = heap_alloc(len);
if (iconfile != NULL)
{
WideCharToMultiByte(CP_UTF8, 0, pvread[0].u.pwszVal, -1, iconfile, len, 0, 0);
WriteFile(file, str_ICONFILE, lstrlenA(str_ICONFILE), &bytesWritten, NULL);
WriteFile(file, iconfile, lstrlenA(iconfile), &bytesWritten, NULL);
WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL);
}
sprintf(indexString, "ICONINDEX=%d", pvread[1].u.iVal);
WriteFile(file, indexString, lstrlenA(indexString), &bytesWritten, NULL);
WriteFile(file, str_eol, lstrlenA(str_eol), &bytesWritten, NULL);
IPropertyStorage_Release(pPropStgRead);
PropVariantClear(&pvread[0]);
PropVariantClear(&pvread[1]);
}
else
{
TRACE("Unable to read properties.\n");
}
}
else
{
TRACE("Unable to get the IPropertyStorage.\n");
}
CloseHandle(file);
if (pszFileName == NULL || fRemember)
This->isDirty = FALSE;
StartLinkProcessor(pszFileName);
}
else
hr = E_FAIL;
heap_free(url);
}
else
hr = E_OUTOFMEMORY;
return hr;
}
static HRESULT WINAPI PersistFile_Load(IPersistFile *pFile, LPCOLESTR pszFileName, DWORD dwMode)
{
WCHAR str_header[] = {'I','n','t','e','r','n','e','t','S','h','o','r','t','c','u','t',0};
WCHAR str_URL[] = {'U','R','L',0};
WCHAR str_iconfile[] = {'i','c','o','n','f','i','l','e',0};
WCHAR str_iconindex[] = {'i','c','o','n','i','n','d','e','x',0};
WCHAR *filename = NULL;
HRESULT hr;
InternetShortcut *This = impl_from_IPersistFile(pFile);
TRACE("(%p, %s, 0x%x)\n", pFile, debugstr_w(pszFileName), dwMode);
if (dwMode != 0)
FIXME("ignoring unimplemented mode 0x%x\n", dwMode);
filename = co_strdupW(pszFileName);
if (filename != NULL)
{
DWORD r;
WCHAR *url;
r = get_profile_string(str_header, str_URL, pszFileName, &url);
if (url == NULL)
{
hr = E_OUTOFMEMORY;
CoTaskMemFree(filename);
}
else if (r == 0)
{
hr = E_FAIL;
CoTaskMemFree(filename);
}
else
{
hr = S_OK;
CoTaskMemFree(This->currentFile);
This->currentFile = filename;
CoTaskMemFree(This->url);
This->url = url;
This->isDirty = FALSE;
}
/* Now we're going to read in the iconfile and iconindex.
If we don't find them, that's not a failure case -- it's possible
that they just aren't in there. */
if (SUCCEEDED(hr))
{
IPropertyStorage *pPropStg;
WCHAR *iconfile;
WCHAR *iconindexstring;
hr = IPropertySetStorage_Open(This->property_set_storage, &FMTID_Intshcut,
STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
&pPropStg);
r = get_profile_string(str_header, str_iconfile, pszFileName, &iconfile);
if (iconfile != NULL)
{
PROPSPEC ps;
PROPVARIANT pv;
ps.ulKind = PRSPEC_PROPID;
ps.u.propid = PID_IS_ICONFILE;
pv.vt = VT_LPWSTR;
pv.u.pwszVal = iconfile;
hr = IPropertyStorage_WriteMultiple(pPropStg, 1, &ps, &pv, 0);
if (FAILED(hr))
{
TRACE("Failed to store the iconfile to our property storage. hr = 0x%x\n", hr);
}
CoTaskMemFree(iconfile);
}
r = get_profile_string(str_header, str_iconindex, pszFileName, &iconindexstring);
if (iconindexstring != NULL)
{
int iconindex;
PROPSPEC ps;
PROPVARIANT pv;
char *iconindexastring = co_strdupWtoA(iconindexstring);
sscanf(iconindexastring, "%d", &iconindex);
CoTaskMemFree(iconindexastring);
ps.ulKind = PRSPEC_PROPID;
ps.u.propid = PID_IS_ICONINDEX;
pv.vt = VT_I4;
pv.u.iVal = iconindex;
hr = IPropertyStorage_WriteMultiple(pPropStg, 1, &ps, &pv, 0);
if (FAILED(hr))
{
TRACE("Failed to store the iconindex to our property storage. hr = 0x%x\n", hr);
}
CoTaskMemFree(iconindexstring);
}
IPropertyStorage_Release(pPropStg);
}
else
hr = E_OUTOFMEMORY;
}
else
hr = E_OUTOFMEMORY;
return hr;
}
static void test_ReadAndWriteProperties(void)
{
HRESULT hr;
IUniformResourceLocatorA *urlA;
IUniformResourceLocatorA *urlAFromFile;
WCHAR fileNameW[MAX_PATH];
static const WCHAR shortcutW[] = {'t','e','s','t','s','h','o','r','t','c','u','t','.','u','r','l',0};
WCHAR iconPath[] = {'f','i','l','e',':','/','/','/','C',':','/','a','r','b','i','t','r','a','r','y','/','i','c','o','n','/','p','a','t','h',0};
int iconIndex = 7;
char testurl[] = "http://some/bogus/url.html";
PROPSPEC ps[2];
ps[0].ulKind = PRSPEC_PROPID;
U(ps[0]).propid = PID_IS_ICONFILE;
ps[1].ulKind = PRSPEC_PROPID;
U(ps[1]).propid = PID_IS_ICONINDEX;
/* Make sure we have a valid temporary directory */
GetTempPathW(MAX_PATH, fileNameW);
lstrcatW(fileNameW, shortcutW);
hr = CoCreateInstance(&CLSID_InternetShortcut, NULL, CLSCTX_ALL, &IID_IUniformResourceLocatorA, (void**)&urlA);
if (hr == S_OK)
{
IPersistFile *pf;
IPropertyStorage *pPropStgWrite;
IPropertySetStorage *pPropSetStg;
PROPVARIANT pv[2];
/* We need to set a URL -- IPersistFile refuses to save without one. */
hr = urlA->lpVtbl->SetURL(urlA, testurl, 0);
ok(hr == S_OK, "Failed to set a URL. hr=0x%x\n", hr);
/* Write this shortcut out to a file so that we can test reading it in again. */
hr = urlA->lpVtbl->QueryInterface(urlA, &IID_IPersistFile, (void **) &pf);
ok(hr == S_OK, "Failed to get the IPersistFile for writing. hr=0x%x\n", hr);
hr = IPersistFile_Save(pf, fileNameW, TRUE);
ok(hr == S_OK, "Failed to save via IPersistFile. hr=0x%x\n", hr);
IPersistFile_Release(pf);
pv[0].vt = VT_LPWSTR;
U(pv[0]).pwszVal = (void *) iconPath;
pv[1].vt = VT_I4;
U(pv[1]).iVal = iconIndex;
hr = urlA->lpVtbl->QueryInterface(urlA, &IID_IPropertySetStorage, (void **) &pPropSetStg);
ok(hr == S_OK, "Unable to get an IPropertySetStorage, hr=0x%x\n", hr);
hr = IPropertySetStorage_Open(pPropSetStg, &FMTID_Intshcut, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pPropStgWrite);
ok(hr == S_OK, "Unable to get an IPropertyStorage for writing, hr=0x%x\n", hr);
hr = IPropertyStorage_WriteMultiple(pPropStgWrite, 2, ps, pv, 0);
ok(hr == S_OK, "Unable to set properties, hr=0x%x\n", hr);
hr = IPropertyStorage_Commit(pPropStgWrite, STGC_DEFAULT);
ok(hr == S_OK, "Failed to commit properties, hr=0x%x\n", hr);
pPropStgWrite->lpVtbl->Release(pPropStgWrite);
urlA->lpVtbl->Release(urlA);
IPropertySetStorage_Release(pPropSetStg);
}
else
skip("could not create a CLSID_InternetShortcut for property tests, hr=0x%x\n", hr);
hr = CoCreateInstance(&CLSID_InternetShortcut, NULL, CLSCTX_ALL, &IID_IUniformResourceLocatorA, (void**)&urlAFromFile);
if (hr == S_OK)
{
IPropertySetStorage *pPropSetStg;
IPropertyStorage *pPropStgRead;
PROPVARIANT pvread[2];
IPersistFile *pf;
LPSTR url = NULL;
/* Now read that .url file back in. */
hr = urlAFromFile->lpVtbl->QueryInterface(urlAFromFile, &IID_IPersistFile, (void **) &pf);
ok(hr == S_OK, "Failed to get the IPersistFile for reading. hr=0x%x\n", hr);
hr = IPersistFile_Load(pf, fileNameW, 0);
ok(hr == S_OK, "Failed to load via IPersistFile. hr=0x%x\n", hr);
IPersistFile_Release(pf);
hr = urlAFromFile->lpVtbl->GetURL(urlAFromFile, &url);
ok(hr == S_OK, "Unable to get url from file, hr=0x%x\n", hr);
ok(lstrcmp(url, testurl) == 0, "Wrong url read from file: %s\n",url);
hr = urlAFromFile->lpVtbl->QueryInterface(urlAFromFile, &IID_IPropertySetStorage, (void **) &pPropSetStg);
ok(hr == S_OK, "Unable to get an IPropertySetStorage, hr=0x%x\n", hr);
hr = IPropertySetStorage_Open(pPropSetStg, &FMTID_Intshcut, STGM_READ | STGM_SHARE_EXCLUSIVE, &pPropStgRead);
ok(hr == S_OK, "Unable to get an IPropertyStorage for reading, hr=0x%x\n", hr);
hr = IPropertyStorage_ReadMultiple(pPropStgRead, 2, ps, pvread);
ok(hr == S_OK, "Unable to read properties, hr=0x%x\n", hr);
todo_wine /* Wine doesn't yet support setting properties after save */
{
ok(U(pvread[1]).iVal == iconIndex, "Read wrong icon index: %d\n", U(pvread[1]).iVal);
ok(lstrcmpW(U(pvread[0]).pwszVal, iconPath) == 0, "Wrong icon path read: %s\n", wine_dbgstr_w(U(pvread[0]).pwszVal));
}
PropVariantClear(&pvread[0]);
PropVariantClear(&pvread[1]);
IPropertyStorage_Release(pPropStgRead);
IPropertySetStorage_Release(pPropSetStg);
urlAFromFile->lpVtbl->Release(urlAFromFile);
DeleteFileW(fileNameW);
}
