|
|
//+-------------------------------------------------------------------
//
// File: actstrm.cxx
//
// Contents: code for providing a stream with an IBuffer interface
// as well as providing marshalled interface data for
// RPC.
//
// Classes: ActivationStream
//
// History: 30-Jan-93 Ricksa Created CXmitRpcStream
// 04-Feb-98 Vinaykr ActivationStream
//
// Description: All requirements of CXmitRpcStream, plus the additional
// requirement of being able to support a buffer interface
// for activation custom marshalling.
//--------------------------------------------------------------------
#include <ole2int.h>
#include <actstrm.hxx>
HRESULT GetActivationStream(REFIID riid, void** ppv, DWORD size){ ActivationStream *st = new ActivationStream(size); if (st==NULL) return E_OUTOFMEMORY; return st->QueryInterface(riid, ppv); return S_OK;}
STDMETHODIMP ActivationStream::QueryInterface( REFIID iidInterface, void FAR* FAR* ppvObj){ HRESULT hresult = S_OK;
// We only support IUnknown and IStream
if (IsEqualIID(iidInterface, IID_IUnknown) || IsEqualIID(iidInterface, IID_IStream)) { *ppvObj = (IStream*)this; AddRef(); } else if (IsEqualIID(iidInterface, IID_IBuffer)) { *ppvObj = (IBuffer*)this; AddRef(); } else { *ppvObj = NULL; hresult = E_NOINTERFACE; }
return hresult;}
STDMETHODIMP_(ULONG) ActivationStream::AddRef(void){ Win4Assert((_clRefs != 0) && "ActivationStream::AddRef"); InterlockedIncrement(&_clRefs); return _clRefs;}
STDMETHODIMP_(ULONG) ActivationStream::Release(void){ Win4Assert((_clRefs != 0) && "ActivationStream::Release");
ULONG ulRefs = InterlockedDecrement(&_clRefs); if (ulRefs == 0) { delete this; }
return ulRefs;}
STDMETHODIMP ActivationStream::Read( VOID HUGEP* pv, ULONG cb, ULONG FAR* pcbRead){ HRESULT hresult = S_OK;
if (pcbRead) { *pcbRead = 0L; }
if (cb > _cbData - _lOffset) { cb = _cbData - _lOffset; hresult = STG_E_READFAULT; }
memcpy(pv,_pifData->abData + _lOffset, (size_t) cb); _lOffset += cb;
if (pcbRead != NULL) { *pcbRead = cb; }
return hresult;}
STDMETHODIMP ActivationStream::Write( VOID const HUGEP* pv, ULONG cbToWrite, ULONG FAR* pcbWritten){ HRESULT hresult = S_OK;
if (pcbWritten) { *pcbWritten = 0L; }
if (cbToWrite > _cbData - _lOffset) { // the current stream is too small, try to grow it.
// Validate that we can fulfill this request (this class doesn't
// support buffers bigger than MAX_ULONG, so we need to avoid
// overflow)
UINT64 cbReq = sizeof(DWORD) + cbToWrite + _lOffset + 64; if(cbReq > ULONG_MAX) return E_OUTOFMEMORY;
// We have a valid request
ULONG ulLen = (ULONG) cbReq; if (!_fFree) { // The stream doesn't own the buffer so it can't reallocate it
return STG_E_WRITEFAULT; }
// Reallocate the size of the buffer
// NOTE: The constant (64) added to the size allocated is a number
// designed simply to try and decrease the number of follow on
// allocations.
BYTE *pbNewBuf = (BYTE *) ActMemAlloc(ulLen);
if (pbNewBuf == NULL) { return E_OUTOFMEMORY; }
if (_pifData) { // we had a buffer from before, copy that in, and free the old one.
memcpy(pbNewBuf, _pifData, sizeof(DWORD) + _cbData); ActMemFree(_pifData); }
_cbData = cbToWrite + _lOffset + 64; _pifData = (InterfaceData *)pbNewBuf; }
// copy in the new data
memcpy(_pifData->abData + _lOffset, pv, (size_t) cbToWrite); _lOffset += cbToWrite;
if (pcbWritten != NULL) { *pcbWritten = cbToWrite; }
// We assume maxium size of buffer is the size to send on the network.
if (_cSize < _lOffset) { _cSize = _lOffset; }
return hresult;}
STDMETHODIMP ActivationStream::Seek( LARGE_INTEGER dlibMoveIN, DWORD dwOrigin, ULARGE_INTEGER FAR* plibNewPosition){ HRESULT hresult = S_OK;
/*
can't use this code until the stuff in ole2pr32.dll is fixed.
// check against -2^31-1 <= x <= 2^31-1
if (dlibMoveIN.HighPart == 0 && dlibMoveIN.LowPart < 0x80000000) // positive 31 bit value
; else if (dlibMoveIN.HighPart == -1L && dlibMoveIN.LowPart >= 0x80000000) // negative 31 bit value
; else return STG_E_SEEKERROR;*/
LONG dlibMove = dlibMoveIN.LowPart; ULONG cbNewPos = dlibMove;
switch(dwOrigin) { case STREAM_SEEK_SET:
if (dlibMove >= 0) { _lOffset = dlibMove; } else { hresult = STG_E_SEEKERROR; } break;
case STREAM_SEEK_CUR:
if (!(dlibMove < 0 && (-dlibMove > _lOffset))) { _lOffset += (ULONG) dlibMove; } else { hresult = STG_E_SEEKERROR; } break;
case STREAM_SEEK_END:
if (!(dlibMove < 0 && ((ULONG) -dlibMove) > _cbData)) { _lOffset = _cbData + dlibMove; } else { hresult = STG_E_SEEKERROR; } break;
default:
hresult = STG_E_SEEKERROR; }
if (plibNewPosition != NULL) { ULISet32(*plibNewPosition, _lOffset); }
return hresult;}
STDMETHODIMP ActivationStream::SetSize(ULARGE_INTEGER cb){ return E_NOTIMPL;}
STDMETHODIMP ActivationStream::CopyTo( IStream FAR* pstm, ULARGE_INTEGER cb, ULARGE_INTEGER FAR* pcbRead, ULARGE_INTEGER FAR* pcbWritten){ return E_NOTIMPL;}
STDMETHODIMP ActivationStream::Commit(DWORD grfCommitFlags){ return NOERROR;}
STDMETHODIMP ActivationStream::Revert(void){ return NOERROR;}
STDMETHODIMP ActivationStream::LockRegion( ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType){ return STG_E_INVALIDFUNCTION;}
STDMETHODIMP ActivationStream::UnlockRegion( ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType){ return STG_E_INVALIDFUNCTION;}
STDMETHODIMP ActivationStream::Stat( STATSTG FAR* pstatstg, DWORD statflag){ if (!pstatstg) return E_POINTER; memset(pstatstg, 0, sizeof(STATSTG));
pstatstg->type = STGTY_LOCKBYTES; pstatstg->cbSize.LowPart = _cbData;
// Everything else is zero or null, including the name
return S_OK;}
STDMETHODIMP ActivationStream::SetCopyAlignment(DWORD alignment){ _copyAlignment = alignment; return S_OK;}
inline ActivationStream *ActivationStream::Clone(){ DWORD len; BYTE *newBuff; DWORD alignmentOffset=0;
// Assume 8 byte alignment for new buffer
ActivationStream *strm = new ActivationStream(_cbData+_copyAlignment-1); if (strm == NULL) return strm;
// make sure we were able to allocate an internal buffer
if (_cbData != 0) { strm->GetLength(&len); if (len == 0) { delete strm; return NULL; } } strm->GetBuffer(&len, &newBuff); ASSERT(len==(_cbData+_copyAlignment-1)); ASSERT( sizeof(_lOffset) == sizeof(LONG) ); if ((UINT_PTR)(newBuff+_lOffset) & (_copyAlignment-1)) { alignmentOffset = _copyAlignment - ( PtrToUlong(newBuff+_lOffset) & (_copyAlignment-1) ); } GetCopy(newBuff+alignmentOffset); strm->SetPosition(len, _lOffset+alignmentOffset); return strm;}
STDMETHODIMP ActivationStream::Clone(IStream FAR * FAR *ppstm){ *ppstm = Clone(); if (*ppstm==NULL) return E_OUTOFMEMORY; return S_OK;}
STDMETHODIMP ActivationStream::GetOrCreateBuffer(DWORD dwReq, DWORD *pdwLength, BYTE **ppBuff){ if (((_cbData - _lOffset) < dwReq) || (!_pifData)) { BYTE* pbNewBuf = (BYTE*)ActMemAlloc(sizeof(DWORD)+dwReq+_cbData-_lOffset); if (pbNewBuf==NULL) return E_OUTOFMEMORY;
if (_pifData) { // we had a buffer from before, copy that in, and free the old one.
memcpy(pbNewBuf, _pifData, sizeof(DWORD) + _cbData); ActMemFree(_pifData); } // update _cbData
_cbData = dwReq + _cbData - _lOffset;
_pifData = (InterfaceData*)pbNewBuf; } *ppBuff = _pifData->abData + _lOffset; *pdwLength = _cbData - _lOffset; return S_OK;}
STDMETHODIMP ActivationStream::GetBuffer(DWORD *pdwLength, BYTE **ppBuff){ *pdwLength = _cbData-_lOffset; *ppBuff = _pifData->abData + _lOffset; return S_OK;}
STDMETHODIMP ActivationStream::GetLength(DWORD *pdwLength){ *pdwLength = _cbData; return S_OK;}
STDMETHODIMP ActivationStream::GetCopy(BYTE *pBuff){ memcpy(pBuff, _pifData->abData, _cbData); return S_OK;}
STDMETHODIMP ActivationStream::SetPosition(DWORD dwLenFromEnd, DWORD dwPosFromStart){ if (dwPosFromStart > dwLenFromEnd) return E_FAIL; _lOffset = _cbData - dwLenFromEnd + dwPosFromStart; if (_cSize < _lOffset) _cSize = _lOffset; return S_OK;}
STDMETHODIMP ActivationStream::SetBuffer(DWORD dwLength, BYTE *pBuff){ return E_NOTIMPL;}
|
