|
|
//+-------------------------------------------------------------------
//
// File: serial.cxx
//
// Contents: serialization support
//
// Classes: Serializer
//
// Functions: Helper class for serialization which holds
// serialization state like MES handles, position
// in buffer, stream etc. Provides a virtual
// buffer for operation but is created from and
// commited back to an IStream object.
//
// History: 24-Jan-98 vinaykr Created
// 17-Aug-98 vinaykr Made every method inline
// and non-COM class in serial.hxx
// This file no longer used
//
//
//--------------------------------------------------------------------
#include <ole2int.h>
#include "serial.hxx"
#include "buffer.h"
Serializer::~Serializer(){ // Free MES handle
if (_handle!=0) MesHandleFree(_handle);
// If we have a stream free it
if (_pStream) { _pIBuff->Release(); _pStream->Release(); }
// If original stream is different free it
if ((_pOriginalStream) && (_pOriginalStream != _pStream)) _pOriginalStream->Release();}
Serializer::Serializer(){ _bufSize=0; _operationSize=0; _buffer = 0; _nWritten = 0; _position = 0; _start = 0; _pStream = NULL; _pOriginalStream = NULL; _pIBuff = NULL; _handle = 0; _clRefs = 1;}
HRESULT Serializer::QueryInterface(REFIID iidInterface, void **ppvObj){ HRESULT hresult = S_OK;
// We only support IUnknown and ISerializer
if (IsEqualIID(iidInterface, IID_IUnknown) || IsEqualIID(iidInterface, IID_ISerializer)) { *ppvObj = (void*)this; AddRef(); } else { *ppvObj = NULL; hresult = E_NOINTERFACE; }
return hresult;}
STDMETHODIMP_(ULONG) Serializer::AddRef(void){ Win4Assert((_clRefs != 0) && "Serializer::AddRef"); InterlockedIncrement(&_clRefs); return _clRefs;}
STDMETHODIMP_(ULONG) Serializer::Release(void){ Win4Assert((_clRefs != 0) && "Serializer::Release");
if (InterlockedDecrement(&_clRefs) == 0) { delete this; return 0; }
return _clRefs;}
/***************************************************************************//** Initializes state based on stream for serialization **//** Assumes that we know the limits of our operation before hand if we **//** writing out to the stream. **//***************************************************************************/STDMETHODIMP Serializer::InitStream(IStream *pStream,DWORD dwSize, DWORD direction, DWORD dwDestCtx, DWORD dwMarshalCtx){ HRESULT hr; DWORD nRead; _direction = direction; _destCtx = dwDestCtx; _marshalCtx = dwMarshalCtx; _pOriginalStream = pStream; _pOriginalStream->AddRef();
// Either read or write initial protocol header
if (direction == DIRECTION_IN) { DWORD x[2]; if ((hr = _pOriginalStream->Read(x, 8, &nRead)) != S_OK) return hr; _operationSize = x[0]; } else { DWORD x[2]; x[0] = dwSize; if ((hr = _pOriginalStream->Write(x, 8, &_nWritten)) != S_OK) return hr; _operationSize = dwSize; }
// See if given stream supports IBuffer otherwise create one that does
IBuffer *pibuff; if (_pOriginalStream->QueryInterface(IID_IBuffer, (void**)&pibuff)!=S_OK) { // allocate more in case alignment needed
_bufSize = _operationSize + 8; _pStream = new ActivationStream(_bufSize); if (_pStream==NULL) return E_OUTOFMEMORY;
hr = _pStream->QueryInterface(IID_IBuffer, (void**)&_pIBuff); ASSERT(hr==S_OK); pibuff = _pIBuff; }
do // Loop until we get right buffer
{ // Invariant is that pibuff must exist by the time we get here
ASSERT(pibuff != 0);
// Set up our buffer appropriately
if (direction == DIRECTION_IN) { if (pibuff->GetBuffer(&_bufSize, &_buffer)!=S_OK) return E_FAIL; if (_bufSize < _operationSize) return E_FAIL; } else if (direction == DIRECTION_OUT) { if (pibuff->GetOrCreateBuffer(_operationSize+GetSize(), &_bufSize, &_buffer)!=S_OK) return E_FAIL; }
if(((INT_PTR)_buffer)&0x7) { // If buffer is not 8 byte aligned, do it
if (pibuff != _pIBuff) { // Only get here if we are still using original
ASSERT(_pIBuff == 0); // So release it and create a new aligned one
pibuff->Release(); _bufSize = _operationSize + 8; _pStream = new ActivationStream(_bufSize); if (_pStream==NULL) return E_OUTOFMEMORY;
hr = _pStream->QueryInterface(IID_IBuffer, (void**)&_pIBuff); ASSERT(hr==S_OK); pibuff = _pIBuff; //Continue loop
} else { // Got a buffer which we can align
ASSERT(_pIBuff != 0); pibuff = 0; //Signal end of loop
// Align buffer
_start = 8-(PtrToUlong(_buffer)&7); } } else { // We have an original good one
_pIBuff = pibuff; pibuff = 0; } } while (pibuff);
ASSERT(_pIBuff!=0); // Set position for next operations and set up
// internal state correctly
hr = _pIBuff->SetPosition(_bufSize, _start); ASSERT(hr == S_OK); _bufSize -= _start; _buffer += _start; _position = 0;
if (direction==DIRECTION_IN) { if ((_pStream) && (_pOriginalStream != _pStream)) { //If what we have is not the original one then we
//need to copy data into aligned address from original
DWORD nOver=0; do { if ((hr=_pOriginalStream->Read(_buffer+nOver, _operationSize-nOver, &nRead))!= S_OK) return hr; nOver += nRead; } while (nOver<_operationSize); _pOriginalStream->Release(); _pOriginalStream = 0; // Don't need original any longer
} else _pStream = _pOriginalStream; // Set operating to original
ASSERT(_pStream!=0); // Create decoding handle for MES operations
MesDecodeBufferHandleCreate((char*)_buffer, _bufSize, &_handle); if (_handle == NULL) return E_OUTOFMEMORY; } else { _nWritten = 0; // Check if we are still using the orignal stream
if (_pStream == 0) _pStream = _pOriginalStream; // Create encoding handle for MES operations
MesEncodeFixedBufferHandleCreate((char*)_buffer, _bufSize, &_nWritten, &_handle); if (_handle == NULL) return E_OUTOFMEMORY; }
return S_OK;}
/***************************************************************************//** Sets stream and state for further serialization operations **//** Assumes that a stream supporting IBuffer is provided. **//***************************************************************************/STDMETHODIMP Serializer::SetStream(IStream *pStream,DWORD dwOpSize, DWORD direction,DWORD dwDestCtx, DWORD dwMarshalCtx){ // Set up internal state
_destCtx = dwDestCtx; _marshalCtx = dwMarshalCtx; _direction = direction; _pOriginalStream = 0; _pStream = pStream; _operationSize = dwOpSize; _pStream->AddRef();
// Assume IBuffer exists otherwise fail
if (_pStream->QueryInterface(IID_IBuffer, (void**)&_pIBuff)!=S_OK) return E_FAIL; if (_pIBuff->GetBuffer(&_bufSize, &_buffer)!=S_OK) return E_FAIL; if (_bufSize < _operationSize) return E_FAIL;
// Set up MES handles
if (direction==DIRECTION_IN) MesDecodeBufferHandleCreate((char*)_buffer, _bufSize, &_handle); else MesEncodeFixedBufferHandleCreate((char*)_buffer, _bufSize, &_nWritten, &_handle);
if (_handle == NULL) return E_OUTOFMEMORY;
return S_OK;}
// Gets MES handle
STDMETHODIMP Serializer::GetSerializationHandle(void *pHandle){ *((handle_t*) pHandle) = _handle; Win4Assert(_handle); return S_OK;}
// Gets MES handle for sizing operations
STDMETHODIMP Serializer::GetSizingHandle(void *pHandle){ char dummy[30], *dummybuff; unsigned long encodedSize; handle_t handle; dummybuff = (char*)(((INT_PTR)(&dummy[7])) & ~7); MesEncodeFixedBufferHandleCreate(dummybuff, 100, &encodedSize, (handle_t*)pHandle); if (pHandle == NULL) return E_OUTOFMEMORY; return S_OK;}
//Signals end of operations on this object and commits
//operations to stream
STDMETHODIMP Serializer::Commit(){ // If we are not using original and we are writing,
// then we need to copy
if ((_pOriginalStream) && (_pOriginalStream != _pStream)) { ASSERT(_direction==DIRECTION_OUT); HRESULT hr; do { _nWritten = 0; hr = _pOriginalStream->Write(_buffer, _operationSize, &_nWritten); if (hr != S_OK) break; _operationSize -= _nWritten; _buffer += _nWritten; } while (_operationSize);
return hr; } else return _pIBuff->SetPosition(_bufSize, _operationSize);}
STDMETHODIMP Serializer::SetPosition(DWORD dwPos){ // Sets position in buffer and creates appropriate MES handle
HRESULT hr = _pIBuff->SetPosition(_bufSize, dwPos); if (hr!=S_OK) return hr; MesHandleFree(_handle); if (_direction == DIRECTION_IN) MesDecodeBufferHandleCreate((char*)(_buffer+dwPos), _bufSize, &_handle); else { _nWritten = 0; MesEncodeFixedBufferHandleCreate((char*)(_buffer+dwPos), _bufSize, &_nWritten, &_handle); } if (_handle == NULL) return E_OUTOFMEMORY;
_position = dwPos; return S_OK;}
// Gets current position in buffer
STDMETHODIMP Serializer::GetPosition(DWORD *pdwPos){ *pdwPos = _position; return S_OK;}
// Increment current position by specified amount in buffer
STDMETHODIMP Serializer::IncrementPosition(DWORD dwInc){ return SetPosition(_position+dwInc);}
// Get buffers underlying stream object
STDMETHODIMP Serializer::GetStream(IStream **ppStream){ _pStream->AddRef(); *ppStream = _pStream; return S_OK;}
// Get a copy of this object
STDMETHODIMP Serializer::GetCopy(ISerializer **ppSer){
HRESULT hr; IStream *pNewStream; if (_pStream) { ASSERT(_direction==DIRECTION_IN); //No need for any other case right now
hr = _pIBuff->SetPosition(_bufSize, 0); ASSERT(hr==S_OK); Serializer *ser = new Serializer(); if (ser==NULL) return E_OUTOFMEMORY;
if (_pOriginalStream) // Still using original so clone
{ ASSERT(_start==0); ASSERT(_pStream==_pOriginalStream); hr = _pIBuff->SetCopyAlignment(8); ASSERT(hr==S_OK); hr = _pStream->Clone(&pNewStream); if (hr != S_OK) { delete ser; return hr; } } else { pNewStream = _pStream; } hr = ser->SetStream(pNewStream, _operationSize, _direction, _destCtx, _marshalCtx); if (FAILED(hr)) { if (pNewStream != _pStream) pNewStream->Release(); delete ser; return hr; } hr = ser->SetPosition(_position); if (FAILED(hr)) { if (pNewStream != _pStream) pNewStream->Release(); delete ser; return hr; } hr = _pIBuff->SetPosition(_bufSize, _position); ASSERT(hr==S_OK); *ppSer = ser; if (pNewStream != _pStream) pNewStream->Release(); return S_OK; }
return E_FAIL;}
// Write provided buffer into our buffer at current position
// and advance position
STDMETHODIMP Serializer::Write(BYTE *buff, DWORD nBytes){ ASSERT(nBytes<=(_bufSize-_position)); memcpy(_buffer+_position,buff, (size_t) nBytes); IncrementPosition(nBytes); return S_OK;}
// Copy into provided Serializer our data at given position and length
STDMETHODIMP Serializer::CopyTo(ISerializer *pSer, DWORD dwPos, DWORD nBytes){ ASSERT(nBytes<=(_bufSize-dwPos)); return pSer->Write(_buffer+dwPos, nBytes);}
// return buffer starting at current position
STDMETHODIMP Serializer::GetBufferAtCurrent(BYTE **ppBuff){ *ppBuff = _buffer+_position; return S_OK;}
|
