/***********************************************************************
* MsiSIPIsMyTypeOfFile (MSISIP.@)
*/
BOOL WINAPI MsiSIPIsMyTypeOfFile(WCHAR *name, GUID *subject)
{
BOOL ret = FALSE;
IStorage *stg = NULL;
HRESULT r;
TRACE("(%s, %p)\n", debugstr_w(name), subject);
r = StgOpenStorage(name, NULL, STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE,
NULL, 0, &stg);
if (SUCCEEDED(r))
{
STATSTG stat;
r = IStorage_Stat(stg, &stat, STATFLAG_NONAME);
if (SUCCEEDED(r))
{
if (IsEqualGUID(&stat.clsid, &CLSID_MsiDatabase) ||
IsEqualGUID(&stat.clsid, &CLSID_MsiPatch) ||
IsEqualGUID(&stat.clsid, &CLSID_MsiTransform))
{
ret = TRUE;
*subject = mySubject;
}
}
IStorage_Release(stg);
}
return ret;
}
RImage* QSLItemData::Load(
CString& strDocPathname, // @parm string containing document pathname
BOOL fDescOnly )
{
USES_CONVERSION;
LPSTORAGE pIStorage = NULL;
// get path name in Unicode
const WCHAR *pDocPathname = T2COLE((LPCTSTR)strDocPathname.GetBuffer (10));
strDocPathname.ReleaseBuffer();
// open storage
StgOpenStorage( pDocPathname, NULL, STGM_DIRECT | STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0, &pIStorage );
if (!pIStorage)
return NULL ;
RImage* pImage = Load2( pIStorage, fDescOnly );
if (dynamic_cast<RBitmapImage *>( pImage ))
((RBitmapImage *) pImage)->LockImage();
// release storage
pIStorage->Release();
return( pImage );
}
HRESULT CDShowCtrl::LoadGraphFile(IGraphBuilder *pGraph, const WCHAR* wszName)
{
IStorage *pStorage = 0;
if (S_OK != StgIsStorageFile(wszName))
{
return E_FAIL;
}
HRESULT hr = StgOpenStorage(wszName, 0,
STGM_TRANSACTED | STGM_READ | STGM_SHARE_DENY_WRITE,
0, 0, &pStorage);
if (FAILED(hr))
{
return hr;
}
IPersistStream *pPersistStream = 0;
hr = pGraph->QueryInterface(IID_IPersistStream,
reinterpret_cast<void**>(&pPersistStream));
if (SUCCEEDED(hr))
{
IStream *pStream = 0;
hr = pStorage->OpenStream(L"ActiveMovieGraph", 0,
STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
if(SUCCEEDED(hr))
{
hr = pPersistStream->Load(pStream);
pStream->Release();
}
pPersistStream->Release();
}
pStorage->Release();
return hr;
}
/***********************************************************************
* MsiSIPIsMyTypeOfFile (MSISIP.@)
*/
BOOL WINAPI MsiSIPIsMyTypeOfFile(WCHAR *name, GUID *subject)
{
static const WCHAR msi[] = { '.','m','s','i',0 };
static const WCHAR msp[] = { '.','m','s','p',0 };
BOOL ret = FALSE;
TRACE("(%s, %p)\n", debugstr_w(name), subject);
if (lstrlenW(name) < lstrlenW(msi))
return FALSE;
else if (lstrcmpiW(name + lstrlenW(name) - lstrlenW(msi), msi) &&
lstrcmpiW(name + lstrlenW(name) - lstrlenW(msp), msp))
return FALSE;
else
{
IStorage *stg = NULL;
HRESULT r = StgOpenStorage(name, NULL,
STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
if (SUCCEEDED(r))
{
IStorage_Release(stg);
*subject = mySubject;
ret = TRUE;
}
}
return ret;
}
// @pymethod <o PyIStorage>|pythoncom|StgOpenStorage|Opens an existing root storage object in the file system.
PyObject *pythoncom_StgOpenStorage(PyObject *self, PyObject *args)
{
PyObject *temp = NULL;
DWORD reserved = 0;
PyObject *obName;
DWORD mode;
IStorage *pResult;
PyObject *obOther;
if (!PyArg_ParseTuple(args, "OOi|Oi:StgOpenStorage",
&obName, // @pyparm string|name||Name of the stream, or possibly None if storageOther is non None.
&obOther, // @pyparm <o PyIStorage>|other||Usually None, or another parent storage.
&mode, // @pyparm int|mode||Specifies the access mode used to open the storage. A combination of the storagecon.STGM_* constants.
&temp, // @pyparm object|snbExclude|None|Not yet supported - must be None
&reserved)) // @pyparm int|reserved|0|A reserved value
return NULL;
PyWin_AutoFreeBstr bstrName;
if ( !PyWinObject_AsAutoFreeBstr(obName, &bstrName, TRUE) )
return NULL;
IStorage *pOther;
if (!PyCom_InterfaceFromPyObject(obOther, IID_IStorage, (void **)&pOther, TRUE))
return NULL;
PY_INTERFACE_PRECALL;
HRESULT hr = StgOpenStorage(bstrName, pOther, mode, NULL, reserved, &pResult);
if (pOther) pOther->Release();
PY_INTERFACE_POSTCALL;
if (FAILED(hr)) return PyCom_BuildPyException(hr);
return PyCom_PyObjectFromIUnknown(pResult, IID_IStorage, FALSE);
}
void StreamFileReader::Open(CStdStringW sDocFileName)
{
HRESULT hr = StgOpenStorage(sDocFileName ,NULL, STGM_DIRECT_SWMR|STGM_READ|STGM_SHARE_DENY_NONE,
NULL, 0, &m_pRootStorage);
if (FAILED(hr))
throw _com_error(hr);
if (m_pRootStorage == NULL)
throw _com_error(E_FAIL);
}
HRESULT MakeRootStorage(LPSTORAGE *ppIStorage, LPCSTR pPathName)
{
HRESULT hr = NOERROR;
DWORD dwMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE |
STGM_TRANSACTED ;
char *pNameToUse = new char [_MAX_PATH];
LPSTORAGE pIStorage = *ppIStorage;
if (NULL == pNameToUse || NULL == pPathName)
return ResultFromScode(E_FAIL);
// alte ProjektStruktur, eigenes DocFile erzeugen/öffnen
// erstellt Pfadnamen
hr = MakeFileName (pPathName, pNameToUse, "str");
if (FAILED(hr))
return hr;
// Funktionen machen Addref(), Release() im Destruktor (Memberpointer Rootstorage)
USES_CONVERSION;
hr = StgOpenStorage (A2OLE(pNameToUse), NULL, dwMode, 0, 0, &pIStorage);
if (FAILED(hr)) {
if (GetScode(hr) == STG_E_FILENOTFOUND) {
// neu anlegen
dwMode |= STGM_CREATE;
hr = StgCreateDocfile (A2OLE(pNameToUse), dwMode, 0, &pIStorage);
delete (pNameToUse);
if (FAILED(hr)) return hr;
// GUID reinschreiben (Kontrollmöglichkeit)
hr = WriteClassStg (pIStorage, CLSID_ScriptContainer);
if (FAILED(hr)) {
pIStorage -> Release();
return hr;
}
}
else {
delete (pNameToUse);
return hr;
}
} else delete (pNameToUse);
hr = TestclsID (pIStorage, CLSID_ScriptContainer);
if (FAILED(hr)) { pIStorage -> Release(); return hr; }
*ppIStorage = pIStorage;
return NOERROR;
}
/******************************************************************************
* FileMoniker_BindToStorage
*/
static HRESULT WINAPI
FileMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
REFIID riid, VOID** ppvObject)
{
LPOLESTR filePath=0;
IStorage *pstg=0;
HRESULT res;
TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
if (pmkToLeft==NULL){
if (IsEqualIID(&IID_IStorage, riid)){
/* get the file name */
IMoniker_GetDisplayName(iface,pbc,pmkToLeft,&filePath);
/* verify if the file contains a storage object */
res=StgIsStorageFile(filePath);
if(res==S_OK){
res=StgOpenStorage(filePath,NULL,STGM_READWRITE|STGM_SHARE_DENY_WRITE,NULL,0,&pstg);
if (SUCCEEDED(res)){
*ppvObject=pstg;
IStorage_AddRef(pstg);
return res;
}
}
CoTaskMemFree(filePath);
}
else
if ( (IsEqualIID(&IID_IStream, riid)) || (IsEqualIID(&IID_ILockBytes, riid)) )
return E_FAIL;
else
return E_NOINTERFACE;
}
else {
FIXME("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvObject);
return E_NOTIMPL;
}
return res;
}
void E_IStorage::ccom_open_root_storage (WCHAR * pwcsName, DWORD grfMode)
// Opens an existing root storage object in the file system.
// Points pRootStorage to the opened storage object.
// Parameters
// - pwcsName points to the pathname of the compound file to create.
// - grfMode specifies the access mode to use when opening the new
// storage object. Must be one of the STGM enumeration values.
{
HRESULT hr;
hr = StgOpenStorage (pwcsName, NULL, grfMode,
NULL, 0, &pStorage);
if (hr != S_OK)
{
pStorage = NULL;
com_eraise (f.c_format_message (hr), EN_COM);
}
};
/***********************************************************************
* MsiSIPGetSignedDataMsg (MSISIP.@)
*/
BOOL WINAPI MsiSIPGetSignedDataMsg(SIP_SUBJECTINFO *pSubjectInfo,
DWORD *pdwEncodingType, DWORD dwIndex, DWORD *pcbSignedDataMsg,
BYTE *pbSignedDataMsg)
{
static const WCHAR digitalSig[] = { 5,'D','i','g','i','t','a','l',
'S','i','g','n','a','t','u','r','e',0 };
BOOL ret = FALSE;
IStorage *stg = NULL;
HRESULT r;
IStream *stm = NULL;
BYTE hdr[2], len[sizeof(DWORD)];
DWORD count, lenBytes, dataBytes;
TRACE("(%p %p %d %p %p)\n", pSubjectInfo, pdwEncodingType, dwIndex,
pcbSignedDataMsg, pbSignedDataMsg);
r = StgOpenStorage(pSubjectInfo->pwsFileName, NULL,
STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
if (FAILED(r))
{
TRACE("couldn't open %s\n", debugstr_w(pSubjectInfo->pwsFileName));
goto end;
}
r = IStorage_OpenStream(stg, digitalSig, 0,
STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &stm);
if (FAILED(r))
{
TRACE("couldn't find digital signature stream\n");
goto freestorage;
}
r = IStream_Read(stm, hdr, sizeof(hdr), &count);
if (FAILED(r) || count != sizeof(hdr))
goto freestream;
if (hdr[0] != 0x30)
{
WARN("unexpected data in digital sig: 0x%02x%02x\n", hdr[0], hdr[1]);
goto freestream;
}
/* Read the asn.1 length from the stream. Only supports definite-length
* values, which DER-encoded signatures should be.
*/
if (hdr[1] == 0x80)
{
WARN("indefinite-length encoding not supported!\n");
goto freestream;
}
else if (hdr[1] & 0x80)
{
DWORD temp;
LPBYTE ptr;
lenBytes = hdr[1] & 0x7f;
if (lenBytes > sizeof(DWORD))
{
WARN("asn.1 length too long (%d)\n", lenBytes);
goto freestream;
}
r = IStream_Read(stm, len, lenBytes, &count);
if (FAILED(r) || count != lenBytes)
goto freestream;
dataBytes = 0;
temp = lenBytes;
ptr = len;
while (temp--)
{
dataBytes <<= 8;
dataBytes |= *ptr++;
}
}
else
{
lenBytes = 0;
dataBytes = hdr[1];
}
if (!pbSignedDataMsg)
{
*pcbSignedDataMsg = 2 + lenBytes + dataBytes;
ret = TRUE;
}
else if (*pcbSignedDataMsg < 2 + lenBytes + dataBytes)
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
*pcbSignedDataMsg = 2 + lenBytes + dataBytes;
}
else
{
LPBYTE ptr = pbSignedDataMsg;
memcpy(ptr, hdr, sizeof(hdr));
ptr += sizeof(hdr);
if (lenBytes)
{
memcpy(ptr, len, lenBytes);
ptr += lenBytes;
}
r = IStream_Read(stm, ptr, dataBytes, &count);
if (SUCCEEDED(r) && count == dataBytes)
{
*pdwEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
*pcbSignedDataMsg = 2 + lenBytes + dataBytes;
ret = TRUE;
}
}
freestream:
IStream_Release(stm);
freestorage:
IStorage_Release(stg);
end:
TRACE("returning %d\n", ret);
return ret;
}
//加载信息
bool CUserInformation::LoadInformation()
{
//变量定义
IStream * pIStreamSub=NULL;
IStorage * pIStorageSub=NULL;
IStorage * pIStorageRoot=NULL;
IEnumSTATSTG * pIEnumSTATSTG=NULL;
//读取数据
try
{
//变量定义
STATSTG Statstg;
tagCompanionInfo CompanionInfo;
ZeroMemory(&Statstg,sizeof(Statstg));
ZeroMemory(&CompanionInfo,sizeof(CompanionInfo));
//工作目录
TCHAR szDirectory[MAX_PATH]=TEXT("");
CWHService::GetWorkDirectory(szDirectory,CountArray(szDirectory));
//打开文件
WCHAR szInfomationFile[MAX_PATH]=L"";
_snwprintf(szInfomationFile,CountArray(szInfomationFile),L"%s\\%s",(LPCWSTR)(CT2CW(szDirectory)),INFORMATION_FILE);
//打开文件
StgOpenStorage(szInfomationFile,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageRoot);
if (pIStorageRoot==NULL) return false;
//创建枚举
pIStorageRoot->EnumElements(0,NULL,0,&pIEnumSTATSTG);
if (pIEnumSTATSTG==NULL) throw TEXT("EnumElements Create pIEnumSTATSTG Error");
//枚举对象
while (pIEnumSTATSTG->Next(1,&Statstg,NULL)==NOERROR)
{
//目录类型
if (Statstg.type==STGTY_STORAGE)
{
//打开存储
pIStorageRoot->OpenStorage(Statstg.pwcsName,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageSub);
if (pIStorageSub==NULL) throw TEXT("CreateStorage Create pIStorageSub Error");
//打开数据
pIStorageSub->OpenStream(STREAM_COMPANION,NULL,STGM_READ|STGM_SHARE_EXCLUSIVE,0,&pIStreamSub);
//读取数据
if (pIStreamSub!=NULL)
{
//读取关系
ULONG cbReadCount=0L;
pIStreamSub->Read(&CompanionInfo,sizeof(CompanionInfo),&cbReadCount);
//读取效验
ASSERT(cbReadCount==sizeof(CompanionInfo));
if (cbReadCount!=sizeof(CompanionInfo)) throw TEXT("Read Data CompanionInfo Error");
//创建对象
tagCompanionInfo * pCompanionInfo=CreateCompanionItem();
if (pCompanionInfo==NULL) throw TEXT("CreateCompanionItem Error");
//设置信息
CopyMemory(pCompanionInfo,&CompanionInfo,sizeof(CompanionInfo));
}
//释放接口
SafeRelease(pIStreamSub);
SafeRelease(pIStorageSub);
}
//释放内存
CoTaskMemFree(Statstg.pwcsName);
}
//释放接口
SafeRelease(pIEnumSTATSTG);
SafeRelease(pIStreamSub);
SafeRelease(pIStorageSub);
SafeRelease(pIStorageRoot);
return true;
}
catch (...)
{
//错误断言
ASSERT(FALSE);
//释放接口
SafeRelease(pIEnumSTATSTG);
SafeRelease(pIStreamSub);
SafeRelease(pIStorageSub);
SafeRelease(pIStorageRoot);
}
return false;
}
void App::GetProperties()
{
LPSTORAGE pStorage = NULL;
IPropertySetStorage* pPropertySetStorage = NULL;
IPropertyStorage* pSummaryInfoStorage = NULL;
IPropertyStorage* pDocumentSummaryInfoStorage = NULL;
IPropertyStorage* pUserDefinedPropertyStorage = NULL;
wchar_t wfilename[_MAX_PATH];
char szBuf[256];
char filename[MAX_PATH];
SendMessage(GetDlgItem(hPropDialog, IDC_TITLE), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_SUBJECT), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_AUTHOR), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_MANAGER), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_COMPANY), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_CATEGORY), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_KEYWORDS), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_COMMENTS), WM_SETTEXT, 0, (LPARAM)"");
SendMessage(GetDlgItem(hPropDialog, IDC_CONTENTS), LB_RESETCONTENT, 0, 0);
ListView_DeleteAllItems(GetDlgItem(hPropDialog, IDC_CUSTOM));
int idx = SendMessage(hListBox, LB_GETCURSEL, 0, 0);
SendMessage(hListBox, LB_GETTEXT, idx, (LPARAM)filename);
SetWindowText(hPropDialog, filename);
MultiByteToWideChar(CP_ACP, 0, filename, -1, wfilename, _MAX_PATH);
HRESULT res = StgOpenStorage(wfilename, (LPSTORAGE)0, STGM_DIRECT|STGM_READ|STGM_SHARE_EXCLUSIVE, NULL,0,&pStorage);
if (res!=S_OK) {
return;
}
// Get the Storage interface
if (S_OK != pStorage->QueryInterface(IID_IPropertySetStorage, (void**)&pPropertySetStorage)) {
pStorage->Release();
return;
}
// Get the SummaryInfo property set interface
if (S_OK == pPropertySetStorage->Open(FMTID_SummaryInformation, STGM_READ|STGM_SHARE_EXCLUSIVE, &pSummaryInfoStorage)) {
BOOL bFound = FALSE;
PROPSPEC PropSpec[5];
PROPVARIANT PropVar[5];
PropSpec[0].ulKind = PRSPEC_PROPID;
PropSpec[0].propid = PID_TITLE;
PropSpec[1].ulKind = PRSPEC_PROPID;
PropSpec[1].propid = PID_SUBJECT;
PropSpec[2].ulKind = PRSPEC_PROPID;
PropSpec[2].propid = PID_AUTHOR;
PropSpec[3].ulKind = PRSPEC_PROPID;
PropSpec[3].propid = PID_KEYWORDS;
PropSpec[4].ulKind = PRSPEC_PROPID;
PropSpec[4].propid = PID_COMMENTS;
HRESULT hr = pSummaryInfoStorage->ReadMultiple(5, PropSpec, PropVar);
if (S_OK == hr) {
if (PropVar[0].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_TITLE), WM_SETTEXT, 0, (LPARAM)PropVar[0].pszVal);
}
if (PropVar[1].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_SUBJECT), WM_SETTEXT, 0, (LPARAM)PropVar[1].pszVal);
}
if (PropVar[2].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_AUTHOR), WM_SETTEXT, 0, (LPARAM)PropVar[2].pszVal);
}
if (PropVar[3].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_KEYWORDS), WM_SETTEXT, 0, (LPARAM)PropVar[3].pszVal);
}
if (PropVar[4].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_COMMENTS), WM_SETTEXT, 0, (LPARAM)PropVar[4].pszVal);
}
}
FreePropVariantArray(5, PropVar);
pSummaryInfoStorage->Release();
}
// Get the DocumentSummaryInfo property set interface
if (S_OK == pPropertySetStorage->Open(FMTID_DocSummaryInformation, STGM_READ|STGM_SHARE_EXCLUSIVE, &pDocumentSummaryInfoStorage)) {
BOOL bFound = FALSE;
PROPSPEC PropSpec[5];
PROPVARIANT PropVar[5];
PropSpec[0].ulKind = PRSPEC_PROPID;
PropSpec[0].propid = PID_MANAGER;
PropSpec[1].ulKind = PRSPEC_PROPID;
PropSpec[1].propid = PID_COMPANY;
PropSpec[2].ulKind = PRSPEC_PROPID;
PropSpec[2].propid = PID_CATEGORY;
PropSpec[3].ulKind = PRSPEC_PROPID;
PropSpec[3].propid = PID_HEADINGPAIR;
PropSpec[4].ulKind = PRSPEC_PROPID;
PropSpec[4].propid = PID_DOCPARTS;
HRESULT hr = pDocumentSummaryInfoStorage->ReadMultiple(5, PropSpec, PropVar);
if (S_OK == hr) {
if (PropVar[0].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_MANAGER), WM_SETTEXT, 0, (LPARAM)PropVar[0].pszVal);
}
if (PropVar[1].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_COMPANY), WM_SETTEXT, 0, (LPARAM)PropVar[1].pszVal);
}
if (PropVar[2].vt == VT_LPSTR) {
SendMessage(GetDlgItem(hPropDialog, IDC_CATEGORY), WM_SETTEXT, 0, (LPARAM)PropVar[2].pszVal);
}
if ((PropVar[3].vt == (VT_VARIANT | VT_VECTOR)) && (PropVar[4].vt == (VT_LPSTR | VT_VECTOR))) {
CAPROPVARIANT* pHeading = &PropVar[3].capropvar;
CALPSTR* pDocPart = &PropVar[4].calpstr;
// Headings:
// =========
// 0 - General
// 2 - Mesh Totals
// 4 - Scene Totals
// 6 - External Dependencies
// 8 - Objects
// 10 - Materials
// 12 - Plug-Ins
int nDocPart = 0;
for (UINT i=0; i<pHeading->cElems; i+=2) {
SendMessage(GetDlgItem(hPropDialog, IDC_CONTENTS), LB_ADDSTRING, 0, (LPARAM)pHeading->pElems[i].pszVal);
for (int j=0; j<pHeading->pElems[i+1].lVal; j++) {
sprintf(szBuf, "\t%s", pDocPart->pElems[nDocPart]);
SendMessage(GetDlgItem(hPropDialog, IDC_CONTENTS), LB_ADDSTRING, 0, (LPARAM)szBuf);
nDocPart++;
}
}
}
}
FreePropVariantArray(5, PropVar);
pDocumentSummaryInfoStorage->Release();
}
if (S_OK == pPropertySetStorage->Open(FMTID_UserDefinedProperties, STGM_READ|STGM_SHARE_EXCLUSIVE, &pUserDefinedPropertyStorage)) {
int numUserProps = 0;
// First we need to count the properties
IEnumSTATPROPSTG* pIPropertyEnum;
if (S_OK == pUserDefinedPropertyStorage->Enum(&pIPropertyEnum)) {
STATPROPSTG property;
while (pIPropertyEnum->Next(1, &property, NULL) == S_OK) {
if (property.lpwstrName) {
CoTaskMemFree(property.lpwstrName);
property.lpwstrName = NULL;
numUserProps++;
}
}
PROPSPEC* pPropSpec = new PROPSPEC[numUserProps];
PROPVARIANT* pPropVar = new PROPVARIANT[numUserProps];
ZeroMemory(pPropVar, numUserProps*sizeof(PROPVARIANT));
ZeroMemory(pPropSpec, numUserProps*sizeof(PROPSPEC));
pIPropertyEnum->Reset();
int idx = 0;
while (pIPropertyEnum->Next(1, &property, NULL) == S_OK) {
if (property.lpwstrName) {
pPropSpec[idx].ulKind = PRSPEC_LPWSTR;
pPropSpec[idx].lpwstr = (LPWSTR)CoTaskMemAlloc(sizeof(wchar_t)*(wcslen(property.lpwstrName)+1));
wcscpy(pPropSpec[idx].lpwstr, property.lpwstrName);
idx++;
CoTaskMemFree(property.lpwstrName);
property.lpwstrName = NULL;
}
}
pIPropertyEnum->Release();
ListView_DeleteAllItems(GetDlgItem(hPropDialog, IDC_CUSTOM));
HRESULT hr = pUserDefinedPropertyStorage->ReadMultiple(idx, pPropSpec, pPropVar);
if (S_OK == hr) {
for (int i=0; i<idx; i++) {
wcstombs(szBuf, pPropSpec[i].lpwstr, 255);
LV_ITEM item;
item.mask = LVIF_TEXT;
item.iItem = i;
item.iSubItem = 0;
item.pszText = szBuf;
item.cchTextMax = strlen(szBuf);
ListView_InsertItem(GetDlgItem(hPropDialog, IDC_CUSTOM), &item);
VariantToString(this, &pPropVar[i], szBuf, 255);
item.iSubItem = 1;
item.pszText = szBuf;
item.cchTextMax = strlen(szBuf);
ListView_SetItem(GetDlgItem(hPropDialog, IDC_CUSTOM), &item);
TypeNameFromVariant(this, &pPropVar[i], szBuf, 255);
item.iSubItem = 2;
item.pszText = szBuf;
item.cchTextMax = strlen(szBuf);
ListView_SetItem(GetDlgItem(hPropDialog, IDC_CUSTOM), &item);
}
}
for (int i=0; i<idx; i++) {
CoTaskMemFree(pPropSpec[i].lpwstr);
}
FreePropVariantArray(numUserProps, pPropVar);
delete [] pPropSpec;
delete [] pPropVar;
}
pUserDefinedPropertyStorage->Release();
}
pPropertySetStorage->Release();
pStorage->Release();
}
BOOL COleDocument::OnOpenDocument(LPCTSTR lpszPathName)
{
ASSERT(lpszPathName == NULL || AfxIsValidString(lpszPathName));
// just use default implementation if 'docfile' not enabled
if (!m_bCompoundFile && m_lpRootStg == NULL)
{
ASSERT(lpszPathName != NULL);
return CDocument::OnOpenDocument(lpszPathName);
}
if (IsModified())
TRACE(traceOle, 0, "Warning: OnOpenDocument replaces an unsaved document.\n");
// abort changes to current docfile
if (lpszPathName != NULL)
{
DeleteContents();
RELEASE(m_lpRootStg);
}
SetModifiedFlag(); // dirty during de-serialize
BOOL bResult = FALSE;
TRY
{
if (m_lpRootStg == NULL)
{
const CStringW strPathName(lpszPathName);
LPCOLESTR lpsz = lpszPathName ? strPathName.GetString() : NULL;
// use STGM_CONVERT if necessary
SCODE sc;
LPSTORAGE lpStorage = NULL;
if (StgIsStorageFile(lpsz) == S_FALSE)
{
// convert existing storage file
sc = StgCreateDocfile(lpsz, STGM_READWRITE|
STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_CONVERT,
0, &lpStorage);
}
else
{
// open new storage file
sc = StgOpenStorage(lpsz, NULL,
STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE,
0, 0, &lpStorage);
if (FAILED(sc) || lpStorage == NULL)
sc = StgOpenStorage(lpsz, NULL,
STGM_READ|STGM_TRANSACTED, 0, 0, &lpStorage);
}
if (FAILED(sc))
AfxThrowOleException(sc);
ASSERT(lpStorage != NULL);
m_lpRootStg = lpStorage;
}
// use helper to read document from storage
LoadFromStorage();
SetModifiedFlag(FALSE); // start off with unmodified
bResult = TRUE;
}
CATCH_ALL(e)
{
DeleteContents(); // removed failed contents
RELEASE(m_lpRootStg);
// if not file-based load, return exceptions to the caller
if (lpszPathName == NULL)
{
THROW_LAST();
}
TRY
{
ReportSaveLoadException(lpszPathName, e,
FALSE, AFX_IDP_FAILED_TO_OPEN_DOC);
}
END_TRY
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
return bResult;
}
? VTRUE : VFALSE;
}
/** Open a compound document file to initialize this object. The file is
expected to already exist, and will be created only if bCreateIfNeeded
is VTRUE. Returns VTRUE on success, VFALSE on failure.*/
VBOOL OpenFile( VSTRING_CONST pszFileName,
VBOOL bCreateIfNeeded = VTRUE)
{
/* This object should NOT already be initialized!*/
VASSERT(!m_pWrappedObject)
if ( FAILED(StgOpenStorage(
VTEXT_ANY(pszFileName),
NULL,
m_nMode,
NULL,
0,
(IStorage**)&m_pWrappedObject)) && bCreateIfNeeded )
{
StgCreateDocfile( VTEXT_ANY(pszFileName),
STGM_CREATE | m_nMode,
0,
(IStorage**)&m_pWrappedObject);
}
return (m_pWrappedObject) ? VTRUE : VFALSE;
}
/** Open a named storage as a sub-storage of this object, returning a
pointer to it on success, NULL on failure. The object returned from
/* 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);
}
UINT MSI_OpenDatabaseW(LPCWSTR szDBPath, LPCWSTR szPersist, MSIDATABASE **pdb)
{
IStorage *stg = NULL;
HRESULT r;
MSIDATABASE *db = NULL;
UINT ret = ERROR_FUNCTION_FAILED;
LPCWSTR szMode;
STATSTG stat;
TRACE("%s %s\n",debugstr_w(szDBPath),debugstr_w(szPersist) );
if( !pdb )
return ERROR_INVALID_PARAMETER;
szMode = szPersist;
if( HIWORD( szPersist ) )
{
/* UINT len = lstrlenW( szPerist ) + 1; */
FIXME("don't support persist files yet\b");
return ERROR_INVALID_PARAMETER;
/* szMode = msi_alloc( len * sizeof (DWORD) ); */
}
else if( szPersist == MSIDBOPEN_READONLY )
{
r = StgOpenStorage( szDBPath, NULL,
STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
}
else if( szPersist == MSIDBOPEN_CREATE || szPersist == MSIDBOPEN_CREATEDIRECT )
{
/* FIXME: MSIDBOPEN_CREATE should case STGM_TRANSACTED flag to be
* used here: */
r = StgCreateDocfile( szDBPath,
STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &stg);
if( r == ERROR_SUCCESS )
{
IStorage_SetClass( stg, &CLSID_MsiDatabase );
r = init_string_table( stg );
}
}
else if( szPersist == MSIDBOPEN_TRANSACT )
{
/* FIXME: MSIDBOPEN_TRANSACT should case STGM_TRANSACTED flag to be
* used here: */
r = StgOpenStorage( szDBPath, NULL,
STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
}
else if( szPersist == MSIDBOPEN_DIRECT )
{
r = StgOpenStorage( szDBPath, NULL,
STGM_DIRECT|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
}
else
{
ERR("unknown flag %p\n",szPersist);
return ERROR_INVALID_PARAMETER;
}
if( FAILED( r ) )
{
FIXME("open failed r = %08lx!\n",r);
return ERROR_FUNCTION_FAILED;
}
r = IStorage_Stat( stg, &stat, STATFLAG_NONAME );
if( FAILED( r ) )
{
FIXME("Failed to stat storage\n");
goto end;
}
if ( !IsEqualGUID( &stat.clsid, &CLSID_MsiDatabase ) &&
!IsEqualGUID( &stat.clsid, &CLSID_MsiPatch ) )
{
ERR("storage GUID is not a MSI database GUID %s\n",
debugstr_guid(&stat.clsid) );
goto end;
}
db = alloc_msiobject( MSIHANDLETYPE_DATABASE, sizeof (MSIDATABASE),
MSI_CloseDatabase );
if( !db )
{
FIXME("Failed to allocate a handle\n");
goto end;
}
if( TRACE_ON( msi ) )
enum_stream_names( stg );
db->storage = stg;
db->mode = szMode;
list_init( &db->tables );
list_init( &db->transforms );
db->strings = load_string_table( stg );
if( !db->strings )
goto end;
ret = ERROR_SUCCESS;
msiobj_addref( &db->hdr );
IStorage_AddRef( stg );
*pdb = db;
end:
if( db )
msiobj_release( &db->hdr );
if( stg )
IStorage_Release( stg );
return ret;
}
HRESULT GRF_File::Load(LPCWSTR fileName)
{
HRESULT hr = S_OK;
STATSTG rGrfStat;
CComPtr<IStorage> pGrfFile;
CComPtr<IStream> pGrfData;
Clear();
TRACE(trace_open(NULL,zFalse));
TRACE(trace(TEXT("*** StgOpenStorage(L\"%") TRACEWSTR TEXT("\")...\n"), fileName));
if(S_OK != (hr = StgOpenStorage(fileName,NULL,STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE,NULL,DWRESERVED,&pGrfFile)))
return hr;
TRACE(trace(TEXT("*** OpenStream(L\"ActiveMovieGraph\")...\n")));
if(S_OK != (hr = pGrfFile->OpenStream(L"ActiveMovieGraph",LPRESERVED,STGM_DIRECT|STGM_READ|STGM_SHARE_EXCLUSIVE,DWRESERVED,&pGrfData)))
return hr;
TRACE(trace(TEXT("*** Stat()...\n")));
if(S_OK != (hr = pGrfData->Stat(&rGrfStat,STATFLAG_NONAME)))
return hr;
int cb = (int)rGrfStat.cbSize.QuadPart;
TRACE(trace(TEXT("*** new BYTE[%d]...\n"),cb));
const int EXTRA = 32 * sizeof(WCHAR); // add safety margin to end of buffer
CStringA data('\0', cb + EXTRA);
char* const pb = data.GetBufferSetLength(cb + EXTRA);
if (!pb)
return E_POINTER;
TRACE(trace(TEXT("*** Read(%d)...\n"),cb));
if(S_OK != (hr = pGrfData->Read(pb,(ULONG)cb,NULL)))
return hr;
LPCWSTR p = (LPCWSTR)pb;
LPCWSTR s1 = p, s2 = p;
const LPCWSTR end = p + 1 + (cb/sizeof(WCHAR)); // round up to next WCHAR after cb bytes
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> version = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
const long format_version = wcstol(s1, NULL, 10);
ASSERT(format_version == 3);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
if(0 == wcsnicmp(s1,L"FILTERS",s2-s1)) {
int filter_index = 1;
TRACE(trace(TEXT(">>> FILTERS\n")));
while (p < end) {
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
if(0 == wcsnicmp(s1,L"CONNECTIONS",s2-s1))
break;
GRF_Filter grf_filter;
TRACE(trace(TEXT(">>> %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
grf_filter.index = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> name .... = L\"%.*") TRACEWSTR TEXT("\"\n"), (INT) (s2 - s1), s1));
grf_filter.name = CString(s1, (int) (s2-s1));
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> class_id = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
GUID clsid = {0};
const CString clsid_str(s1, (int) (s2-s1));
hr = CLSIDFromString(clsid_str, &grf_filter.clsid);
// TODO is it possible for filter to be both source and sink?
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
const bool source_file = 0 == wcsnicmp(s1,L"SOURCE",s2-s1);
const bool sink_file = 0 == wcsnicmp(s1,L"SINK",s2-s1);
if (source_file || sink_file) {
TRACE(trace(TEXT(">>> file .... = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> file_name = L\"%.*") TRACEWSTR TEXT("\"\n"), (INT) (s2 - s1), s1));
CStringW filename = CString(s1, (int) (s2-s1));
if (source_file) {
grf_filter.source_filename = filename;
} else {
grf_filter.sink_filename = filename;
}
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
}
TRACE(trace(TEXT(">>> length .. = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
int filter_data_length = 0;
const char* filter_data = (const char*)(p + 1);
if(S_OK != (hr = skip(s1, &p, filter_data_length)))
return hr;
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
grf_filter.ipersiststream_data = CStringA(filter_data, filter_data_length);
ASSERT(filter_data_length == grf_filter.ipersiststream_data.GetLength());
grf_filters.Add(grf_filter);
}
}
if(0 == wcsnicmp(s1,L"CONNECTIONS",s2-s1)) {
TRACE(trace(TEXT(">>> CONNECTIONS\n")));
while(p < end) {
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
if(0 == wcsnicmp(s1,L"CLOCK",s2-s1))
break;
if(0 == wcsnicmp(s1,L"END",s2-s1))
break;
GRF_Connection grf_connection;
TRACE(trace(TEXT(">>> %.*") TRACEWSTR, (INT) (s2 - s1), s1));
grf_connection.output_filter_index = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(" [L\"%.*") TRACEWSTR TEXT("\"]"), (INT) (s2 - s1), s1));
grf_connection.output_pin_id = CString(s1, (int) (s2-s1));
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(" -> %.*") TRACEWSTR, (INT) (s2 - s1), s1));
grf_connection.input_filter_index = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(" [L\"%.*") TRACEWSTR TEXT("\"]\n"), (INT) (s2 - s1), s1));
grf_connection.input_pin_id = CString(s1, (int) (s2-s1));
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> sample_size ........ = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
grf_connection.flags = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> major_type ......... = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
CString guid_str(s1, (int) (s2-s1));
hr = CLSIDFromString(guid_str, &grf_connection.media_type.majortype);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> subtype ............ = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
guid_str = CString(s1, (int) (s2-s1));
hr = CLSIDFromString(guid_str, &grf_connection.media_type.subtype);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> fixed_sample_size .. = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
grf_connection.media_type.bFixedSizeSamples = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> temporal_compression = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
grf_connection.media_type.bTemporalCompression = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> length(?) .......... = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
grf_connection.media_type.lSampleSize = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> format_type ........ = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
guid_str = CString(s1, (int) (s2-s1));
hr = CLSIDFromString(guid_str, &grf_connection.media_type.formattype);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> length ............. = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
int format_length = 0;
BYTE* format_data = (BYTE *)(p + 1);
if(S_OK != (hr = skip(s1, &p, format_length)))
return hr;
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
if (format_length > 0)
grf_connection.media_type.SetFormat(format_data, format_length);
grf_connections.Add(grf_connection);
p++; /// where is this L'\0' terminator documented??
}
}
if(0 == wcsnicmp(s1,L"CLOCK",s2-s1)) {
TRACE(trace(TEXT(">>> CLOCK\n")));
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> required = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
clock_flags = wcstol(s1, NULL, 10);
p = token(p,end,&s1,&s2);
if (p >= end)
return E_NOT_SUFFICIENT_BUFFER;
TRACE(trace(TEXT(">>> clock_id = %.*") TRACEWSTR TEXT("\n"), (INT) (s2 - s1), s1));
clock_index = wcstol(s1, NULL, 10);
}
if(0 == wcsnicmp(s1,L"END",s2-s1)) {
TRACE(trace(TEXT(">>> END\n")));
}
TRACE(trace(TEXT("*** hr = ") TRACEHR_STR TEXT("\n"),TRACEHR_REF(hr)));
TRACE(trace_close());
return hr;
}
//设置关系
tagCompanionInfo * CUserInformation::InsertCompanionInfo(IClientUserItem * pIClientUserItem, BYTE cbCompanion)
{
//效验参数
ASSERT(pIClientUserItem!=NULL);
if (pIClientUserItem==NULL) return NULL;
//用户搜索
DWORD dwUserID=pIClientUserItem->GetUserID();
tagCompanionInfo * pCompanionInfo=SearchCompanionInfo(dwUserID);
//设置信息
if (pCompanionInfo==NULL)
{
//创建对象
pCompanionInfo=CreateCompanionItem();
if (pCompanionInfo==NULL) return NULL;
//设置信息
pCompanionInfo->cbCompanion=cbCompanion;
pCompanionInfo->dwGameID=pIClientUserItem->GetGameID();
pCompanionInfo->dwUserID=pIClientUserItem->GetUserID();
lstrcpyn(pCompanionInfo->szNickName,pIClientUserItem->GetNickName(),CountArray(pCompanionInfo->szNickName));
lstrcpyn(pCompanionInfo->szUserNote,pIClientUserItem->GetUserNoteInfo(),CountArray(pCompanionInfo->szUserNote));
//插入通知
if (m_pIUserCompanionSink!=NULL) m_pIUserCompanionSink->OnCompanionInsert(pCompanionInfo);
}
else
{
//修改判断
bool bModify=false;
if (pCompanionInfo->cbCompanion!=cbCompanion) bModify=true;
if ((bModify==false)&&(lstrcmp(pCompanionInfo->szNickName,pIClientUserItem->GetNickName())!=0)) bModify=true;
if ((bModify==false)&&(lstrcmp(pCompanionInfo->szUserNote,pIClientUserItem->GetUserNoteInfo())!=0)) bModify=true;
//修改判断
if (bModify=false) return pCompanionInfo;
//设置信息
pCompanionInfo->cbCompanion=cbCompanion;
pCompanionInfo->dwGameID=pIClientUserItem->GetGameID();
pCompanionInfo->dwUserID=pIClientUserItem->GetUserID();
lstrcpyn(pCompanionInfo->szNickName,pIClientUserItem->GetNickName(),CountArray(pCompanionInfo->szNickName));
lstrcpyn(pCompanionInfo->szUserNote,pIClientUserItem->GetUserNoteInfo(),CountArray(pCompanionInfo->szUserNote));
//更新通知
if (m_pIUserCompanionSink!=NULL) m_pIUserCompanionSink->OnCompanionUpdate(pCompanionInfo);
}
//变量定义
IStream * pIStreamSub=NULL;
IStorage * pIStorageSub=NULL;
IStorage * pIStorageRoot=NULL;
//写入数据
try
{
//构造名字
WCHAR szStorageName[16]=L"";
_snwprintf(szStorageName,CountArray(szStorageName),L"%ld",dwUserID);
//工作目录
TCHAR szDirectory[MAX_PATH]=TEXT("");
CWHService::GetWorkDirectory(szDirectory,CountArray(szDirectory));
//打开文件
WCHAR szInfomationFile[MAX_PATH]=L"";
_snwprintf(szInfomationFile,CountArray(szInfomationFile),L"%s\\%s",(LPCWSTR)(CT2CW(szDirectory)),INFORMATION_FILE);
//打开文件
StgOpenStorage(szInfomationFile,NULL,STGM_READWRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageRoot);
if (pIStorageRoot==NULL) StgCreateDocfile(szInfomationFile,STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE,0,&pIStorageRoot);
//错误判断
if (pIStorageRoot==NULL) throw TEXT("StgCreateDocfile Create pIStorageRoot Error");
//打开存储
pIStorageRoot->CreateStorage(szStorageName,STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageSub);
if (pIStorageSub==NULL) pIStorageRoot->CreateStorage(szStorageName,STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStorageSub);
//错误处理
if (pIStorageSub==NULL) throw TEXT("CreateStorage Create pIStorageSub Error");
//创建数据
pIStorageSub->CreateStream(STREAM_COMPANION,STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStreamSub);
if (pIStreamSub==NULL) pIStorageSub->CreateStream(STREAM_COMPANION,STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE,0,0,&pIStreamSub);
//错误处理
if (pIStreamSub==NULL) throw TEXT("CreateStream Create pIStreamSub Error");
//写入数据
ULONG cbWriteCount=0L;
pIStreamSub->Write(pCompanionInfo,sizeof(tagCompanionInfo),&cbWriteCount);
//释放接口
SafeRelease(pIStreamSub);
SafeRelease(pIStorageSub);
SafeRelease(pIStorageRoot);
return pCompanionInfo;
}
catch (...)
{
//错误断言
ASSERT(FALSE);
//释放接口
SafeRelease(pIStreamSub);
SafeRelease(pIStorageSub);
SafeRelease(pIStorageRoot);
}
return NULL;
}