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.
2839 lines
70 KiB
2839 lines
70 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved
|
|
|
|
Module Name:
|
|
|
|
wsbpstbl.cpp
|
|
|
|
Abstract:
|
|
|
|
Abstract classes that provides persistence methods.
|
|
|
|
|
|
Author:
|
|
|
|
Chuck Bardeen [cbardeen] 29-Oct-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
|
|
#include "wsbport.h"
|
|
#include "wsbpstbl.h"
|
|
#include "wsbtrak.h"
|
|
|
|
#define BYTE_SIZE 64 // Larger than largest BYTE_SIZE_*
|
|
#define PERSIST_CHECK_VALUE 0x456D5377 // ASCII: "EmSw" (Eastman Software)
|
|
|
|
// Local functions
|
|
static BOOL WsbFileExists(OLECHAR* pFileName);
|
|
|
|
|
|
// ******** CWsbPersistStream ************
|
|
|
|
#pragma optimize("g", off)
|
|
|
|
HRESULT
|
|
CWsbPersistStream::FinalConstruct(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalConstruct().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAffirmHr(CComObjectRoot::FinalConstruct());
|
|
|
|
// Initialize some member data.
|
|
m_isDirty = TRUE;
|
|
|
|
// Add class to object table
|
|
GUID guid;
|
|
if (S_OK != GetClassID(&guid)) {
|
|
guid = GUID_NULL;
|
|
}
|
|
WSB_OBJECT_ADD(guid, this);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
#pragma optimize("", on)
|
|
|
|
|
|
void
|
|
CWsbPersistStream::FinalRelease(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalRelease().
|
|
|
|
--*/
|
|
{
|
|
// Subtract class from object table
|
|
GUID guid;
|
|
if (S_OK != GetClassID(&guid)) {
|
|
guid = GUID_NULL;
|
|
}
|
|
WSB_OBJECT_SUB(guid, this);
|
|
|
|
CComObjectRoot::FinalRelease();
|
|
}
|
|
|
|
#if defined(WSB_TRACK_MEMORY)
|
|
ULONG
|
|
CWsbPersistStream::InternalAddRef(
|
|
)
|
|
{
|
|
WsbTraceIn( L"CWsbPersistStream::InternalAddRef", L"this = %p",
|
|
static_cast<void *>(this) );
|
|
|
|
ULONG retval = CComObjectRoot::InternalAddRef( );
|
|
|
|
WsbTraceOut( L"CWsbPersistStream::InternalAddRef", L"retval = %lu", retval);
|
|
return( retval );
|
|
}
|
|
|
|
ULONG
|
|
CWsbPersistStream::InternalRelease(
|
|
)
|
|
{
|
|
WsbTraceIn( L"CWsbPersistStream::InternalRelease", L"this = %p",
|
|
static_cast<void *>(this) );
|
|
|
|
ULONG retval = CComObjectRoot::InternalRelease( );
|
|
|
|
WsbTraceOut( L"CWsbPersistStream::InternalRelease", L"retval = %lu", retval);
|
|
return( retval );
|
|
}
|
|
#endif
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistStream::IsDirty(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::IsDirty().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistStream::IsDirty"), OLESTR(""));
|
|
|
|
if (m_isDirty) {
|
|
hr = S_OK;
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistStream::IsDirty"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistStream::SetIsDirty(
|
|
IN BOOL isDirty
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbPersistable::SetIsDirty().
|
|
|
|
--*/
|
|
{
|
|
WsbTraceIn(OLESTR("CWsbPersistable::SetIsDirty"), OLESTR("isDirty = <%ls>"), WsbBoolAsString(isDirty));
|
|
|
|
m_isDirty = isDirty;
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::SetIsDirty"), OLESTR(""));
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
|
|
// ******** CWsbPersistable ************
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::FinalConstruct(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalConstruct().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAffirmHr(CWsbPersistStream::FinalConstruct());
|
|
|
|
// Initialize some member data.
|
|
m_persistState = WSB_PERSIST_STATE_UNINIT;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
void
|
|
CWsbPersistable::FinalRelease(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalRelease().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CWsbPersistStream::FinalRelease();
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::GetCurFile(
|
|
OUT OLECHAR** pFileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistFile::GetCurFile().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Make sure that the string is returned into newly allocated
|
|
// memory (or not at all).
|
|
*pFileName = NULL;
|
|
|
|
try {
|
|
ULONG Size;
|
|
|
|
WsbAffirm(m_persistState != WSB_PERSIST_STATE_UNINIT, E_UNEXPECTED);
|
|
|
|
// Retrieve the actual name if one is specifed or the default name
|
|
// if one has not been specified.
|
|
WsbAffirmHr(m_persistFileName.GetSize(&Size));
|
|
if (Size > 0) {
|
|
WsbAffirmHr(WsbAllocAndCopyComString(pFileName, m_persistFileName, 0));
|
|
} else {
|
|
WsbAffirmHr(GetDefaultFileName(pFileName, 0));
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::GetDefaultFileName(
|
|
OUT OLECHAR** pFileName,
|
|
IN ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbPersistable::GetDefaultFileName().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistable::GetDefaultFileName"), OLESTR("bufferSize = <%lu>"), bufferSize);
|
|
|
|
try {
|
|
ULONG Size;
|
|
|
|
// If we haven't read the default in from the resource file, then
|
|
// do so now.
|
|
WsbAffirmHr(m_persistDefaultName.GetSize(&Size));
|
|
if (Size == 0) {
|
|
WsbAffirmHr(m_persistDefaultName.LoadFromRsc(_Module.m_hInst, IDS_WSBPERSISTABLE_DEF_FILE));
|
|
}
|
|
|
|
WsbAffirmHr(WsbAllocAndCopyComString(pFileName, m_persistDefaultName, bufferSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::GetDefaultFileName"), OLESTR("hr = <%ls>, FileName = <%ls>"), WsbHrAsString(hr), pFileName);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::Load(
|
|
IN LPCOLESTR fileName,
|
|
IN DWORD mode
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistFile::Load().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IStream> pStream;
|
|
CLSID clsid;
|
|
CLSID clsidFile;
|
|
CComPtr<IRunningObjectTable> pROT;
|
|
CComPtr<IMoniker> pMoniker;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistable::Load"), OLESTR("fileName = <%ls>, mode = <%lx>> m_persistState = <%d>"),
|
|
fileName, mode, m_persistState);
|
|
|
|
try {
|
|
CComPtr<IPersistStream> pIPersistStream;
|
|
|
|
WsbAffirm(m_persistState == WSB_PERSIST_STATE_UNINIT, E_UNEXPECTED);
|
|
WsbAffirm(fileName, E_UNEXPECTED);
|
|
|
|
// Open a storage on the file where the data is stored.
|
|
if (0 == mode) {
|
|
WsbAffirmHr(StgOpenStorageEx(fileName, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
|
|
STGFMT_STORAGE, 0, NULL, NULL, IID_IStorage, (void**)&m_persistStorage));
|
|
}
|
|
else {
|
|
WsbAffirmHr(StgOpenStorageEx(fileName, mode,
|
|
STGFMT_STORAGE, 0, NULL, NULL, IID_IStorage, (void**)&m_persistStorage));
|
|
}
|
|
|
|
// Get the IPersistStream interface.
|
|
WsbAffirmHr(((IUnknown*)(IWsbPersistable*) this)->QueryInterface(IID_IPersistStream, (void**) &pIPersistStream));
|
|
|
|
// Open a stream.
|
|
WsbAffirmHr(m_persistStorage->OpenStream(WSB_PERSIST_DEFAULT_STREAM_NAME, NULL, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
|
|
0, &pStream));
|
|
|
|
// Load the object using the IPersistStream::Load() method, checking
|
|
// to make sure the CLSID is correct.
|
|
WsbAffirmHr(pIPersistStream->GetClassID(&clsid));
|
|
WsbAffirmHr(ReadClassStm(pStream, &clsidFile));
|
|
WsbAffirm(clsid == clsidFile, WSB_E_STREAM_ERROR);
|
|
|
|
WsbAffirmHr(pIPersistStream->Load(pStream));
|
|
|
|
// Check that we got everything by reading a special ULONG
|
|
// that should be at the end
|
|
ULONG check_value;
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &check_value));
|
|
WsbAffirm(check_value == PERSIST_CHECK_VALUE, WSB_E_PERSISTENCE_FILE_CORRUPT);
|
|
|
|
// We are now in the normal state.
|
|
m_persistFileName = fileName;
|
|
m_persistState = WSB_PERSIST_STATE_NORMAL;
|
|
|
|
m_persistStream = pStream;
|
|
|
|
} WsbCatchAndDo(hr,
|
|
//
|
|
// Set the storage pointer to null on an error to make sure the file is closed.
|
|
//
|
|
m_persistStorage = NULL;
|
|
|
|
);
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::ReleaseFile(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbPersistable::ReleaseFile().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistable::ReleaseFile"), OLESTR(""));
|
|
|
|
try {
|
|
WsbAffirm(m_persistState != WSB_PERSIST_STATE_UNINIT, E_UNEXPECTED);
|
|
|
|
// Try to make sure changes are committed
|
|
if (m_persistStream) {
|
|
m_persistStream->Commit(STGC_DEFAULT);
|
|
}
|
|
if (m_persistStorage) {
|
|
m_persistStorage->Commit(STGC_DEFAULT);
|
|
}
|
|
|
|
// Release the resources that we have been holding open.
|
|
m_persistStream = NULL;
|
|
m_persistStorage = NULL;
|
|
m_persistFileName.Free();
|
|
|
|
m_persistState = WSB_PERSIST_STATE_RELEASED;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::ReleaseFile"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT CWsbPersistable::Save(
|
|
IN LPCOLESTR fileName,
|
|
IN BOOL remember
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistFile::Save().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
OLECHAR* name;
|
|
BOOL create = FALSE;
|
|
CComPtr<IStream> pStream;
|
|
CLSID clsid;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistable::Save"), OLESTR("fileName = <%ls>, remember = <%ls>"), WsbPtrToStringAsString((OLECHAR**) &fileName), WsbBoolAsString(remember));
|
|
|
|
try {
|
|
CComPtr<IPersistStream> pIPersistStream;
|
|
|
|
// Make sure that we are in the right state.
|
|
WsbAffirm(((m_persistState == WSB_PERSIST_STATE_UNINIT) ||
|
|
(m_persistState == WSB_PERSIST_STATE_NORMAL) ||
|
|
(m_persistState == WSB_PERSIST_STATE_RELEASED)),
|
|
E_UNEXPECTED);
|
|
|
|
WsbAssert((m_persistState == WSB_PERSIST_STATE_NORMAL) || (0 != fileName), E_POINTER);
|
|
|
|
// If they supplied a name use it,
|
|
if ((m_persistState == WSB_PERSIST_STATE_UNINIT) ||
|
|
(m_persistState == WSB_PERSIST_STATE_RELEASED)) {
|
|
|
|
// We need to create a new file based on the name
|
|
// that they gave us.
|
|
name = (OLECHAR*) fileName;
|
|
create = TRUE;
|
|
} else {
|
|
|
|
// If they gave a name and it is different than what we have
|
|
// stored, then we need to create a new file.
|
|
if ((0 != fileName) && (_wcsicmp(m_persistFileName, fileName) != 0)) {
|
|
name = (OLECHAR*) fileName;
|
|
create = TRUE;
|
|
}
|
|
|
|
// Otherwise, use the stored name.
|
|
else {
|
|
name = m_persistFileName;
|
|
}
|
|
}
|
|
|
|
// We should now have a file name and know whether to open or
|
|
// create a file.
|
|
if (create) {
|
|
WsbAffirmHr(StgCreateStorageEx(name, STGM_DIRECT | STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
|
|
STGFMT_STORAGE, 0, NULL, NULL, IID_IStorage, (void**)&m_persistStorage));
|
|
WsbAffirmHr(m_persistStorage->CreateStream(WSB_PERSIST_DEFAULT_STREAM_NAME, STGM_DIRECT | STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE,
|
|
0, 0, &pStream));
|
|
} else {
|
|
LARGE_INTEGER llOffset;
|
|
|
|
pStream = m_persistStream;
|
|
|
|
llOffset.QuadPart = 0;
|
|
WsbAffirmHr(pStream->Seek(llOffset, STREAM_SEEK_SET, NULL));
|
|
}
|
|
|
|
// Get the IPersistStream interface.
|
|
WsbAffirmHr(((IUnknown*)(IWsbPersistable*) this)->QueryInterface(IID_IPersistStream, (void**) &pIPersistStream));
|
|
|
|
// Write out the class id, and then Save the data using IPersistStream method.
|
|
WsbAffirmHr(pIPersistStream->GetClassID(&clsid));
|
|
WsbAffirmHr(WriteClassStm(pStream, clsid));
|
|
WsbAffirmHr(pIPersistStream->Save(pStream, remember));
|
|
|
|
// Put a special ULONG value at the end as a check during load
|
|
ULONG check_value = PERSIST_CHECK_VALUE;
|
|
WsbAffirmHr(WsbSaveToStream(pStream, check_value));
|
|
//
|
|
// Commit the stream right now, as ReleaseFile will not commit it
|
|
// if we close the stream
|
|
//
|
|
WsbAffirmHr(pStream->Commit(STGC_DEFAULT));
|
|
|
|
// Should we remember the file that was specified as the new
|
|
// current file?
|
|
if (remember) {
|
|
m_persistState = WSB_PERSIST_STATE_NOSCRIBBLE;
|
|
|
|
// If we created a new file, then remember it's name.
|
|
if (create) {
|
|
m_persistFileName = fileName;
|
|
}
|
|
|
|
// We need to make sure that we don't have anything open on this
|
|
// file.
|
|
m_persistStream = NULL;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::SaveCompleted(
|
|
IN LPCOLESTR fileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistFile::SaveCompleted().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IStream> pStream;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistable::SaveCompleted"), OLESTR("fileName = <%ls>"), fileName);
|
|
|
|
try {
|
|
|
|
// Are we doing any other kind of persistance, are we doing storage
|
|
// persistence, but are in the wrong state, or are the parameters
|
|
// wrong.
|
|
WsbAffirm(m_persistState == WSB_PERSIST_STATE_NOSCRIBBLE, E_UNEXPECTED);
|
|
|
|
// Save off the name that was given to us, and only another save to
|
|
// begin.
|
|
if (fileName != NULL) {
|
|
m_persistFileName = fileName;
|
|
}
|
|
|
|
// Open a storage to the file where the data is stored.
|
|
WsbAffirmHr(StgOpenStorageEx(m_persistFileName, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
|
|
STGFMT_STORAGE, 0, NULL, NULL, IID_IStorage, (void**)&m_persistStorage));
|
|
|
|
// Open a stream.
|
|
WsbAffirmHr(m_persistStorage->OpenStream(WSB_PERSIST_DEFAULT_STREAM_NAME, NULL, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStream));
|
|
|
|
// Save it all off.
|
|
m_persistState = WSB_PERSIST_STATE_NORMAL;
|
|
|
|
m_persistStream = pStream;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::SaveCompleted"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
CWsbPersistable::SetDefaultFileName(
|
|
IN OLECHAR* fileName
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbPersistable::SetDefaultFileName().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CWsbPersistable::SetDefaultFileName"), OLESTR("fileName = <%ls>"), fileName);
|
|
|
|
m_persistDefaultName = fileName;
|
|
|
|
WsbTraceOut(OLESTR("CWsbPersistable::SetDefaultFileName"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
|
|
// Standard Type Helper Functions
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT BOOL* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a BOOL value from the specified stream and sets
|
|
pValue to value of the BOOL.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a BOOL that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(BOOL)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(BOOL)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToBoolAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT LONG* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a LONG value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a LONG that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(LONG)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(LONG)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToLongAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT GUID* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a GUID value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a GUID that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(GUID)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(GUID)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToGuidAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT SHORT* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a SHORT value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a SHORT that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(SHORT)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(SHORT)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT BYTE* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a BYTE value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a BYTE that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(BYTE)"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) pValue, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(BYTE)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToByteAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT UCHAR* pValue,
|
|
IN ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a UCHAR array value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a BYTE that will be set to the value.
|
|
|
|
bufferSize - number of bytes to load
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(UCHAR)"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = bufferSize;
|
|
WsbAffirmHr(pStream->Read((void*) pValue, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(UCHAR)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT OLECHAR** pValue,
|
|
IN ULONG ulBufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a STRING value from the specified stream and sets
|
|
pValue to the string.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the string will be read.
|
|
|
|
pValue - A pointer to a STRING that will be set to the string
|
|
read in..
|
|
|
|
ulBufferSize - Size of buffer pValue points to or zero allow
|
|
alloc/realloc of the buffer.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(STRING)"), OLESTR(""));
|
|
|
|
try {
|
|
ULONG nchar;
|
|
OLECHAR *pc;
|
|
ULONG size;
|
|
USHORT wc;
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
WsbAssert(sizeof(OLECHAR) == sizeof(USHORT), E_UNEXPECTED);
|
|
|
|
// Get the length of the string (in bytes).
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &size));
|
|
|
|
if (size != 0) {
|
|
// Allocate a buffer to hold the string.
|
|
WsbAffirmHr(WsbGetComBuffer(pValue, ulBufferSize, size, NULL));
|
|
pc = *pValue;
|
|
|
|
// Now read in the proper number of wide chars.
|
|
nchar = size / sizeof(USHORT);
|
|
for (ULONG i = 0; i < nchar; i++) {
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &wc));
|
|
*pc++ = wc;
|
|
}
|
|
} else {
|
|
// Allocate a buffer to hold the string.
|
|
WsbAffirmHr(WsbGetComBuffer(pValue, ulBufferSize, sizeof(OLECHAR), NULL));
|
|
*(*pValue) = 0;
|
|
}
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(STRING)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToStringAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT ULONG* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a ULONG value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a ULONG that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(ULONG)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(ULONG)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToUlongAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT USHORT* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a USHORT value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a USHORT that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(USHORT)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(USHORT)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToUshortAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT LONGLONG* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a LONGLONG value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a LONGLONG that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(LONGLONG)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(LONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT ULONGLONG* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a ULONGLONG value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a ULONGLONG that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(ULONGLONG)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(ULONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT DATE* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a DATE value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a DATE that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(DATE)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
// WsbTraceOut(OLESTR("WsbLoadFromStream(DATE)"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToLongAsString(pValue));
|
|
|
|
// Modify next statement after WsbDate functions written to be like the one above.
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(DATE)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT FILETIME* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a FILETIME value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a FILETIME that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(FILETIME)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(FILETIME)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbLoadFromStream(
|
|
IN IStream* pStream,
|
|
OUT ULARGE_INTEGER* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a ULARGE_INTEGER value from the specified stream and sets
|
|
pValue to the value.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the value will be read.
|
|
|
|
pValue - A pointer to a ULARGE_INTEGER that will be set to the value.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbLoadFromStream(ULARGE_INTEGER)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
|
|
size = WsbByteSize(*pValue);
|
|
WsbAffirmHr(pStream->Read((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
WsbAffirmHr(WsbConvertFromBytes(bytes, pValue, &size));
|
|
WsbAffirm(size == ulBytes, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbLoadFromStream(ULARGE_INTEGER)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IN IStream* pStream,
|
|
IN BOOL value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a BOOL value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the BOOL to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(BOOL)"), OLESTR("value = <%ls>"), WsbBoolAsString(value));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(BOOL)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IN IStream* pStream,
|
|
IN GUID value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a GUID value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the GUID to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(GUID)"), OLESTR("value = <%ls>"), WsbGuidAsString(value));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(GUID)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
LONG value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a LONG value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the LONG to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(LONG)"), OLESTR("value = <%ld>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(LONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
SHORT value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a SHORT value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the SHORT to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(SHORT)"), OLESTR("value = <%ld>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(SHORT)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
BYTE value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a BYTE value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the BYTE to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(BYTE)"), OLESTR("value = <%ld>"), value);
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
size = WsbByteSize(value);
|
|
WsbAffirmHr(pStream->Write((void*) &value, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(BYTE)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
UCHAR* value,
|
|
ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a UCHAR array to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The pointer to value of the UCHAR array to be written.
|
|
|
|
bufferSize - Size of array to save (in bytes).
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(UCHAR)"), OLESTR("value = <%ld>"), value);
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
// WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
|
|
size = bufferSize;
|
|
WsbAffirmHr(pStream->Write((void*) value, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(UCHAR)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IN IStream* pStream,
|
|
IN OLECHAR* value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a OLECHAR string to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the string will be written.
|
|
|
|
value - The string to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or value was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(STRING)"), OLESTR("value = <%ls>"), WsbPtrToStringAsString(&value));
|
|
|
|
try {
|
|
ULONG nchar;
|
|
OLECHAR *pc;
|
|
ULONG size;
|
|
USHORT wc;
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
// WsbAssert(0 != value, E_POINTER);
|
|
WsbAssert(sizeof(OLECHAR) == sizeof(USHORT), E_UNEXPECTED);
|
|
|
|
// Save the length of the string (in bytes).
|
|
if (value) {
|
|
nchar = wcslen(value) + 1;
|
|
} else {
|
|
nchar = 0;
|
|
}
|
|
size = nchar * sizeof(USHORT);
|
|
WsbAffirmHr(WsbSaveToStream(pStream, size));
|
|
|
|
// Now write out the proper number of wide chars
|
|
pc = value;
|
|
for (ULONG i = 0; i < nchar; i++) {
|
|
wc = *pc++;
|
|
WsbAffirmHr(WsbSaveToStream(pStream, wc));
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(STRING)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
ULONG value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a ULONG value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the ULONG to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(ULONG)"), OLESTR("value = <%ld>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(ULONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
USHORT value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a USHORT value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the USHORT to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(USHORT)"), OLESTR("value = <%ld>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(USHORT)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
LONGLONG value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a LONGLONG value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the LONGLONG to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(LONGLONG)"), OLESTR("value = <%l64x>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(LONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
ULONGLONG value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a ULONGLONG value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the ULONGLONG to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(ULONGLONG)"), OLESTR("value = <%l64x>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(ULONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
DATE value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a DATE value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the DATE to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
// Modify next statement to return date after WsbDate functions written.
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(DATE)"), OLESTR("value = <%f>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(DATE)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
FILETIME value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a FILETIME value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the FILETIME to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(FILETIME)"), OLESTR(""));
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(FILETIME)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbBstrFromStream(
|
|
IN IStream* pStream,
|
|
OUT BSTR* pValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads a BSTR value from the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream from which the BSTR will be read.
|
|
|
|
pValue - A pointer to a BSTR. If *pValue is NULL, this
|
|
function will allocate the BSTR; if it already
|
|
points to a BSTR that is too short, the BSTR
|
|
will be reallocated.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - Either pStream or pValue were NULL.
|
|
E_... - Anything returned by IStream::Read.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("WsbBstrFromStream"), OLESTR(""));
|
|
|
|
try {
|
|
ULONG bchar;
|
|
ULONG nchar;
|
|
OLECHAR *pc;
|
|
ULONG size;
|
|
USHORT wc;
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != pValue, E_POINTER);
|
|
WsbAssert(sizeof(OLECHAR) == sizeof(USHORT), E_UNEXPECTED);
|
|
|
|
// Get the length of the string (in bytes).
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &size));
|
|
|
|
// (Re)allocate a buffer to hold the string.
|
|
nchar = size / sizeof(USHORT);
|
|
bchar = nchar - 1;
|
|
if (*pValue) {
|
|
if (bchar != SysStringLen(*pValue)) {
|
|
WsbAffirm(WsbReallocStringLen(pValue, NULL, bchar),
|
|
WSB_E_RESOURCE_UNAVAILABLE);
|
|
}
|
|
} else {
|
|
*pValue = WsbAllocStringLen(NULL, bchar);
|
|
WsbAffirm(*pValue, WSB_E_RESOURCE_UNAVAILABLE);
|
|
}
|
|
|
|
// Now read in the proper number of wide chars.
|
|
pc = *pValue;
|
|
for (ULONG i = 0; i < nchar; i++) {
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &wc));
|
|
*pc++ = wc;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbBstrFromStream"), OLESTR("hr = <%ls>, value = <%ls>"), WsbHrAsString(hr), WsbPtrToStringAsString(pValue));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbBstrToStream(
|
|
IN IStream* pStream,
|
|
IN BSTR value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a BSTR to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the BSTR will be written.
|
|
|
|
value - The BSTR to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("WsbBstrToStream"), OLESTR("value = <%ls>"), WsbPtrToStringAsString(&value));
|
|
|
|
try {
|
|
ULONG nchar;
|
|
OLECHAR *pc;
|
|
ULONG size;
|
|
USHORT wc;
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
WsbAssert(0 != value, E_POINTER);
|
|
WsbAssert(sizeof(OLECHAR) == sizeof(USHORT), E_UNEXPECTED);
|
|
|
|
// Save the length of the string (in bytes).
|
|
nchar = SysStringLen(value) + 1;
|
|
size = nchar * sizeof(USHORT);
|
|
WsbAffirmHr(WsbSaveToStream(pStream, size));
|
|
|
|
// Now write out the proper number of wide chars
|
|
pc = value;
|
|
for (ULONG i = 0; i < nchar; i++) {
|
|
wc = *pc++;
|
|
WsbAffirmHr(WsbSaveToStream(pStream, wc));
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbBstrToStream"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSaveToStream(
|
|
IStream* pStream,
|
|
ULARGE_INTEGER value
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves a ULARGE_INTEGER value to the specified stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
value - The value of the ULARGE_INTEER to be written.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_POINTER - pStream was NULL.
|
|
E_... - Anything returned by IStream::Write.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG size;
|
|
ULONG ulBytes;
|
|
|
|
WsbTraceIn(OLESTR("WsbSaveToStream(ULARGE_INTEGER)"), OLESTR("value = <%l64x>"), value);
|
|
|
|
try {
|
|
UCHAR bytes[BYTE_SIZE];
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(WsbConvertToBytes(bytes, value, &size));
|
|
WsbAffirmHr(pStream->Write((void*) bytes, size, &ulBytes));
|
|
WsbAffirm(ulBytes == size, WSB_E_STREAM_ERROR);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("WsbSaveToStream(ULARGE_INTEGER)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
static HRESULT
|
|
WsbMakeBackupName(
|
|
OLECHAR* pSaveName,
|
|
OLECHAR* pExtension,
|
|
OLECHAR** ppBackupName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a Save file name to a backup file name.
|
|
|
|
Arguments:
|
|
|
|
pSaveName - Orginal file name.
|
|
|
|
pExtension - The file extension to substitute.
|
|
|
|
ppBackupName - Pointer to pointer to new backup file name.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_... - Some error.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
size_t len;
|
|
CWsbStringPtr NewName;
|
|
OLECHAR* pC;
|
|
|
|
// It sure would be nice to have a general function for parsing
|
|
// file names!
|
|
|
|
// Find the file extension (if any)
|
|
NewName = pSaveName;
|
|
if (NewName == NULL) {
|
|
WsbThrow(E_OUTOFMEMORY);
|
|
}
|
|
len = wcslen(NewName);
|
|
pC = wcsrchr(NewName, OLECHAR('.'));
|
|
if (pC && (size_t)((pC - (OLECHAR*)NewName) + 4) >= len) {
|
|
*pC = 0;
|
|
}
|
|
|
|
// Put on new file extension
|
|
NewName.Append(pExtension);
|
|
|
|
// Give the buffer to the output parameter
|
|
NewName.GiveTo(ppBackupName);
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbPrintfToStream(
|
|
IStream* pStream,
|
|
OLECHAR* fmtString,
|
|
...
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Print printf-style format string and arguments to a stream.
|
|
|
|
Arguments:
|
|
|
|
pStream - The stream to which the value will be written.
|
|
|
|
fmtString - A printf style string indicating the number of
|
|
arguments and how they should be formatted.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
ULONG bytesWritten;
|
|
ULONG nBytes;
|
|
ULONG nChars=0;
|
|
CWsbStringPtr tmpString;
|
|
va_list vaList;
|
|
|
|
va_start(vaList, fmtString);
|
|
WsbAffirmHr(tmpString.VPrintf(fmtString, vaList));
|
|
va_end(vaList);
|
|
WsbAffirmHr(tmpString.GetLen(&nChars));
|
|
nBytes = nChars * sizeof(WCHAR);
|
|
if (0 < nBytes) {
|
|
WsbAffirmHr(pStream->Write(static_cast<WCHAR *>(tmpString),
|
|
nBytes, &bytesWritten));
|
|
WsbAffirm(bytesWritten == nBytes, E_FAIL);
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
WsbSafeCreate(
|
|
OLECHAR* pFileName,
|
|
IPersistFile* pIPFile
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
Makes sure there are no database files found and then creates the database files.
|
|
|
|
Arguments:
|
|
|
|
pFileName - Name of the file containing the persisted data
|
|
pIPFile - Pointer to the objects IPersistFile interface.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
WSB_E_DATABASE_ALREADY_EXISTS - The databases already exist and cannot be created.
|
|
E_... - Some other error.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
OLECHAR* pBackupName = NULL;
|
|
OLECHAR* pNewName = NULL;
|
|
|
|
|
|
WsbTraceIn(OLESTR("WsbSafeCreate"), OLESTR("<%ls>"), pFileName);
|
|
|
|
try {
|
|
CComPtr<IWsbPersistable> pIWsbPersist;
|
|
BOOL fileThere = FALSE;
|
|
|
|
// Save the file name passed as the default file name
|
|
WsbAffirmHr(pIPFile->QueryInterface(IID_IWsbPersistable,
|
|
(void**)&pIWsbPersist));
|
|
WsbAffirmHr(pIWsbPersist->SetDefaultFileName(pFileName));
|
|
|
|
//
|
|
// Check to see if the file exists. If so, life is BAD.
|
|
// If not, then see if the new or backup files exist
|
|
// and use them
|
|
//
|
|
// Make sure the Save file exists
|
|
if (!WsbFileExists(pFileName)) {
|
|
//
|
|
// The file doesn't exist. See if the new copy is there
|
|
//
|
|
// Create name for new (temporary) file
|
|
//
|
|
WsbAffirmHr(WsbMakeBackupName(pFileName, OLESTR(".new"), &pNewName));
|
|
|
|
// See if the new file exists
|
|
if (!WsbFileExists(pNewName)) {
|
|
//
|
|
// Don't have the new file, look for the backup file
|
|
//
|
|
WsbAffirmHr(WsbMakeBackupName(pFileName, OLESTR(".bak"), &pBackupName));
|
|
if (WsbFileExists(pBackupName)) {
|
|
//
|
|
// Backup is there - complain
|
|
//
|
|
hr = WSB_E_DATABASE_ALREADY_EXISTS;
|
|
}
|
|
} else {
|
|
//
|
|
// New is there - complain
|
|
//
|
|
hr = WSB_E_DATABASE_ALREADY_EXISTS;
|
|
}
|
|
} else {
|
|
//
|
|
// The file exists so complain
|
|
//
|
|
hr = WSB_E_DATABASE_ALREADY_EXISTS;
|
|
WsbThrow( hr );
|
|
}
|
|
|
|
//
|
|
// If we haven't thrown then it is OK to create the files
|
|
//
|
|
hr = pIPFile->Save( pFileName, TRUE);
|
|
if (!SUCCEEDED(hr)) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFECREATE_SAVE_FAILED, 0, NULL, pFileName, NULL);
|
|
WsbThrow(hr);
|
|
}
|
|
|
|
// Release the file
|
|
WsbAffirmHr(pIWsbPersist->ReleaseFile());
|
|
|
|
} WsbCatch(hr);
|
|
|
|
if (pBackupName) {
|
|
WsbFree(pBackupName);
|
|
}
|
|
if (pNewName) {
|
|
WsbFree(pNewName);
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("WsbSafeCreate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT
|
|
WsbSafeLoad(
|
|
OLECHAR* pFileName,
|
|
IPersistFile* pIPFile,
|
|
BOOL UseBackup
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
Loads data from the specified file name. Works in conjunction with WsbSafeSave
|
|
to best recover from disaster situations.
|
|
|
|
Arguments:
|
|
|
|
pFileName - Name of the file containing the persisted data
|
|
pIPFile - Pointer to the objects IPersistFile interface.
|
|
UseBackup - Load data from backup file instead of normal file
|
|
NOTE: (this is not used anymore)
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
WSB_E_NOTFOUND - The databases could not be found
|
|
E_... - Some other error.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
OLECHAR* pBackupName = NULL;
|
|
OLECHAR* pLoadName = NULL;
|
|
BOOL usingBackup = FALSE;
|
|
BOOL TracePersistence = FALSE;
|
|
|
|
UNREFERENCED_PARAMETER(UseBackup);
|
|
|
|
// Turn tracing off during save if it's not wanted
|
|
if (g_pWsbTrace) {
|
|
g_pWsbTrace->GetTraceSetting(WSB_TRACE_BIT_PERSISTENCE, &TracePersistence);
|
|
}
|
|
if (!TracePersistence) {
|
|
WsbTraceThreadOff();
|
|
}
|
|
WsbTraceIn(OLESTR("WsbSafeLoad"), OLESTR("File = <%ls>, UseBackup = %ls"),
|
|
pFileName, WsbBoolAsString(UseBackup));
|
|
|
|
try {
|
|
HRESULT hrLoad;
|
|
BOOL fileThere = FALSE;
|
|
CComPtr<IWsbPersistable> pIWsbPersist;
|
|
|
|
// Save the file name passed as the default file name
|
|
WsbAffirmHr(pIPFile->QueryInterface(IID_IWsbPersistable,
|
|
(void**)&pIWsbPersist));
|
|
WsbAffirmHr(pIWsbPersist->SetDefaultFileName(pFileName));
|
|
|
|
//
|
|
// Create the backup file name
|
|
//
|
|
WsbAffirmHr(WsbMakeBackupName(pFileName, OLESTR(".bak"), &pBackupName));
|
|
|
|
//
|
|
// Check if the .col exists
|
|
//
|
|
if (WsbFileExists(pFileName)) {
|
|
//
|
|
// The file exists. Use it
|
|
//
|
|
fileThere = TRUE;
|
|
pLoadName = pFileName;
|
|
} else {
|
|
//
|
|
// Look for the backup file
|
|
//
|
|
WsbTrace(OLESTR("WsbSafeLoad: trying .bak\n"));
|
|
if (WsbFileExists(pBackupName)) {
|
|
//
|
|
// Use the backup file
|
|
//
|
|
// WsbLogEvent(WSB_MESSAGE_SAFELOAD_USING_BACKUP, 0, NULL, pFileName, NULL);
|
|
pLoadName = pBackupName;
|
|
fileThere = TRUE;
|
|
usingBackup= TRUE;
|
|
}
|
|
}
|
|
|
|
WsbAffirm(fileThere, WSB_E_NOTFOUND);
|
|
//
|
|
// The file exists so try to load from it
|
|
//
|
|
hr = pIPFile->Load(pLoadName, 0);
|
|
|
|
if (SUCCEEDED(hr)) {
|
|
//
|
|
// Load succeeded, release the file
|
|
//
|
|
WsbAffirmHr(pIWsbPersist->ReleaseFile());
|
|
//
|
|
// TO BE DONE: check if .bak file is out of date
|
|
// and update it if so..
|
|
//
|
|
} else if (!usingBackup) {
|
|
WsbTrace(OLESTR("WsbSafeLoad: trying .bak\n"));
|
|
if (WsbFileExists(pBackupName)) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFELOAD_USING_BACKUP, 0, NULL, pLoadName, WsbHrAsString(hr));
|
|
//
|
|
// Use the backup file
|
|
//
|
|
hrLoad = pIPFile->Load(pBackupName, 0);
|
|
if (SUCCEEDED(hrLoad)) {
|
|
// Load succeeded, release the file
|
|
WsbAffirmHr(pIWsbPersist->ReleaseFile());
|
|
//
|
|
// Now save the changes to the .col file to keep it in sync
|
|
//
|
|
hr = pIPFile->Save(pFileName, FALSE);
|
|
|
|
if (!SUCCEEDED(hr)) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFESAVE_RECOVERY_CANT_SAVE, 0, NULL, pFileName, WsbHrAsString(hr), NULL);
|
|
WsbThrow(hr);
|
|
}
|
|
//
|
|
// Commit and release .col file
|
|
//
|
|
WsbAffirmHr(pIWsbPersist->ReleaseFile());
|
|
|
|
} else {
|
|
WsbLogEvent(WSB_MESSAGE_SAFELOAD_RECOVERY_FAILED, 0, NULL, pFileName, WsbHrAsString(hrLoad), NULL);
|
|
WsbThrow(hrLoad);
|
|
}
|
|
} else {
|
|
WsbLogEvent(WSB_MESSAGE_SAFELOAD_RECOVERY_FAILED, 0, NULL, pFileName, NULL);
|
|
}
|
|
} else {
|
|
WsbLogEvent(WSB_MESSAGE_SAFELOAD_RECOVERY_FAILED, 0, NULL, pFileName, WsbHrAsString(hr));
|
|
}
|
|
} WsbCatch(hr);
|
|
|
|
if (pBackupName) {
|
|
WsbFree(pBackupName);
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("WsbSafeLoad"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
// Restore tracing if we turned it off
|
|
if (!TracePersistence) {
|
|
WsbTraceThreadOn();
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT
|
|
WsbSafeSave(
|
|
IPersistFile* pIPFile
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Saves the object to a backup file and then replaces the objects Save file
|
|
with the backup file. Use with WsbSafeLoad
|
|
|
|
Arguments:
|
|
|
|
pIPFile - Pointer to the objects IPersistFile interface.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
E_... - Some error.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
OLECHAR* pBackupName = NULL;
|
|
OLECHAR* pFileName = NULL;
|
|
BOOL TracePersistence = FALSE;
|
|
DWORD file_attrs;
|
|
|
|
// Turn tracing off during save if it's not wanted
|
|
if (g_pWsbTrace) {
|
|
g_pWsbTrace->GetTraceSetting(WSB_TRACE_BIT_PERSISTENCE, &TracePersistence);
|
|
}
|
|
if (!TracePersistence) {
|
|
WsbTraceThreadOff();
|
|
}
|
|
WsbTraceIn(OLESTR("WsbSafeSave"), OLESTR(""));
|
|
|
|
try {
|
|
CComPtr<IWsbPersistable> pIWsbPersist;
|
|
|
|
// Get the current Save file name
|
|
WsbAffirmHr(pIPFile->GetCurFile(&pFileName));
|
|
WsbTrace(OLESTR("WsbSafeSave: filename = <%ls>\n"), pFileName);
|
|
|
|
// Create name for backup file
|
|
WsbAffirmHr(WsbMakeBackupName(pFileName, OLESTR(".bak"), &pBackupName));
|
|
|
|
|
|
// Make sure we have write access to the save file if it exists!
|
|
if (WsbFileExists(pFileName)) {
|
|
file_attrs = GetFileAttributes(pFileName);
|
|
if (file_attrs & FILE_ATTRIBUTE_READONLY) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFESAVE_RECOVERY_CANT_ACCESS, 0, NULL, pFileName, NULL);
|
|
WsbThrow(E_FAIL);
|
|
}
|
|
}
|
|
|
|
// Save data to save file
|
|
hr = pIPFile->Save(pFileName, FALSE);
|
|
if (!SUCCEEDED(hr)) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFESAVE_RECOVERY_CANT_SAVE, 0, NULL, pFileName, WsbHrAsString(hr), NULL);
|
|
WsbThrow(hr);
|
|
}
|
|
// Commit and release the save file
|
|
WsbAffirmHr(pIPFile->QueryInterface(IID_IWsbPersistable,
|
|
(void**)&pIWsbPersist));
|
|
WsbAffirmHr(pIWsbPersist->ReleaseFile());
|
|
|
|
// Save data to .bak file
|
|
// Make sure we have write access to the save file if it exists!
|
|
if (WsbFileExists(pBackupName)) {
|
|
file_attrs = GetFileAttributes(pBackupName);
|
|
if (file_attrs & FILE_ATTRIBUTE_READONLY) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFESAVE_RECOVERY_CANT_ACCESS, 0, NULL, pBackupName, NULL);
|
|
WsbThrow(E_FAIL);
|
|
}
|
|
}
|
|
hr = pIPFile->Save(pBackupName, FALSE);
|
|
if (!SUCCEEDED(hr)) {
|
|
WsbLogEvent(WSB_MESSAGE_SAFESAVE_RECOVERY_CANT_SAVE, 0, NULL, pBackupName, WsbHrAsString(hr), NULL);
|
|
WsbThrow(hr);
|
|
}
|
|
// Commit and release the .bak file
|
|
WsbAffirmHr(pIWsbPersist->ReleaseFile());
|
|
} WsbCatch(hr);
|
|
|
|
if (pFileName) {
|
|
WsbFree(pFileName);
|
|
}
|
|
if (pBackupName) {
|
|
WsbFree(pBackupName);
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("WsbSafeSave"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
// Restore tracing if we turned it off
|
|
if (!TracePersistence) {
|
|
WsbTraceThreadOn();
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT WsbStreamToFile(
|
|
HANDLE hFile,
|
|
IStream* pStream,
|
|
BOOL AddCR
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies text from a stream (which must have been created with CreateStreamOnHGlobal)
|
|
to an open file (opened via CreateFile). The text is assumed to be wide characters
|
|
with no embedded wide-character nulls. The text is converted to multibyte characters
|
|
for output to the file.
|
|
|
|
After the text is copied, the stream position is reset to the beggining.
|
|
|
|
Arguments:
|
|
|
|
hFile - Handle of output file.
|
|
|
|
pStream - Pointer to an IStream interface.
|
|
|
|
AddCR - Convert LF to CR-LF if TRUE.
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
const int safe_size = 1024;
|
|
static char buf[safe_size + 16];
|
|
static char CRLF[3] = "\r\n";
|
|
|
|
HGLOBAL hMem = 0; // Mem block for stream
|
|
WCHAR* addr = NULL;
|
|
|
|
try {
|
|
WCHAR big_eof = 0;
|
|
BOOL doCRLF = FALSE;
|
|
DWORD err;
|
|
DWORD nbytes;
|
|
int nchars_todo;
|
|
int nchars_remaining;
|
|
LARGE_INTEGER seek_pos_zero;
|
|
|
|
// Make sure the text ends with a null
|
|
WsbAffirmHr(pStream->Write(&big_eof, sizeof(WCHAR), NULL));
|
|
|
|
// Get the address of the memory block for the stream
|
|
WsbAffirmHr(GetHGlobalFromStream(pStream, &hMem));
|
|
addr = static_cast<WCHAR *>(GlobalLock(hMem));
|
|
WsbAffirm(addr, E_HANDLE);
|
|
|
|
// Get the total number of chars. in the string
|
|
nchars_remaining = wcslen(addr);
|
|
|
|
// Loop until all chars. are written
|
|
while (nchars_remaining) {
|
|
DWORD bytesWritten;
|
|
|
|
if (nchars_remaining * sizeof(WCHAR) > safe_size) {
|
|
nchars_todo = safe_size / sizeof(WCHAR);
|
|
} else {
|
|
nchars_todo = nchars_remaining;
|
|
}
|
|
|
|
// Stop at LineFeed if we need to convert to CR-LF
|
|
if (AddCR) {
|
|
int lf_todo;
|
|
WCHAR* pLF;
|
|
|
|
pLF = wcschr(addr, WCHAR('\n'));
|
|
if (pLF) {
|
|
lf_todo = (int)(pLF - addr);
|
|
if (lf_todo < nchars_todo) {
|
|
nchars_todo = lf_todo;
|
|
doCRLF = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Output everything up to LF
|
|
if (0 < nchars_todo) {
|
|
nbytes = WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, addr, nchars_todo, buf,
|
|
safe_size, NULL, NULL);
|
|
if (0 == nbytes) {
|
|
DWORD dwErr = GetLastError();
|
|
hr = HRESULT_FROM_WIN32(dwErr);
|
|
WsbAffirmHr(hr);
|
|
}
|
|
|
|
if (!WriteFile(hFile, buf, nbytes, &bytesWritten, NULL)) {
|
|
err = GetLastError();
|
|
WsbThrow(HRESULT_FROM_WIN32(err));
|
|
}
|
|
WsbAffirm(bytesWritten == nbytes, E_FAIL);
|
|
}
|
|
|
|
// Output CR-LF in place of LF if needed
|
|
if (doCRLF) {
|
|
if (!WriteFile(hFile, CRLF, 2, &bytesWritten, NULL)) {
|
|
err = GetLastError();
|
|
WsbThrow(HRESULT_FROM_WIN32(err));
|
|
}
|
|
WsbAffirm(bytesWritten == 2, E_FAIL);
|
|
nchars_todo++;
|
|
doCRLF = FALSE;
|
|
}
|
|
nchars_remaining -= nchars_todo;
|
|
addr += nchars_todo;
|
|
}
|
|
|
|
seek_pos_zero.QuadPart = 0;
|
|
WsbAffirmHr(pStream->Seek(seek_pos_zero, STREAM_SEEK_SET, NULL));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
if (addr != NULL) {
|
|
GlobalUnlock(hMem);
|
|
addr = NULL;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
// WsbFileExists - determine if a file exists or not
|
|
static BOOL WsbFileExists(OLECHAR* pFileName)
|
|
{
|
|
BOOL doesExist = FALSE;
|
|
DWORD file_attrs;
|
|
|
|
WsbTraceIn(OLESTR("WsbFileExists"), OLESTR("%ls"), pFileName);
|
|
|
|
file_attrs = GetFileAttributes(pFileName);
|
|
if (0xffffffff != file_attrs) {
|
|
doesExist = TRUE;
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("WsbFileExists"), OLESTR("%ls"),
|
|
WsbBoolAsString(doesExist));
|
|
return(doesExist);
|
|
}
|