387 lines
15 KiB
C++
387 lines
15 KiB
C++
#if !defined(_FUSION_INC_PSPIPEHELPER_H_INCLUDED_)
|
|
#define _FUSION_INC_PSPIPEHELPER_H_INCLUDED_
|
|
|
|
#pragma once
|
|
|
|
#pragma warning(disable: 4127)
|
|
|
|
#include "fusioncom.h"
|
|
#include "smartref.h"
|
|
#include "fusewin.h"
|
|
#include "fusionbytebuffer.h"
|
|
#include "pstream.h"
|
|
|
|
#define IFFAIL_RETURN(x) \
|
|
do { \
|
|
const HRESULT __hr = (x); \
|
|
if (FAILED(__hr)) \
|
|
return __hr; \
|
|
} while (0)
|
|
|
|
#define IFFAIL_SET_PIPE_BAD_AND_RETURN(x) \
|
|
do { \
|
|
const HRESULT __hr = (x);\
|
|
if (FAILED(__hr)) \
|
|
{ \
|
|
m_fPipeBad = true; \
|
|
return __hr; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define IFFAIL_SET_PIPE_BAD_IF_AND_RETURN(x, cond) \
|
|
do { \
|
|
const HRESULT __hr = (x);\
|
|
if (FAILED(__hr)) \
|
|
{ \
|
|
if ((cond)) m_fPipeBad = true; \
|
|
return __hr; \
|
|
} \
|
|
} while (0)
|
|
|
|
// SET_PIPE_BAD_IF_AND_EXIT evaluates the first parameter. If it is
|
|
// failure and "cond" is true, the pipe is set to be broken. Regardless
|
|
// of success vs. failure, the value of the first parameter is returned.
|
|
#define SET_PIPE_BAD_IF_AND_EXIT(x, cond) \
|
|
do { \
|
|
const HRESULT __hr = (x); \
|
|
if (FAILED(__hr)) \
|
|
{ \
|
|
if ((cond)) m_fPipeBad = true; \
|
|
hr = __hr; \
|
|
goto Exit; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define UNUSED(x) (x)
|
|
|
|
extern HRESULT FusionWriteProperty(IPipeByte *pIPipeByte, ULONG propid, const PROPVARIANT &rvarValue, bool &rfAnyDataWritten);
|
|
extern HRESULT FusionWriteBlobVectorProperty(IPipeByte *pIPipeByte, ULONG propid, ULONG cElements, va_list ap, bool &rfAnyDataWritten);
|
|
extern HRESULT FusionWriteUI2VectorProperty(IPipeByte *pIPipeByte, ULONG propid, ULONG cElements, va_list ap, bool &rfAnyDataWritten);
|
|
|
|
class CPropertyStreamPipeWriter
|
|
{
|
|
public:
|
|
CPropertyStreamPipeWriter() : m_fInitialized(false), m_dwNextSectionCookie(0), m_fPipeBad(false) { }
|
|
~CPropertyStreamPipeWriter() { }
|
|
|
|
HRESULT Initialize(IPipeByte *pIPipeByte)
|
|
{
|
|
if (m_fInitialized) return E_UNEXPECTED;
|
|
if (pIPipeByte == NULL) return E_POINTER;
|
|
m_srpIPipeByte = pIPipeByte;
|
|
m_fInitialized = true;
|
|
m_fPipeBad = false;
|
|
return NOERROR;
|
|
}
|
|
|
|
// The pipe data stream is considered bad if we started writing some part of a data
|
|
// item and failed before completing. Once a pipe is bad, there is nothing
|
|
// you can do with it except close it.
|
|
bool IsPipeBad() const { return m_fPipeBad; }
|
|
|
|
HRESULT WriteHeader(REFCLSID rclsidOriginator)
|
|
{
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
if (m_dwNextSectionCookie != 0) return E_UNEXPECTED;
|
|
if (m_fPipeBad) return HRESULT_FROM_WIN32(ERROR_BAD_PIPE);
|
|
FUSION_PSTREAM_VERSION_1_HEADER hdr;
|
|
hdr.vih.wByteOrder = 0xFFFE;
|
|
hdr.vih.wFormat = 1;
|
|
hdr.vih.dwOSVer = (DWORD) MAKELONG(LOWORD(::GetVersion()), 2); // taken from MSDN mk:@MSITStore:\\infosrv2\msdn_oct99\MSDN\COM.chm::/devdoc/com/stgasstg_44mr.htm
|
|
hdr.vih.clsid = rclsidOriginator;
|
|
hdr.vih.reserved = 0;
|
|
IFFAIL_RETURN(m_srpIPipeByte->Push((LPBYTE) &hdr, sizeof(hdr)));
|
|
m_dwNextSectionCookie = 1;
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT BeginSection(REFGUID rguidSectionSet, ULONG ulSectionID, DWORD &rdwSectionCookie)
|
|
{
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
ASSERT(m_dwNextSectionCookie != 0); // forgot to send header
|
|
if (m_dwNextSectionCookie == 0) return E_UNEXPECTED;
|
|
if (m_fPipeBad) return HRESULT_FROM_WIN32(ERROR_BAD_PIPE);
|
|
FUSION_PSTREAM_ELEMENT elt;
|
|
elt.bIndicator = FUSION_PSTREAM_INDICATOR_SECTION_BEGIN;
|
|
elt.BeginSectionVal.guidSectionSet = rguidSectionSet;
|
|
elt.BeginSectionVal.ulSectionID = ulSectionID;
|
|
IFFAIL_RETURN(m_srpIPipeByte->Push((LPBYTE) &elt, FUSION_PSTREAM_SIZEOF_SECTION_BEGIN));
|
|
rdwSectionCookie = m_dwNextSectionCookie++;
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT EndSection(DWORD dwSectionCookie)
|
|
{
|
|
UNUSED(dwSectionCookie); // Eventually check this so that we can make sure caller doesn't mis-match begins/ends
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
if (m_fPipeBad) return HRESULT_FROM_WIN32(ERROR_BAD_PIPE);
|
|
FUSION_PSTREAM_ELEMENT elt;
|
|
elt.bIndicator = FUSION_PSTREAM_INDICATOR_SECTION_END;
|
|
IFFAIL_RETURN(m_srpIPipeByte->Push((LPBYTE) &elt, FUSION_PSTREAM_SIZEOF_SECTION_END));
|
|
return NOERROR;
|
|
}
|
|
|
|
HRESULT WriteProperty(DWORD dwSectionCookie, ULONG ulPropertyID, PROPVARIANT varValue)
|
|
{
|
|
UNUSED(dwSectionCookie);
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
if (m_fPipeBad) return HRESULT_FROM_WIN32(ERROR_BAD_PIPE);
|
|
// Too much work to even try to do inline..
|
|
bool fAnyDataWritten = false;
|
|
IFFAIL_SET_PIPE_BAD_IF_AND_RETURN(::FusionWriteProperty(m_srpIPipeByte, ulPropertyID, varValue, fAnyDataWritten), fAnyDataWritten);
|
|
return NOERROR;
|
|
}
|
|
|
|
// cch should not include space for the null...
|
|
HRESULT WriteProperty(DWORD dwSectionCookie, ULONG ulPropertyID, LPCWSTR szValue, INT cch = -1)
|
|
{
|
|
UNUSED(dwSectionCookie);
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
if (m_fPipeBad) return HRESULT_FROM_WIN32(ERROR_BAD_PIPE);
|
|
if (cch < 0)
|
|
{
|
|
cch = ::wcslen(szValue);
|
|
// Handle overflow - crazy case, but might as well not crash.
|
|
if (cch < 0)
|
|
cch = 0x7fffffff;
|
|
}
|
|
else {
|
|
// Trim off trailing null characters when user passed in cch > 0
|
|
while ((cch > 0) && (szValue[cch - 1] == L'\0')) cch--;
|
|
}
|
|
FUSION_PSTREAM_ELEMENT elt;
|
|
elt.bIndicator = FUSION_PSTREAM_INDICATOR_PROPERTY;
|
|
elt.PropertyVal.propid = ulPropertyID;
|
|
elt.PropertyVal.wType = VT_LPWSTR;
|
|
bool fAnyDataWritten = false;
|
|
IFFAIL_RETURN(m_srpIPipeByte->Push((LPBYTE) &elt, FUSION_PSTREAM_SIZEOF_PROPERTY));
|
|
IFFAIL_SET_PIPE_BAD_AND_RETURN(m_srpIPipeByte->Push((LPBYTE) &cch, sizeof(cch)));
|
|
IFFAIL_SET_PIPE_BAD_AND_RETURN(m_srpIPipeByte->Push((LPBYTE) szValue, cch * sizeof(WCHAR)));
|
|
return NOERROR;
|
|
}
|
|
|
|
// WriteVector() currently only understands: VT_UI2, VT_BLOB
|
|
HRESULT WriteVectorVa(DWORD dwSectionCookie, ULONG ulPropertyID, VARTYPE vt, ULONG cElements, va_list ap)
|
|
{
|
|
HRESULT hr = NOERROR;
|
|
bool fAnyDataWritten = false;
|
|
UNUSED(dwSectionCookie);
|
|
if (!m_fInitialized) { hr = E_UNEXPECTED; goto Exit; }
|
|
if (m_fPipeBad) { hr = HRESULT_FROM_WIN32(ERROR_BAD_PIPE); goto Exit; }
|
|
switch (vt)
|
|
{
|
|
case VT_BLOB:
|
|
SET_PIPE_BAD_IF_AND_EXIT(
|
|
::FusionWriteBlobVectorProperty(m_srpIPipeByte, ulPropertyID, cElements, ap, fAnyDataWritten),
|
|
fAnyDataWritten);
|
|
break;
|
|
|
|
case VT_UI2:
|
|
SET_PIPE_BAD_IF_AND_EXIT(
|
|
::FusionWriteUI2VectorProperty(m_srpIPipeByte, ulPropertyID, cElements, ap, fAnyDataWritten),
|
|
fAnyDataWritten);
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
hr = E_INVALIDARG;
|
|
goto Exit;
|
|
|
|
break;
|
|
}
|
|
|
|
hr = NOERROR;
|
|
Exit:
|
|
return hr;
|
|
}
|
|
|
|
HRESULT WriteVector(DWORD dwSectionCookie, ULONG ulPropertyID, VARTYPE vt, ULONG cElements, ...)
|
|
{
|
|
va_list ap;
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
if (m_fPipeBad) return HRESULT_FROM_WIN32(ERROR_BAD_PIPE);
|
|
va_start(ap, cElements);
|
|
HRESULT hr = this->WriteVectorVa(dwSectionCookie, ulPropertyID, vt, cElements, ap);
|
|
va_end(ap);
|
|
if (!FAILED(hr)) hr = NOERROR;
|
|
return hr;
|
|
}
|
|
|
|
HRESULT Close()
|
|
{
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
HRESULT hr = m_srpIPipeByte->Push(0, 0);
|
|
if (FAILED(hr)) return hr;
|
|
m_srpIPipeByte.Release();
|
|
m_fInitialized = false;
|
|
return NOERROR;
|
|
}
|
|
|
|
protected:
|
|
CSmartRef<IPipeByte> m_srpIPipeByte;
|
|
bool m_fInitialized;
|
|
DWORD m_dwNextSectionCookie;
|
|
bool m_fPipeBad;
|
|
};
|
|
|
|
//
|
|
// CPropertyStreamPipeReader is an aggregatable/tear-off-able COM object that
|
|
// you can instantiate on your class in order to get callbacks when a piped
|
|
// property stream has data available on it.
|
|
//
|
|
// We expect to invoke the following member functions on the T pointer passed in:
|
|
//
|
|
// HRESULT OnPropertyStreamHeader(PFUSION_PSTREAM_VERSION_INDEPENDENT_HEADER phdr);
|
|
// Called when the header has been recognized from the stream in.
|
|
// If this function returns a non-successful HRESULT, the remainder of
|
|
// the property stream is discarded, and when OnPropertyStreamEnd() is
|
|
// called, the caller should call StopParsingPropertyStream().
|
|
//
|
|
// HRESULT OnPropertyStreamElement(PFUSION_PSTREAM_ELEMENT pelt);
|
|
// Called when a property stream element header has been recognized.
|
|
// This may be either a section begin (in which case the section guid
|
|
// and ID are available in the pelt), a section end (no additional data),
|
|
// or a property (in which case the property id and property type are
|
|
// available in the pelt). Once a property header has been found, the
|
|
// property data is buffered until entirely available.
|
|
// If this function returns a non-successful HRESULT, the remainder of
|
|
// the property stream is discarded, and when OnPropertyStreamEnd() is
|
|
// called, the caller should call StopParsingPropertyStream().
|
|
//
|
|
// HRESULT OnPropertyStreamPropertyValue(LPCBYTE *prgbValue, ULONG cbValue);
|
|
// Called when an entire property value is available. Note that
|
|
// the buffer passed in is the raw format of the property value; strings
|
|
// are not null terminated and there may or may not be valid data past
|
|
// prgbValue[cbValue-1].
|
|
// If this function returns a non-successful HRESULT, the remainder of
|
|
// the property stream is discarded, and when OnPropertyStreamEnd() is
|
|
// called, the caller should call StopParsingPropertyStream().
|
|
//
|
|
// VOID OnPropertyStreamEnd(CPropertyStreamPipeReaderBase::PropertyStreamEndReason er);
|
|
// Called when the pipe is closed/ended.
|
|
//
|
|
|
|
class __declspec(novtable) CPropertyStreamPipeReaderBase : public CFusionCOMObjectBase, public IPipeByte
|
|
{
|
|
public:
|
|
FUSION_BEGIN_COM_MAP(CPropertyStreamPipeReaderBase)
|
|
FUSION_COM_INTERFACE_ENTRY(IPipeByte)
|
|
FUSION_END_COM_MAP()
|
|
|
|
HRESULT StartParsingPropertyStream();
|
|
HRESULT StopParsingPropertyStream();
|
|
|
|
// IPipeByte methods:
|
|
STDMETHODIMP Pull(BYTE *prgbBuffer, ULONG cRequest, ULONG *pcReturned);
|
|
STDMETHODIMP Push(BYTE *prgbBuffer, ULONG cbBuffer);
|
|
|
|
enum PropertyStreamEndReason
|
|
{
|
|
eNormalEnd,
|
|
eStreamFormatError,
|
|
ePropertyTypeError,
|
|
eStreamEndEarly,
|
|
eInternalError, // indicates a code bug
|
|
eOutOfMemory,
|
|
eOtherError, // indicates some HRESULT other than E_OUTOFMEMORY was encountered
|
|
};
|
|
|
|
protected:
|
|
CPropertyStreamPipeReaderBase() : m_fInitialized(false), m_iByteCurrent(0) { }
|
|
~CPropertyStreamPipeReaderBase() { }
|
|
|
|
virtual HRESULT FireOnPropertyStreamHeader(PCFUSION_PSTREAM_VERSION_INDEPENDENT_HEADER phdr) = 0;
|
|
virtual HRESULT FireOnPropertyStreamElement(PCFUSION_PSTREAM_ELEMENT pelt) = 0;
|
|
virtual HRESULT FireOnPropertyStreamPropertyValue(PCBYTE prgbValue, ULONG cbValue) = 0;
|
|
virtual VOID FireOnPropertyStreamEnd(PropertyStreamEndReason pser) = 0;
|
|
|
|
bool m_fInitialized;
|
|
CByteBuffer m_buffer;
|
|
ULONG m_iByteCurrent;
|
|
|
|
enum State
|
|
{
|
|
eIdle, // Not yet started parsing
|
|
eWaitingForHeader, // waiting for header bytes
|
|
eWaitingForIndicator, // waiting for indicator byte
|
|
eWaitingForSection, // waiting for remainder of section header
|
|
eWaitingForProperty, // waiting for property
|
|
eWaitingForPropertySize, // Waiting for some size/count on the property
|
|
eWaitingForPropertyElementSize,
|
|
eWaitingForPropertyElementData,
|
|
eWaitingForPropertyValue, // waiting for property value
|
|
eWaitingForPipeEnd, // Hit end indicator; next push should be length 0 and there should
|
|
// be no data in the buffer.
|
|
ePipeDone, // end of pipe hit; will transition to idle when parsing is stopped
|
|
eDiscarded, // we don't care about the rest of the data pushed to us.
|
|
} m_state;
|
|
|
|
ULONG m_cbRequiredForNextStateTransition;
|
|
ULONG m_cVectorElementsLeft; // Used when parsing VT_VECTOR properties; we store the
|
|
// total number of elements we still expect to find in the
|
|
// data stream here so we can tell when we can fire
|
|
// OnPropertyStreamPropertyValue().
|
|
ULONG m_iNextVectorSize; // Offset from m_iByteCurrent to the next vector element size.
|
|
WORD m_wType; // current property type we're parsing; makes a lot of code
|
|
// simpler to just copy it here.
|
|
|
|
HRESULT OnStateMet();
|
|
HRESULT OnWaitingForHeaderStateMet();
|
|
HRESULT OnWaitingForIndicatorStateMet();
|
|
HRESULT OnWaitingForSectionStateMet();
|
|
HRESULT OnWaitingForPropertyStateMet();
|
|
HRESULT OnWaitingForPropertySizeStateMet();
|
|
HRESULT OnWaitingForPropertyValueStateMet();
|
|
HRESULT OnWaitingForPropertyElementSizeStateMet();
|
|
HRESULT OnWaitingForPropertyElementDataStateMet();
|
|
};
|
|
|
|
template <class T> class __declspec(novtable) CPropertyStreamPipeReader : public CPropertyStreamPipeReaderBase
|
|
{
|
|
public:
|
|
CPropertyStreamPipeReader() : m_pt(NULL) { }
|
|
~CPropertyStreamPipeReader() { m_pt = NULL; }
|
|
|
|
HRESULT Initialize(T *pt)
|
|
{
|
|
if (m_fInitialized) return E_UNEXPECTED;
|
|
if (pt == NULL) return E_POINTER;
|
|
IFFAIL_RETURN(CFusionCOMObjectBase::Initialize());
|
|
m_pt = pt;
|
|
m_state = eIdle;
|
|
return NOERROR;
|
|
}
|
|
|
|
protected:
|
|
T *m_pt;
|
|
|
|
virtual HRESULT FireOnPropertyStreamHeader(PCFUSION_PSTREAM_VERSION_INDEPENDENT_HEADER phdr)
|
|
{
|
|
ASSERT(m_fInitialized);
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
return m_pt->OnPropertyStreamHeader(phdr);
|
|
}
|
|
|
|
virtual HRESULT FireOnPropertyStreamElement(PCFUSION_PSTREAM_ELEMENT pelt)
|
|
{
|
|
ASSERT(m_fInitialized);
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
return m_pt->OnPropertyStreamElement(pelt);
|
|
}
|
|
|
|
virtual HRESULT FireOnPropertyStreamPropertyValue(PCBYTE prgbValue, ULONG cbValue)
|
|
{
|
|
ASSERT(m_fInitialized);
|
|
if (!m_fInitialized) return E_UNEXPECTED;
|
|
return m_pt->OnPropertyStreamPropertyValue(prgbValue, cbValue);
|
|
}
|
|
|
|
virtual VOID FireOnPropertyStreamEnd(PropertyStreamEndReason er)
|
|
{
|
|
ASSERT(m_fInitialized);
|
|
if (m_fInitialized) m_pt->OnPropertyStreamEnd(er);
|
|
}
|
|
};
|
|
|
|
#endif
|