//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1993.
//
//  File:       memstm.cpp
//
//  Contents:   Implementations of IStream and ILockBytes on memory
//              (versus the file system)
//
//  Classes:    CMemStm
//              CMemBytes
//              CMarshalMemStm
//              CMarshalMemBytes
//
//  Functions:  CreateMemStm
//              CloneMemStm
//              ReleaseMemStm
//              CreateStreamOnHGlobal
//              GetHGlobalFromStream
//              CMemStmUnMarshal
//              CMemBytesUnMarshall
//
//  History:    dd-mmm-yy Author    Comment
//              31-Jan-95 t-ScottH  added Dump methods to CMemStm and CMemBytes
//                                  (_DEBUG only)
//                                  added DumpCMemStm and CMemBytes APIs
//              04-Nov-94 ricksa    Made CMemStm class multithread safe.
//              24-Jan-94 alexgo    first pass at converting to Cairo-style
//                                  memory allocation
//              11-Jan-94 alexgo    added VDATEHEAP macros to every function &
//                                  method, fixed compile warnings, removed
//                                  custom marshalling code.  Memory streams
//                                  and ILockBytes now use standard
//                                  marshalling.
//              16-Dec-93 alexgo    fixed memory reference bugs (bad pointer)
//              02-Dec-93 alexgo    32bit port, implement CMemStm::CopyTo
//              11/22/93 - ChrisWe - replace overloaded ==, != with
//                      IsEqualIID and IsEqualCLSID
//
//  Notes:
//
//--------------------------------------------------------------------------

#include <le2int.h>
#pragma SEG(memstm)

#include <nturtl.h>
#include "memstm.h"
#include "sem.hxx"
#include <reterr.h>

#ifdef _DEBUG
#include "dbgdump.h"
#endif // _DEBUG

NAME_SEG(CMemStm)
ASSERTDATA


// CRefMutexSem implementation
//
// Instances of this class are shared among all CMemStm objects 
// cloned from a common CMemStm object, as well as their parent.
//
// This guarantees synchronization between all instances of CMemStm that share common data

CRefMutexSem::CRefMutexSem() : m_lRefs(1)
{
    // Note: we begin life with one reference
}

CRefMutexSem* CRefMutexSem::CreateInstance()
{
    CRefMutexSem* prefMutexSem = NULL;
    prefMutexSem = new CRefMutexSem();
    if (prefMutexSem != NULL)
    {
    	if (prefMutexSem->FInit() == FALSE)
    	{
    	    ASSERT(FALSE);
    	    delete prefMutexSem;
    	    prefMutexSem = NULL;
    	}
    }
    return prefMutexSem;
}

BOOL CRefMutexSem::FInit()
{
    return m_mxs.FInit();	
}

ULONG CRefMutexSem::AddRef()
{
    return InterlockedIncrement (&m_lRefs);    
}

ULONG CRefMutexSem::Release()
{
    LONG lRefs = InterlockedDecrement (&m_lRefs);
    if (lRefs == 0)
    {
        delete this;
    }

    return lRefs;
}

void CRefMutexSem::RequestCS()
{
    m_mxs.Request();
}

void CRefMutexSem::ReleaseCS()
{
    m_mxs.Release();
}   

const CMutexSem2* CRefMutexSem::GetMutexSem()
{
    return &m_mxs;
}


inline CRefMutexAutoLock::CRefMutexAutoLock (CRefMutexSem* pmxs)
{
    Win4Assert (pmxs != NULL);

    m_pmxs = pmxs;
    m_pmxs->RequestCS();

    END_CONSTRUCTION (CRefMutexAutoLock);
}

inline CRefMutexAutoLock::~CRefMutexAutoLock()
{
    m_pmxs->ReleaseCS();
}
    
// Shared memory IStream implementation
//

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::CMemStm
//
//  Synopsis:   constructor for memory stream
//
//  Arguments:  none
//
//  History:    20-Dec-94   Rickhi      moved from h file
//
//--------------------------------------------------------------------------
CMemStm::CMemStm()
{
    m_hMem = NULL;
    m_pData = NULL;
    m_pos = 0;
    m_refs = 0;
    m_pmxs = NULL;
}

CMemStm::~CMemStm()
{
    if (m_pmxs != NULL)
    {
        m_pmxs->Release();
    }
}


//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::QueryInterface
//
//  Synopsis:   retrieves the requested interface
//
//  Effects:
//
//  Arguments:  [iidInterface]  -- the requested interface ID
//              [ppvObj]        -- where to put the interface pointer
//
//  Requires:
//
//  Returns:    NOERROR, E_OUTOFMEMORY, E_NOINTERFACE
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              11-Jan-94 alexgo    removed QI for IMarshal so that
//                                  the standard marshaller is used.
//                                  This is fix marshalling across
//                                  process on 32bit platforms.
//              02-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_QueryInterface)
STDMETHODIMP CMemStm::QueryInterface(REFIID iidInterface,
        void FAR* FAR* ppvObj)
{
        VDATEHEAP();

        HRESULT         error;

        VDATEPTROUT( ppvObj, LPVOID );
        *ppvObj = NULL;
        VDATEIID( iidInterface );

        // Two interfaces supported: IUnknown, IStream

        if (m_pData != NULL && (IsEqualIID(iidInterface, IID_IStream) ||
                IsEqualIID(iidInterface, IID_ISequentialStream) ||
                IsEqualIID(iidInterface, IID_IUnknown)))
        {

                AddRef();   // A pointer to this object is returned
                *ppvObj = this;
                error = NOERROR;
        }
#ifndef WIN32
        else if (IsEqualIID(iidInterface, IID_IMarshal))
        {
                *ppvObj = (LPVOID) CMarshalMemStm::Create(this);

                if (*ppvObj != NULL)
                {
                        error = NOERROR;
                }
                else
                {
                        error = ResultFromScode(E_OUTOFMEMORY);
                }
        }
#endif
        else
        {                 // Not accessible or unsupported interface
                *ppvObj = NULL;
                error = ResultFromScode(E_NOINTERFACE);
        }

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::AddRef
//
//  Synopsis:   increments the reference count
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    ULONG -- the new reference count
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              02-Dec-93 alexgo    32bit port
//              04-Nov-94 ricksa    Modified for multithreading
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_AddRef)
STDMETHODIMP_(ULONG) CMemStm::AddRef(void)
{
        VDATEHEAP();

        return InterlockedIncrement((LONG *) &m_refs);
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Release
//
//  Synopsis:   decrements the reference count
//
//  Effects:    deletes the object when ref count == 0
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    ULONG -- the new ref count
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              16-Dec-93 alexgo    added GlobalUnlock of the MEMSTM handle
//              02-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Release)
STDMETHODIMP_(ULONG) CMemStm::Release(void)
{
        VDATEHEAP();

        // The reason for this here is that there is a race when releasing
        // this object. If two threads are trying to release this object
        // at the same time, there is a case where the first one dec's
        // the ref count & then loses the processor to the second thread.
        // This second thread decrements the reference count to 0 and frees
        // the memory. The first thread can no longer safely examine the
        // internal state of the object.
        ULONG ulResult = InterlockedDecrement((LONG *) &m_refs);

        if (ulResult == 0)
        {
                // this MEMSTM handle was GlobalLock'ed in ::Create
                // we unlock it here, as we no longer need it.
                GlobalUnlock(m_hMem);

                ReleaseMemStm(&m_hMem);

                delete this;
        }

        return ulResult;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Read
//
//  Synopsis:   reads [cb] bytes from the stream
//
//  Effects:
//
//  Arguments:  [pb]            -- where to put the data read
//              [cb]            -- the number of bytes to read
//              [pcbRead]       -- where to put the actual number of bytes
//                                 read
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:  uses xmemcpy
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              02-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Read)
STDMETHODIMP CMemStm::Read(void HUGEP* pb, ULONG cb, ULONG FAR* pcbRead)
{
        VDATEHEAP();

        HRESULT         error = NOERROR;
        ULONG           cbRead = cb;

        if(cb)
        {
            VDATEPTROUT( pb, char);
        }

        // Single thread
        CRefMutexAutoLock lck(m_pmxs);

        if (pcbRead)
        {
                VDATEPTROUT( pcbRead, ULONG );
                *pcbRead = 0L;
        }

	// cbRead + m_pos could cause roll-over.
        if ( ( (cbRead + m_pos) > m_pData->cb) || ( (cbRead + m_pos) < m_pos) )
        {
                // Caller is asking for more bytes than we have left
                if(m_pData->cb > m_pos)
                    cbRead = m_pData->cb - m_pos;
                else
                    cbRead = 0;
        }

        if (cbRead > 0)
        {
                Assert (m_pData->hGlobal);
                BYTE HUGEP* pGlobal = (BYTE HUGEP *)GlobalLock(
                        m_pData->hGlobal);
                if (NULL==pGlobal)
                {
                        LEERROR(1, "GlobalLock Failed!");

                        return ResultFromScode (STG_E_READFAULT);
                }
                // overlap is currently considered a bug (see the discussion
                // on the Write method
                _xmemcpy(pb, pGlobal + m_pos, cbRead);
                GlobalUnlock (m_pData->hGlobal);
                m_pos += cbRead;
        }

        if (pcbRead != NULL)
        {
                *pcbRead = cbRead;
        }

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Write
//
//  Synopsis:   Writes [cb] bytes into the stream
//
//  Effects:
//
//  Arguments:  [pb]            -- the bytes to write
//              [cb]            -- the number of bytes to write
//              [pcbWritten]    -- where to put the number of bytes written
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:  resizes the internal buffer (if needed), then uses xmemcpy
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              02-Dec-93 alexgo    32bit port, fixed bug dealing with
//                                  0-byte sized memory
//              06-Dec-93 alexgo    handle overlap case.
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Write)
STDMETHODIMP CMemStm::Write(void const HUGEP* pb, ULONG cb,
        ULONG FAR* pcbWritten)
{
        VDATEHEAP();

        HRESULT                 error = NOERROR;
        ULONG                   cbWritten = cb;
        ULARGE_INTEGER          ularge_integer;
        BYTE HUGEP*             pGlobal;

        if(cb)
        {
            VDATEPTRIN( pb , char );
        }

        // Single thread
        CRefMutexAutoLock lck(m_pmxs);

        if (pcbWritten != NULL)
        {
                *pcbWritten = 0;
        }

        if (cbWritten + m_pos > m_pData->cb)
        {
                ULISet32( ularge_integer, m_pos+cbWritten );
                error = SetSize(ularge_integer);
                if (error != NOERROR)
                {
                        goto Exit;
                }
        }

        // we don't write anything if 0 bytes are asked for for two
        // reasons: 1. optimization, 2. m_pData->hGlobal could be a
        // handle to a zero-byte memory block, in which case GlobalLock
        // will fail.

        if( cbWritten > 0 )
        {
                pGlobal = (BYTE HUGEP *)GlobalLock (m_pData->hGlobal);
                if (NULL==pGlobal)
                {
                        LEERROR(1, "GlobalLock Failed!");

                        return ResultFromScode (STG_E_WRITEFAULT);
                }

                // we use memmove here instead of memcpy to handle the
                // overlap case.  Recall that the app originally gave
                // use the memory for the memstm.  He could (either through
                // a CopyTo or through really strange code), be giving us
                // this region to read from, so we have to handle the overlapp
                // case.  The same argument also applies for Read, but for
                // now, we'll consider overlap on Read a bug.
                _xmemmove(pGlobal + m_pos, pb, cbWritten);
                GlobalUnlock (m_pData->hGlobal);

                m_pos += cbWritten;
        }

        if (pcbWritten != NULL)
        {
                *pcbWritten = cbWritten;
        }

Exit:

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Seek
//
//  Synopsis:   Moves the internal seek pointer
//
//  Effects:
//
//  Arguments:  [dlibMoveIN]    -- the amount to move by
//              [dwOrigin]      -- flags to control whether seeking is
//                                 relative to the current postion or
//                                 the begging/end.
//              [plibNewPosition]       -- where to put the new position
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              02-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Seek)
STDMETHODIMP CMemStm::Seek(LARGE_INTEGER dlibMoveIN, DWORD dwOrigin,
        ULARGE_INTEGER FAR* plibNewPosition)
{
        VDATEHEAP();

        HRESULT                 error  = NOERROR;
        LONG                    dlibMove = dlibMoveIN.LowPart ;
        ULONG                   cbNewPos = dlibMove;

        // Single thread
        CRefMutexAutoLock lck(m_pmxs);

        if (plibNewPosition != NULL)
        {
                VDATEPTROUT( plibNewPosition, ULONG );
                ULISet32(*plibNewPosition, m_pos);
        }

        switch(dwOrigin)
        {

        case STREAM_SEEK_SET:
                if (dlibMove >= 0)
                {
                        m_pos = dlibMove;
                }
                else
                {
                        error = ResultFromScode(STG_E_SEEKERROR);
                }

                break;

        case STREAM_SEEK_CUR:
                if (!(dlibMove < 0 && ((ULONG) -dlibMove) > m_pos))
                {
                        m_pos += dlibMove;
                }
                else
                {
                        error = ResultFromScode(STG_E_SEEKERROR);
                }
                break;

        case STREAM_SEEK_END:
                if (!(dlibMove < 0 && ((ULONG) -dlibMove) > m_pData->cb))
                {
                        m_pos = m_pData->cb + dlibMove;
                }
                else
                {
                        error = ResultFromScode(STG_E_SEEKERROR);
                }
                break;

        default:
                error = ResultFromScode(STG_E_SEEKERROR);
        }

        if (plibNewPosition != NULL)
        {
                ULISet32(*plibNewPosition, m_pos);
        }

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::SetSize
//
//  Synopsis:   Sets the size of our memory
//
//  Effects:
//
//  Arguments:  [cb]    -- the new size
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:  calls GlobalRealloc
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              02-Dec-93 alexgo    32bit port, added assert
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_SetSize)
STDMETHODIMP CMemStm::SetSize(ULARGE_INTEGER cb)
{
        VDATEHEAP();

        HANDLE hMemNew;

        // Single thread
        CRefMutexAutoLock lck(m_pmxs);

        // make sure we aren't in overflow conditions.

        AssertSz(cb.HighPart == 0,
                "MemStream::More than 2^32 bytes asked for");

        if (m_pData->cb == cb.LowPart)
        {
                return NOERROR;
        }

        hMemNew = GlobalReAlloc(m_pData->hGlobal, max (cb.LowPart,1),
                        GMEM_SHARE | GMEM_MOVEABLE);

        if (hMemNew == NULL)
        {
                return ResultFromScode (E_OUTOFMEMORY);
        }

        m_pData->hGlobal = hMemNew;
        m_pData->cb = cb.LowPart;

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::CopyTo
//
//  Synopsis:   Copies data from [this] stream to [pstm]
//
//  Effects:
//
//  Arguments:  [pstm]          -- the stream to copy to
//              [cb]            -- the number of bytes to copy
//              [pcbRead]       -- where to return the number of bytes read
//              [pcbWritten]    -- where to return the number of bytes written
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:  does an IStream->Write to the given stream
//
//  History:    dd-mmm-yy Author    Comment
//              04-Nov-94 ricksa    Modified for multithreading
//              03-Dec-93 alexgo    original implementation
//
//  Notes:      This implementation assumes that the address space
//              is not greater than ULARGE_INTEGER.LowPart (which is
//              for for 32bit operating systems).  64bit NT may need
//              to revisit this code.
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_CopyTo)
STDMETHODIMP CMemStm::CopyTo(IStream FAR *pstm, ULARGE_INTEGER cb,
        ULARGE_INTEGER FAR * pcbRead, ULARGE_INTEGER FAR * pcbWritten)
{
        VDATEHEAP();

        ULONG   cbRead          = cb.LowPart;
        ULONG   cbWritten       = 0;
        HRESULT hresult         = NOERROR;

        // pstm cannot be NULL

        VDATEPTRIN(pstm, LPSTREAM);

        // Single thread
        CRefMutexAutoLock lck(m_pmxs);

        // the spec says that if cb is it's maximum value (all bits set,
        // since it's unsigned), then we will simply read the copy of
        // this stream

        if ( ~(cb.LowPart) == 0 && ~(cb.HighPart) == 0 )
        {
                cbRead = m_pData->cb - m_pos;
        }
        else if ( cb.HighPart > 0 )
        {
                // we assume that our memory stream cannot
                // be large enough to accomodate very large (>32bit)
                // copy to requests.  Since this is probably an error
                // on the caller's part, we assert.

                AssertSz(0, "WARNING: CopyTo request exceeds 32 bits");

                // set the Read value to what's left, so that "Ignore"ing
                // the assert works properly.

                cbRead = m_pData->cb - m_pos;
        }
        else if ( cbRead + m_pos > m_pData->cb )
        {
                // more bytes were requested to read than we had left.
                // cbRead is set to the amount remaining.

                cbRead = m_pData->cb - m_pos;
        }

        // now write the data to the stream

        if ( cbRead > 0 )
        {
                BYTE HUGEP* pGlobal = (BYTE HUGEP *)GlobalLock(
                                m_pData->hGlobal);

                if( pGlobal == NULL )
                {
                        LEERROR(1, "GlobalLock failed");

                        return ResultFromScode(STG_E_INSUFFICIENTMEMORY);
                }

                hresult = pstm->Write(pGlobal + m_pos, cbRead, &cbWritten);

                // in the error case, the spec says that the return values
                // may be meaningless, so we do not need to do any special
                // error handling here

                GlobalUnlock(m_pData->hGlobal);
        }

        // increment our seek pointer and set the out parameters

        m_pos += cbRead;

        if( pcbRead )
        {
                ULISet32(*pcbRead, cbRead);
        }

        if( pcbWritten )
        {
                ULISet32(*pcbWritten, cbWritten);
        }

        return hresult;

}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Commit
//
//  Synopsis:   Does nothing, no transactions available on memory streams
//
//  Effects:
//
//  Arguments:  [grfCommitFlags]
//
//  Requires:
//
//  Returns:    NOERROR
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Commit)
STDMETHODIMP CMemStm::Commit(DWORD grfCommitFlags)
{
        VDATEHEAP();

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Revert
//
//  Synopsis:   does nothing, as no transactions are supported on memory
//              streams
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    NOERROR
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Revert)
STDMETHODIMP CMemStm::Revert(void)
{
        VDATEHEAP();

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::LockRegion
//
//  Synopsis:   not supported in OLE2.01
//
//  Effects:
//
//  Arguments:  [libOffset]
//              [cb]
//              [dwLockType]
//
//  Requires:
//
//  Returns:    STG_E_INVALIDFUNCTION
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_LockRegion)
STDMETHODIMP CMemStm::LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb,
        DWORD dwLockType)
{
        VDATEHEAP();

        return ResultFromScode(STG_E_INVALIDFUNCTION);
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::UnlockRegion
//
//  Synopsis:   not implemented for OLE2.01
//
//  Effects:
//
//  Arguments:  [libOffset]
//              [cb]
//              [dwLockType]
//
//  Requires:
//
//  Returns:    STG_E_INVALIDFUNCTION
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_UnlockRegion)
STDMETHODIMP CMemStm::UnlockRegion(ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb, DWORD dwLockType)
{
        VDATEHEAP();

        return ResultFromScode(STG_E_INVALIDFUNCTION);
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Stat
//
//  Synopsis:   Returns info about this stream
//
//  Effects:
//
//  Arguments:  [pstatstg]      -- the STATSTG to fill with info
//              [statflag]      -- status flags, unused
//
//  Requires:
//
//  Returns:    NOERROR, E_INVALIDARG
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//              01-Jun-94 AlexT     Set type correctly
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Stat)
STDMETHODIMP CMemStm::Stat(STATSTG FAR *pstatstg, DWORD statflag)
{
        VDATEHEAP();

        VDATEPTROUT( pstatstg, STATSTG );

        memset ( pstatstg, 0, sizeof(STATSTG) );

        pstatstg->type                  = STGTY_STREAM;
        pstatstg->cbSize.LowPart        = m_pData->cb;

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Clone
//
//  Synopsis:   creates a new instance of this stream pointing to the
//              same data at the same position (same seek pointer)
//
//  Effects:
//
//  Arguments:  [ppstm]         -- where to put the new CMemStm pointer
//
//  Requires:
//
//  Returns:    NOERROR, E_OUTOFMEMORY
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IStream
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Clone)
STDMETHODIMP CMemStm::Clone(IStream FAR * FAR *ppstm)
{
        VDATEHEAP();

        CMemStm FAR*    pCMemStm;

        VDATEPTROUT (ppstm, LPSTREAM);

        *ppstm = pCMemStm = CMemStm::Create(m_hMem, m_pmxs);

        if (pCMemStm == NULL)
        {
                return ResultFromScode(E_OUTOFMEMORY);
        }

        pCMemStm->m_pos = m_pos;

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Create
//
//  Synopsis:   Creates a new CMemStm.  [hMem] must be a handle to a MEMSTM
//              block.
//
//  Effects:
//
//  Arguments:  [hMem]  -- handle to a MEMSTM block
//
//  Requires:
//
//  Returns:    CMemStm *
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              15-Dec-93 alexgo    fixed memory access bug
//              03-Dec-93 alexgo    32bit port
//              20-Sep-2000 mfeingol Added Mutex inheritance
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemStm_Create)
STDSTATICIMP_(CMemStm FAR*) CMemStm::Create(HANDLE hMem, CRefMutexSem* pmxs)
{
        VDATEHEAP();

        CMemStm FAR* pCMemStm = NULL;
        struct MEMSTM FAR* pData;

        pData = (MEMSTM FAR*) GlobalLock(hMem);

        if (pData != NULL)
        {
            pCMemStm = new CMemStm;

            if (pCMemStm != NULL)
            {
                // Initialize CMemStm
                pCMemStm->m_hMem = hMem;
                InterlockedIncrement ((LPLONG) &(pCMemStm->m_pData = pData)->cRef); // AddRefMemStm
                pCMemStm->m_refs = 1;
                pCMemStm->m_dwSig = STREAM_SIG;

                if (pmxs != NULL)
                {
                    // Addref the input
                    pmxs->AddRef();
                }
                else
                {
                    // Create a new mutex (implicit addref)
                    pmxs = CRefMutexSem::CreateInstance();
                }

                if (pmxs != NULL)
                {
                    // Give the CMemStm a mutex
                    pCMemStm->m_pmxs = pmxs;
                }
                else
                {
                    // uh-oh, low on memory
                    delete pCMemStm;
                    pCMemStm = NULL;

                    GlobalUnlock(hMem);
                }
            }
            else
            {
                // uh-oh, low on memory
                GlobalUnlock(hMem);
            }
        }

        // we do *not* unlock the memory now, the memstm structure should
        // be locked for the lifetime of any CMemStm's that refer to it.
        // when the CMemStm is destroyed, we will release our lock on
        // hMem.

        return pCMemStm;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemStm::Dump, public (_DEBUG only)
//
//  Synopsis:   return a string containing the contents of the data members
//
//  Effects:
//
//  Arguments:  [ppszDump]      - an out pointer to a null terminated character array
//              [ulFlag]        - flag determining prefix of all newlines of the
//                                out character array (default is 0 - no prefix)
//              [nIndentLevel]  - will add a indent prefix after the other prefix
//                                for ALL newlines (including those with no prefix)
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:   [ppsz]  - argument
//
//  Derivation:
//
//  Algorithm:  use dbgstream to create a string containing information on the
//              content of data structures
//
//  History:    dd-mmm-yy Author    Comment
//              20-Jan-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

HRESULT CMemStm::Dump(char **ppszDump, ULONG ulFlag, int nIndentLevel)
{
    int i;
    char *pszPrefix;
    char *pszMEMSTM;
    char *pszCMutexSem;
    dbgstream dstrPrefix;
    dbgstream dstrDump(400);

    // determine prefix of newlines
    if ( ulFlag & DEB_VERBOSE )
    {
        dstrPrefix << this << " _VB ";
    }

    // determine indentation prefix for all newlines
    for (i = 0; i < nIndentLevel; i++)
    {
        dstrPrefix << DUMPTAB;
    }

    pszPrefix = dstrPrefix.str();

    // put data members in stream
    dstrDump << pszPrefix << "Impl. Signature   = " << m_dwSig      << endl;

    dstrDump << pszPrefix << "No. of References = " << m_refs       << endl;

    dstrDump << pszPrefix << "Seek pointer      = " << m_pos        << endl;

    dstrDump << pszPrefix << "Memory handle     = " << m_hMem       << endl;

    if (m_pData != NULL)
    {
        pszMEMSTM = DumpMEMSTM(m_pData, ulFlag, nIndentLevel + 1);
        dstrDump << pszPrefix << "MEMSTM:" << endl;
        dstrDump << pszMEMSTM;
        CoTaskMemFree(pszMEMSTM);
    }
    else
    {
        dstrDump << pszPrefix << "MEMSTM            = " << m_pData      << endl;
    }

    pszCMutexSem = DumpCMutexSem ((CMutexSem2*) m_pmxs->GetMutexSem());
    dstrDump << pszPrefix << "Mutex             = " << pszCMutexSem << endl;
    CoTaskMemFree(pszCMutexSem);

    // cleanup and provide pointer to character array
    *ppszDump = dstrDump.str();

    if (*ppszDump == NULL)
    {
        *ppszDump = UtDupStringA(szDumpErrorMessage);
    }

    CoTaskMemFree(pszPrefix);

    return NOERROR;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Function:   DumpCMemStm, public (_DEBUG only)
//
//  Synopsis:   calls the CMemStm::Dump method, takes care of errors and
//              returns the zero terminated string
//
//  Effects:
//
//  Arguments:  [pMS]           - pointer to CMemStm
//              [ulFlag]        - flag determining prefix of all newlines of the
//                                out character array (default is 0 - no prefix)
//              [nIndentLevel]  - will add a indent prefix after the other prefix
//                                for ALL newlines (including those with no prefix)
//
//  Requires:
//
//  Returns:    character array of structure dump or error (null terminated)
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              20-Jan-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

char *DumpCMemStm(CMemStm *pMS, ULONG ulFlag, int nIndentLevel)
{
    HRESULT hresult;
    char *pszDump;

    if (pMS == NULL)
    {
        return UtDupStringA(szDumpBadPtr);
    }

    hresult = pMS->Dump(&pszDump, ulFlag, nIndentLevel);

    if (hresult != NOERROR)
    {
        CoTaskMemFree(pszDump);

        return DumpHRESULT(hresult);
    }

    return pszDump;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Function:   CreateMemStm
//
//  Synopsis:   Allocates memory and creates a CMemStm for it.
//
//  Effects:
//
//  Arguments:  [cb]    -- the number of bytes to allocate
//              [phMem] -- where to put a handle to the MEMSTM structure
//
//  Requires:
//
//  Returns:    LPSTREAM to the CMemStream
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              03-Dec-93 alexgo    32bit port
//
//  Notes:      phMem must be free'd with ReleaseMemStm (because of ref
//              counting and the nested handle)
//
//--------------------------------------------------------------------------

#pragma SEG(CreateMemStm)
STDAPI_(LPSTREAM) CreateMemStm(DWORD cb, LPHANDLE phMem)
{
        VDATEHEAP();

        HANDLE          h;
        LPSTREAM        pstm = NULL;

        if (phMem)
        {
                *phMem = NULL;
        }

        h = GlobalAlloc (GMEM_SHARE | GMEM_MOVEABLE, cb);
        if (NULL==h)
        {
                return NULL;
        }

        if (CreateStreamOnHGlobal (h, TRUE, &pstm) != NOERROR)
        {
                GlobalFree(h);	// COM+ 22886
                return NULL;
        }
        if (phMem)
        {
                // retrieve handle from just-created CMemStm
                *phMem = ((CMemStm FAR*)pstm)->m_hMem;

                // use pointer to bump ref count
                Assert(((CMemStm FAR*)pstm)->m_pData != NULL);
                InterlockedIncrement ((LPLONG) &((CMemStm FAR*)pstm)->m_pData->cRef);  // AddRefMemStm
        }
        return pstm;
}


//+-------------------------------------------------------------------------
//
//  Function:   CloneMemStm
//
//  Synopsis:   Clones a memory stream
//
//  Effects:
//
//  Arguments:  [hMem]  -- a handle to the MEMSTM block
//
//  Requires:
//
//  Returns:    LPSTREAM
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(CloneMemStm)

STDAPI_(LPSTREAM) CloneMemStm(HANDLE hMem)
{
        VDATEHEAP();

        return CMemStm::Create(hMem, NULL); // Create the stream
}

//+-------------------------------------------------------------------------
//
//  Function:   ReleaseMemStm
//
//  Synopsis:   Releases the memory used by a MEMSTM structure (including
//              the nested handle)
//
//  Effects:
//
//  Arguments:  [phMem]         -- pointer the MEMSTM handle
//              [fInternalOnly] -- if TRUE, then only the actual memory
//                                 that MEMSTM refers to is freed
//                                 (not the MEMSTM structure itself)
//
//  Requires:
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:   sets *phMem to NULL on success
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port and fixed bad memory access
//                                  bug
//
//  Notes:      REVIEW32:  look at taking out the second argument
//
//--------------------------------------------------------------------------

#pragma SEG(ReleaseMemStm)
STDAPI_(void) ReleaseMemStm (LPHANDLE phMem, BOOL fInternalOnly)
{
        VDATEHEAP();

        struct MEMSTM FAR*      pData;

        pData = (MEMSTM FAR*) GlobalLock(*phMem);

        // check for NULL pointer in case handle got freed already
        // decrement ref count and free if no refs left
        if (pData != NULL && InterlockedDecrement ((LPLONG) &pData->cRef) == 0)
        {
                if (pData->fDeleteOnRelease)
                {
                        Verify (0==GlobalFree (pData->hGlobal));
                }

                if (!fInternalOnly)
                {
                        GlobalUnlock(*phMem);
                        Verify (0==GlobalFree(*phMem));
                        goto End;
                }
        }

        GlobalUnlock(*phMem);
End:
        *phMem = NULL;
}

//+-------------------------------------------------------------------------
//
//  Function:   CreateStreamOnHGlobal
//
//  Synopsis:   Creates a CMemStm from the given hGlobal (if [hGlobal] is
//              NULL, we allocate a zero byte one)
//
//  Effects:
//
//  Arguments:  [hGlobal]               -- the memory
//              [fDeleteOnRelease]      -- whether the memory should be
//                                         release on delete
//              [ppstm]                 -- where to put the stream
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Jan-93 alexgo    removed initialization of cbSize to -1
//                                  to fix compile warning
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CreateStreamOnHGlobal)
STDAPI CreateStreamOnHGlobal(HANDLE hGlobal, BOOL fDeleteOnRelease,
        LPSTREAM FAR* ppstm)
{
        OLETRACEIN((API_CreateStreamOnHGlobal, PARAMFMT("hGlobal= %h, fDeleteOnRelease= %B, ppstm= %p"),
                hGlobal, fDeleteOnRelease, ppstm));

        VDATEHEAP();

        HANDLE                  hMem      = NULL;
        struct MEMSTM FAR*      pData     = NULL;
        LPSTREAM                pstm      = NULL;
        DWORD                   cbSize;
        BOOL                    fAllocated = FALSE;
        HRESULT hresult;

        VDATEPTROUT_LABEL (ppstm, LPSTREAM, SafeExit, hresult);

        *ppstm = NULL;

        if (NULL==hGlobal)
        {
                hGlobal = GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE, 0);
                if (hGlobal == NULL)
                {
                        goto FreeMem;
                }
                cbSize = 0;
                fAllocated = TRUE;
        }
        else
        {
                cbSize = (ULONG) GlobalSize (hGlobal);
                // Is there a way to verify a zero-sized handle?
                // we currently do no verification for them
                if (cbSize!=0)
                {
                        // verify validity of passed-in handle
                        if (NULL==GlobalLock(hGlobal))
                        {
                                // bad handle
                                hresult = ResultFromScode (E_INVALIDARG);
                                goto SafeExit;
                        }
                        GlobalUnlock (hGlobal);
                }
        }

        hMem = GlobalAlloc (GMEM_SHARE | GMEM_MOVEABLE, sizeof (MEMSTM));
        if (hMem == NULL)
        {
                goto FreeMem;
        }

        pData = (MEMSTM FAR*) GlobalLock(hMem);

        if (pData == NULL)
        {
                GlobalUnlock(hMem);
                goto FreeMem;
        }

        pData->cRef = 0;
        pData->cb = cbSize;
        pData->fDeleteOnRelease = fDeleteOnRelease;
        pData->hGlobal = hGlobal;
        GlobalUnlock(hMem);

        pstm = CMemStm::Create(hMem, NULL);

        if (pstm == NULL)
        {
                goto FreeMem;
        }

        *ppstm = pstm;

        CALLHOOKOBJECTCREATE(S_OK,CLSID_NULL,IID_IStream,(IUnknown **)ppstm);
        hresult = NOERROR;
        goto SafeExit;

FreeMem:
        if (hGlobal && fAllocated)
        {
	        Verify(0==GlobalFree(hGlobal));
        }
        if (hMem)
        {
            Verify(0==GlobalFree(hMem));
        }

        LEERROR(1, "Out of memory!");

        hresult = ResultFromScode(E_OUTOFMEMORY);

SafeExit:

        OLETRACEOUT((API_CreateStreamOnHGlobal, hresult));

        return hresult;
}

//+-------------------------------------------------------------------------
//
//  Function:   GetHGlobalFromStream
//
//  Synopsis:   Retrieves the HGLOBAL to the memory from the given stream
//              pointer (must be a pointer to a CMemByte structure)
//
//  Effects:
//
//  Arguments:  [pstm]          -- pointer to the CMemByte
//              [phglobal]      -- where to put the hglobal
//
//  Requires:
//
//  Returns:    HRESULT (E_INVALIDARG, E_OUTOFMEMORY, NOERROR)
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(GetHGlobalFromStream)
STDAPI GetHGlobalFromStream(LPSTREAM pstm, HGLOBAL FAR* phglobal)
{
        OLETRACEIN((API_GetHGlobalFromStream, PARAMFMT("pstm= %p, phglobal= %p"),
                pstm, phglobal));

        VDATEHEAP();

        HRESULT hresult;
        CMemStm FAR* pCMemStm;
        MEMSTM FAR* pMem;

        VDATEIFACE_LABEL (pstm, errRtn, hresult);
        VDATEPTROUT_LABEL(phglobal, HANDLE, errRtn, hresult);
        CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IStream,(IUnknown **)&pstm);

        pCMemStm = (CMemStm FAR*) pstm;

        if (!IsValidReadPtrIn (&(pCMemStm->m_dwSig), sizeof(ULONG))
                || pCMemStm->m_dwSig != STREAM_SIG)
        {
                // we were passed someone else's implementation of ILockBytes
                hresult = ResultFromScode (E_INVALIDARG);
                goto errRtn;
        }

        pMem= pCMemStm->m_pData;
        if (NULL==pMem)
        {
                LEERROR(1, "Out of memory!");

                hresult = ResultFromScode (E_OUTOFMEMORY);
                goto errRtn;
        }
        Assert (pMem->cb <= GlobalSize (pMem->hGlobal));
        Verify (*phglobal = pMem->hGlobal);

        hresult = NOERROR;

errRtn:
        OLETRACEOUT((API_GetHGlobalFromStream, hresult));

        return hresult;
}


//////////////////////////////////////////////////////////////////////////
//
// Shared memory ILockBytes implementation
//

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::QueryInterface
//
//  Synopsis:   returns the requested interface pointer
//
//  Effects:    a CMarshalMemBytes will be created if IID_IMarshal is
//              requested
//
//  Arguments:  [iidInterface]  -- the requested interface ID
//              [ppvObj]        -- where to put the interface pointer
//
//  Requires:
//
//  Returns:    NOERROR, E_OUTOFMEMORY, E_NOINTERFACE
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              11-Jan-94 alexgo    removed QI for IMarshal so that
//                                  the standard marshaller will be used.
//                                  This is to enable correct operation on
//                                  32bit platforms.
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_QueryInterface)
STDMETHODIMP CMemBytes::QueryInterface(REFIID iidInterface,
        void FAR* FAR* ppvObj)
{
        VDATEHEAP();

        HRESULT                 error;

        VDATEPTROUT( ppvObj, LPVOID );
        *ppvObj = NULL;
        VDATEIID( iidInterface );

        if (m_pData != NULL && (IsEqualIID(iidInterface, IID_ILockBytes) ||
                IsEqualIID(iidInterface, IID_IUnknown)))
        {
                InterlockedIncrement ((LPLONG) &m_refs);   // A pointer to this object is returned
                *ppvObj = this;
                error = NOERROR;
        }

        // this is not an else if because m_pData can be NULL and we
        // allow creating a CMarshalMemBytes.  REVIEW32:  We may want
        // to remove this behavior.

#ifndef WIN32
        if (IsEqualIID(iidInterface, IID_IMarshal))
        {
                *ppvObj = (LPVOID) CMarshalMemBytes::Create(this);
                if (*ppvObj != NULL)
                {
                        error = NOERROR;
                }
                else
                {
                        error = ReportResult(0, E_OUTOFMEMORY, 0, 0);
                }
        }
#endif
        else
        {
                *ppvObj = NULL;
                error = ResultFromScode(E_NOINTERFACE);
        }

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::AddRef
//
//  Synopsis:   Incrememts the reference count
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    ULONG -- the new reference count
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CMemBytes::AddRef(void)
{
        VDATEHEAP();

        return InterlockedIncrement ((LPLONG) &m_refs);
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::Release
//
//  Synopsis:   decrements the reference count
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    ULONG -- the new reference count
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              16-Dec-93 alexgo    added GlobalUnlock to match the Global
//                                  Lock in Create
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CMemBytes::Release(void)
{
        VDATEHEAP();

        ULONG ulRefs = InterlockedDecrement ((LPLONG) &m_refs);

        if (ulRefs != 0)
        {
                return ulRefs;
        }

        // GlobalUnlock the m_hMem that we GlobalLocke'd in Create
        GlobalUnlock(m_hMem);

        ReleaseMemStm(&m_hMem);

        delete this;
        return 0;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::ReadAt
//
//  Synopsis:   reads [cb] bytes from starting position [ulOffset]
//
//  Effects:
//
//  Arguments:  [ulOffset]      -- the offset to start reading from
//              [pb]            -- where to put the data
//              [cb]            -- the number of bytes to read
//              [pcbRead]       -- where to put the number of bytes actually
//                                 read
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:  just calls xmemcpy
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_ReadAt)
STDMETHODIMP CMemBytes::ReadAt(ULARGE_INTEGER ulOffset, void HUGEP* pb,
        ULONG cb, ULONG FAR* pcbRead)
{
        VDATEHEAP();

        HRESULT         error   = NOERROR;
        ULONG           cbRead  = cb;

        VDATEPTROUT( pb, char );

        // make sure we don't offset out of the address space!
        AssertSz(ulOffset.HighPart == 0,
                "CMemBytes: offset greater than 2^32");

        if (pcbRead)
        {
                *pcbRead = 0L;
        }

        if (cbRead + ulOffset.LowPart > m_pData->cb)
        {

                if (ulOffset.LowPart > m_pData->cb)
                {
                        // the offset overruns the size of the memory
                        cbRead = 0;
                }
                else
                {
                        // just read what's left
                        cbRead = m_pData->cb - ulOffset.LowPart;
                }
        }

        if (cbRead > 0)
        {
                BYTE HUGEP* pGlobal = (BYTE HUGEP *)GlobalLock(
                        m_pData->hGlobal);
                if (NULL==pGlobal)
                {
                        LEERROR(1, "GlobalLock failed!");

                        return ResultFromScode (STG_E_READFAULT);
                }
                _xmemcpy(pb, pGlobal + ulOffset.LowPart, cbRead);
                GlobalUnlock (m_pData->hGlobal);
        }

        if (pcbRead != NULL)
        {
                *pcbRead = cbRead;
        }

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::WriteAt
//
//  Synopsis:   writes [cb] bytes at [ulOffset] in the stream
//
//  Effects:
//
//  Arguments:  [ulOffset]      -- the offset at which to start writing
//              [pb]            -- the buffer to read from
//              [cb]            -- the number of bytes to write
//              [pcbWritten]    -- where to put the number of bytes written
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_WriteAt)
STDMETHODIMP CMemBytes::WriteAt(ULARGE_INTEGER ulOffset, void const HUGEP* pb,
        ULONG cb, ULONG FAR* pcbWritten)
{
        VDATEHEAP();

        HRESULT         error           = NOERROR;
        ULONG           cbWritten       = cb;
        BYTE HUGEP*     pGlobal;

        VDATEPTRIN( pb, char );

        // make sure the offset doesn't go beyond our address space!

        AssertSz(ulOffset.HighPart == 0, "WriteAt, offset greater than 2^32");

        if (pcbWritten)
        {
                *pcbWritten = 0;
        }

        if (cbWritten + ulOffset.LowPart > m_pData->cb)
        {
                ULARGE_INTEGER ularge_integer;
                ULISet32( ularge_integer, ulOffset.LowPart + cbWritten);
                error = SetSize( ularge_integer );
                if (error != NOERROR)
                {
                        goto Exit;
                }
        }

        // CMemBytes does not allow zero-sized memory handles

        pGlobal = (BYTE HUGEP *)GlobalLock (m_pData->hGlobal);

        if (NULL==pGlobal)
        {
                LEERROR(1, "GlobalLock failed!");

                return ResultFromScode (STG_E_WRITEFAULT);
        }

        _xmemcpy(pGlobal + ulOffset.LowPart, pb, cbWritten);
        GlobalUnlock (m_pData->hGlobal);


        if (pcbWritten != NULL)
        {
                *pcbWritten = cbWritten;
        }

Exit:
        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::Flush
//
//  Synopsis:   Flushes internal state to disk
//              Not needed for memory ILockBytes
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    NOERROR
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_Flush)
STDMETHODIMP CMemBytes::Flush(void)
{
        VDATEHEAP();

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::SetSize
//
//  Synopsis:   Sets the size of the memory buffer
//
//  Effects:
//
//  Arguments:  [cb]    -- the new size
//
//  Requires:
//
//  Returns:    NOERROR, E_OUTOFMEMORY
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_SetSize)
STDMETHODIMP CMemBytes::SetSize(ULARGE_INTEGER cb)
{
        VDATEHEAP();

        HANDLE          hMemNew;

        AssertSz(cb.HighPart == 0,
                "SetSize: trying to set to more than 2^32 bytes");

        if (m_pData->cb == cb.LowPart)
        {
                return NOERROR;
        }

        hMemNew = GlobalReAlloc(m_pData->hGlobal, max (cb.LowPart, 1),
                GMEM_SHARE | GMEM_MOVEABLE);

        if (hMemNew == NULL)
        {
                return ResultFromScode(E_OUTOFMEMORY);
        }

        m_pData->hGlobal = hMemNew;
        m_pData->cb = cb.LowPart;

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::LockRegion
//
//  Synopsis:   Locks a region.  Since only we have access to the memory,
//              nothing needs to be done (note that the *app* also may
//              access, but there's not much we can do about that)
//
//  Effects:
//
//  Arguments:  [libOffset]     -- offset to start with
//              [cb]            -- the number of bytes in the locked region
//              [dwLockType]    -- the type of lock to use
//
//  Requires:
//
//  Returns:    NOERROR
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_LockRegion)
STDMETHODIMP CMemBytes::LockRegion(ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb, DWORD dwLockType)
{
        VDATEHEAP();

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::UnlockRegion
//
//  Synopsis:   Unlocks a region; since only we have access to the memory,
//              nothing needs to be done.
//
//  Effects:
//
//  Arguments:  [libOffset]     -- the offset to start with
//              [cb]            -- the number of bytes in the region
//              [dwLockType]    -- the lock type
//
//  Requires:
//
//  Returns:    NOERROR
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_UnlockRegion)
STDMETHODIMP CMemBytes::UnlockRegion(ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb, DWORD dwLockType)
{
        VDATEHEAP();

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::Stat
//
//  Synopsis:   returns status information
//
//  Effects:
//
//  Arguments:  [pstatstg]      -- where to put the status info
//              [statflag]      -- status flags (ignored)
//
//  Requires:
//
//  Returns:    NOERROR, E_INVALIDARG
//
//  Signals:
//
//  Modifies:
//
//  Derivation: ILockBytes
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//              01-Jun-94 AlexT     Set type correctly
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_Stat)
STDMETHODIMP CMemBytes::Stat(STATSTG FAR *pstatstg, DWORD statflag)
{
        VDATEHEAP();

        VDATEPTROUT( pstatstg, STATSTG );

        memset ( pstatstg, 0, sizeof(STATSTG) );

        pstatstg->type                  = STGTY_LOCKBYTES;
        pstatstg->cbSize.LowPart        = m_pData->cb;

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::Create
//
//  Synopsis:   Creates an instance of CMemBytes
//
//  Effects:
//
//  Arguments:  [hMem]  -- handle to the memory (must be a MEMSTM block)
//
//  Requires:
//
//  Returns:    CMemBytes *
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              16-Dec-93 alexgo    fixed bad pointer bug (took out
//                                  GlobalUnlock)
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMemBytes_Create)
STDSTATICIMP_(CMemBytes FAR*) CMemBytes::Create(HANDLE hMem)
{
        VDATEHEAP();

        CMemBytes FAR*          pCMemBytes = NULL;
        struct MEMSTM FAR*      pData;

        pData = (MEMSTM FAR*) GlobalLock(hMem);

        if (pData != NULL)
        {
                Assert (pData->hGlobal);

                pCMemBytes = new CMemBytes;

                if (pCMemBytes != NULL)
                {
                        // Initialize CMemBytes
                        pCMemBytes->m_dwSig = LOCKBYTE_SIG;
                        pCMemBytes->m_hMem = hMem;
                        InterlockedIncrement ((LPLONG) &(pCMemBytes->m_pData = pData)->cRef); // AddRefMemStm
                        pCMemBytes->m_refs = 1;
                        CALLHOOKOBJECTCREATE(S_OK,CLSID_NULL,IID_ILockBytes,
                                             (IUnknown **)&pCMemBytes);
                }
                else
                {
                        // uh-oh, low on memory
                        GlobalUnlock(hMem);
                }
        }

        // we don't GlobalUnlock(hMem) until we destory this CMemBytes
        return pCMemBytes;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMemBytes::Dump, public (_DEBUG only)
//
//  Synopsis:   return a string containing the contents of the data members
//
//  Effects:
//
//  Arguments:  [ppszDump]      - an out pointer to a null terminated character array
//              [ulFlag]        - flag determining prefix of all newlines of the
//                                out character array (default is 0 - no prefix)
//              [nIndentLevel]  - will add a indent prefix after the other prefix
//                                for ALL newlines (including those with no prefix)
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:   [ppsz]  - argument
//
//  Derivation:
//
//  Algorithm:  use dbgstream to create a string containing information on the
//              content of data structures
//
//  History:    dd-mmm-yy Author    Comment
//              20-Jan-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

HRESULT CMemBytes::Dump(char **ppszDump, ULONG ulFlag, int nIndentLevel)
{
    int i;
    char *pszPrefix;
    char *pszMEMSTM;
    dbgstream dstrPrefix;
    dbgstream dstrDump(400);

    // determine prefix of newlines
    if ( ulFlag & DEB_VERBOSE )
    {
        dstrPrefix << this << " _VB ";
    }

    // determine indentation prefix for all newlines
    for (i = 0; i < nIndentLevel; i++)
    {
        dstrPrefix << DUMPTAB;
    }

    pszPrefix = dstrPrefix.str();

    // put data members in stream
    dstrDump << pszPrefix << "Impl. Signature   = " << m_dwSig  << endl;

    dstrDump << pszPrefix << "No. of References = " << m_refs   << endl;

    dstrDump << pszPrefix << "Memory handle     = " << m_hMem   << endl;

    if (m_pData != NULL)
    {
        pszMEMSTM = DumpMEMSTM(m_pData, ulFlag, nIndentLevel + 1);
        dstrDump << pszPrefix << "MEMSTM:"                      << endl;
        dstrDump << pszMEMSTM;
        CoTaskMemFree(pszMEMSTM);
    }
    else
    {
        dstrDump << pszPrefix << "MEMSTM            = " << m_pData  << endl;
    }

    // cleanup and provide pointer to character array
    *ppszDump = dstrDump.str();

    if (*ppszDump == NULL)
    {
        *ppszDump = UtDupStringA(szDumpErrorMessage);
    }

    CoTaskMemFree(pszPrefix);

    return NOERROR;
}

#endif // _DEBUG

//+-------------------------------------------------------------------------
//
//  Function:   DumpCMemBytes, public (_DEBUG only)
//
//  Synopsis:   calls the CMemBytes::Dump method, takes care of errors and
//              returns the zero terminated string
//
//  Effects:
//
//  Arguments:  [pMB]           - pointer to CMemBytes
//              [ulFlag]        - flag determining prefix of all newlines of the
//                                out character array (default is 0 - no prefix)
//              [nIndentLevel]  - will add a indent prefix after the other prefix
//                                for ALL newlines (including those with no prefix)
//
//  Requires:
//
//  Returns:    character array of structure dump or error (null terminated)
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              20-Jan-95 t-ScottH  author
//
//  Notes:
//
//--------------------------------------------------------------------------

#ifdef _DEBUG

char *DumpCMemBytes(CMemBytes *pMB, ULONG ulFlag, int nIndentLevel)
{
    HRESULT hresult;
    char *pszDump;

    if (pMB == NULL)
    {
        return UtDupStringA(szDumpBadPtr);
    }

    hresult = pMB->Dump(&pszDump, ulFlag, nIndentLevel);

    if (hresult != NOERROR)
    {
        CoTaskMemFree(pszDump);

        return DumpHRESULT(hresult);
    }

    return pszDump;
}

#endif // _DEBUG

// --------------------------------------------------------------------
// EVERYTHING BELOW HERE HAS BEEN REMOVED FROM WIN32 VERSIONS.

#ifndef WIN32

// CMemStm object's IMarshal implementation
//

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::QueryInterface
//
//  Synopsis:   returns the requested interface ID
//
//  Effects:
//
//  Arguments:  [iidInterface]  -- the requested interface
//              [ppvObj]        -- where to put the interface pointer
//
//  Requires:
//
//  Returns:    NOERROR, E_NOINTERFACE
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_QueryInterface)
STDMETHODIMP CMarshalMemStm::QueryInterface(REFIID iidInterface,
        void FAR* FAR* ppvObj)
{
        VDATEHEAP();

        HRESULT         error;

        VDATEPTROUT( ppvObj, LPVOID );
        *ppvObj = NULL;
        VDATEIID( iidInterface );

        // Two interfaces supported: IUnknown, IMarshal

        if (IsEqualIID(iidInterface, IID_IMarshal) ||
                IsEqualIID(iidInterface, IID_IUnknown))
        {
                InterlockedIncrement (&m_refs);           // A pointer to this object is returned
                *ppvObj = this;
                error = NOERROR;
        }
        else
        {
                // Not accessible or unsupported interface
                *ppvObj = NULL;
                error = ResultFromScode (E_NOINTERFACE);
        }

        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemstm::AddRef
//
//  Synopsis:   increments the reference count
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    ULONG -- the new reference count
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_AddRef)
STDMETHODIMP_(ULONG) CMarshalMemStm::AddRef(void)
{
        VDATEHEAP();

        return InterlockedIncrement (&m_refs);
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::Release
//
//  Synopsis:   decrements the reference count
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    ULONG -- the new reference count
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_Release)
STDMETHODIMP_(ULONG) CMarshalMemStm::Release(void)
{
        VDATEHEAP();

        ULONG ulRefs = InterlockedDecrement (&m_refs);

        if (ulRefs != 0)
        {
                return ulRefs;
        }

        if (m_pMemStm != NULL)
        {
                m_pMemStm->Release();
        }

        delete this; // Free storage
        return 0;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::GetUnmarshalClass
//
//  Synopsis:   returns the object class that should be used to create
//              the proxy in the unmarshalling process (CLSID_StdMemStm)
//
//  Effects:
//
//  Arguments:  [riid]          -- the interface ID of the object to be
//                                 marshalled
//              [pv]            -- pointer to the object
//              [dwDestContext] -- marshalling context (such a no shared mem)
//              [pvDestContext] -- reserved
//              [mshlfags]      -- marshalling flags (e.g. NORMAL)
//              [pCid]          -- where to put the class ID
//
//  Requires:
//
//  Returns:    NOERROR
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_GetUnmarshalClass)
STDMETHODIMP CMarshalMemStm::GetUnmarshalClass(REFIID riid, LPVOID pv,
        DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags,
        CLSID FAR* pCid)
{
        VDATEHEAP();

        VDATEPTROUT( pCid, CLSID);

        *pCid = CLSID_StdMemStm;

        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::GetUnmarshalSizeMax
//
//  Synopsis:   returns the amount of memory needed to marshal the data
//              (in this case, the hglobal)
//
//  Effects:
//
//  Arguments:  [riid]          -- the interface of the object
//              [pv]            -- pointer to the object
//              [dwDestContext] -- marshalling context (such a no shared mem)
//              [pvDestContext] -- reserved
//              [mshlfags]      -- marshalling flags (e.g. NORMAL)
//              [pSize]         -- where to put the size
//
//  Requires:
//
//  Returns:    NOERROR, E_INVALIDARG
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_GetMarshalSizeMax)
STDMETHODIMP CMarshalMemStm::GetMarshalSizeMax(REFIID riid, LPVOID pv,
        DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags,
        DWORD FAR* pSize)
{
        VDATEHEAP();

        VDATEPTROUT(pSize, DWORD);

        *pSize = sizeof(m_pMemStm->m_hMem);
        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::MarshalInterface
//
//  Synopsis:   marshals a reference of the objects interface into [pStm]
//
//  Effects:
//
//  Arguments:  [pStm]          -- the stream into which the object should
//                                 be marshalled
//              [riid]          -- the interface ID of the object to be
//                                 marshalled
//              [pv]            -- points to the interface
//              [dwDestContext] -- the marshalling context
//              [pvDestContext] -- unused
//              [mshlflags]     -- marshalling flags
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_MarshalInterface)
STDMETHODIMP CMarshalMemStm::MarshalInterface(IStream FAR* pStm,
        REFIID riid, void FAR* pv, DWORD dwDestContext,
        LPVOID pvDestContext, DWORD mshlflags)
{
        VDATEHEAP();

        VDATEPTRIN( pStm, IStream );
        VDATEIID( riid );
        VDATEIFACE( pv );

        if (m_pMemStm == NULL)
        {
                return ResultFromScode(E_UNSPEC);
        }

        if ((!IsEqualIID(riid, IID_IStream) &&
                !IsEqualIID(riid, IID_IUnknown)) || pv != m_pMemStm)
        {
                return ReportResult(0, E_INVALIDARG, 0, 0);
        }

        // increase ref count on hglobal (ReleaseMarshalData has -- to match)
        HRESULT error;
        if ((error = pStm->Write(&m_pMemStm->m_hMem,
                sizeof(m_pMemStm->m_hMem), NULL)) == NOERROR)
        {
                InterlockedIncrement (&m_pMemStm->m_pData->cRef);     // AddRefMemStm
        }
        return error;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::UnmarshalInterface
//
//  Synopsis:   Unmarshals an the object from the given stream
//
//  Effects:
//
//  Arguments:  [pStm]          -- the stream to read data from
//              [riid]          -- the interface the caller wants from the
//                                 object
//              [ppvObj]        -- where to put a pointer to the object
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Derivation: IMarshal
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              05-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

#pragma SEG(CMarshalMemStm_UnmarshalInterface)
STDMETHODIMP CMarshalMemStm::UnmarshalInterface(IStream FAR* pStm,
        REFIID riid, void FAR* FAR* ppv)
{
        VDATEHEAP();

        HRESULT         error;
        HANDLE          hMem;

        VDATEPTROUT( ppv, LPVOID );
        *ppv = NULL;
        VDATEPTRIN( pStm, IStream );
        VDATEIID( riid );

        if (!IsEqualIID(riid, IID_IStream) && !IsEqualIID(riid, IID_IUnknown))
        {
                return ResultFromScode(E_INVALIDARG);
        }

        error = pStm->Read(&hMem,sizeof(hMem),NULL);
        if (error != NOERROR)
        {
                return error;
        }

        if (m_pMemStm != NULL)
        {
                if (hMem != m_pMemStm->m_hMem)
                {
                        return ResultFromScode(E_UNSPEC);
                }
        }
        else
        {
                m_pMemStm = (CMemStm FAR*) CloneMemStm(hMem);
                if (m_pMemStm == NULL)
                {
                        return ResultFromScode(E_OUTOFMEMORY);
                }
        }

        m_pMemStm->AddRef();
        *ppv = (LPVOID) m_pMemStm;
        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:     CMarshalMemStm::ReleaseMarshalData
//
//  Synopsis:   releases the marshalling data (takes away ref count on
//              hglobal)
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemStm_ReleaseMarshalData)
STDMETHODIMP CMarshalMemStm::ReleaseMarshalData(IStream FAR* pStm)
{
        VDATEHEAP();

        // reduce ref count on hglobal (matches that done in MarshalInterface)
        HRESULT error;
        HANDLE hMem;

    VDATEIFACE( pStm );

    error = pStm->Read(&hMem,sizeof(hMem),NULL);
    if (error == NOERROR)
                ReleaseMemStm(&hMem);

        return error;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemStm_DisconnectObject)
STDMETHODIMP CMarshalMemStm::DisconnectObject(DWORD dwReserved)
{
        VDATEHEAP();

        return NOERROR;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemStm_Create)
STDSTATICIMP_(CMarshalMemStm FAR*) CMarshalMemStm::Create(CMemStm FAR* pMemStm)
{
        VDATEHEAP();

    CMarshalMemStm FAR* pMMS;

        //VDATEPTRIN rejects NULL
        if( pMemStm )
        GEN_VDATEPTRIN( pMemStm, CMemStm, (CMarshalMemStm FAR *) NULL );

    pMMS = new(MEMCTX_TASK, NULL) CMarshalMemStm;

    if (pMMS == NULL)
        return NULL;

    if (pMemStm != NULL) {
        pMMS->m_pMemStm = pMemStm;
        pMMS->m_pMemStm->AddRef();
    }

    pMMS->m_refs = 1;

    return pMMS;
}


//+-------------------------------------------------------------------------
//
//  Function:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMemStmUnMarshal)
STDAPI_(IUnknown FAR*) CMemStmUnMarshal(void)
{
        VDATEHEAP();

    return CMarshalMemStm::Create(NULL);
}



// CMemBytes object's IMarshal implementation
//

//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_QueryInterface)
STDMETHODIMP CMarshalMemBytes::QueryInterface(REFIID iidInterface,
                                                    void FAR* FAR* ppvObj)
{
        VDATEHEAP();

        HRESULT error;

        VDATEIID( iidInterface );
        VDATEPTROUT( ppvObj, LPVOID );
        *ppvObj = NULL;

        // Two interfaces supported: IUnknown, IMarshal

        if (IsEqualIID(iidInterface, IID_IMarshal)
                || IsEqualIID(iidInterface, IID_IUnknown))
        {
                InterlockedIncrement (&m_refs);           // A pointer to this object is returned
                *ppvObj = this;
                error = NOERROR;
        }
        else
        {                  // Not accessible or unsupported interface
                *ppvObj = NULL;
                error = ReportResult(0, E_NOINTERFACE, 0, 0);
        }

        return error;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


// Called when CMarshalMemBytes is referenced by an additional pointer.
//

#pragma SEG(CMarshalMemBytes_AddRef)
STDMETHODIMP_(ULONG) CMarshalMemBytes::AddRef(void)
{
        VDATEHEAP();

        return InterlockedIncrement (&m_refs);
}

//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_Release)
// Called when a pointer to this CMarshalMemBytes is discarded
//
STDMETHODIMP_(ULONG) CMarshalMemBytes::Release(void)
{
        VDATEHEAP();

        ULONG ulRefs = InterlockedDecrement (&m_refs);

        if (ulRefs != 0) // Still used by others
                return ulRefs;

        if (m_pMemBytes != NULL)
                m_pMemBytes->Release();

        delete this; // Free storage
        return 0;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_GetUnmarshalClass)
// Returns the clsid of the object that created this CMarshalMemBytes.
//
STDMETHODIMP CMarshalMemBytes::GetUnmarshalClass(REFIID riid, LPVOID pv,
    DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags, CLSID FAR* pCid)
{
        VDATEHEAP();

        VDATEIID( riid );
        VDATEIFACE( pv );

        *pCid = CLSID_StdMemBytes;
        return NOERROR;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_GetMarshalSizeMax)
STDMETHODIMP CMarshalMemBytes::GetMarshalSizeMax(REFIID riid, LPVOID pv,
    DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags, DWORD FAR* pSize)
{
        VDATEHEAP();

        VDATEPTROUT( pSize, DWORD );
        VDATEIID( riid );
        VDATEIFACE( pv );

        *pSize = sizeof(m_pMemBytes->m_hMem);
        return NOERROR;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_MarshalInterface)
STDMETHODIMP CMarshalMemBytes::MarshalInterface(IStream FAR* pStm,
    REFIID riid, void FAR* pv, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags)
{
        VDATEHEAP();

        VDATEPTRIN(pStm, IStream );
        VDATEIID( riid );
        if ( pv )
                VDATEPTRIN( pv , char );

        if (m_pMemBytes == NULL)
                return ReportResult(0, E_UNSPEC, 0, 0);

        if ((!IsEqualIID(riid, IID_ILockBytes) &&
                        !IsEqualIID(riid, IID_IUnknown)) || pv != m_pMemBytes)
                return ReportResult(0, E_INVALIDARG, 0, 0);

        // increase ref count on hglobal (ReleaseMarshalData has -- to match)
        HRESULT error;

        if ((error = pStm->Write(&m_pMemBytes->m_hMem,
                sizeof(m_pMemBytes->m_hMem), NULL)) == NOERROR)
                InterlockedIncrement (&m_pMemBytes->m_pData->cRef);   // AddRefMemStm

        return error;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_UnmarshalInterface)
STDMETHODIMP CMarshalMemBytes::UnmarshalInterface(IStream FAR* pStm,
                                 REFIID riid, void FAR* FAR* ppv)
{
        VDATEHEAP();

        HRESULT error;
        HANDLE hMem;

        VDATEPTROUT( ppv , LPVOID );
        *ppv = NULL;
        VDATEIFACE( pStm );
        VDATEIID( riid );


        if (!IsEqualIID(riid, IID_ILockBytes) &&
                !IsEqualIID(riid, IID_IUnknown))
                return ReportResult(0, E_INVALIDARG, 0, 0);

        error = pStm->Read(&hMem,sizeof(hMem),NULL);
        if (error != NOERROR)
                return error;

        if (m_pMemBytes != NULL)
        {
                if (hMem != m_pMemBytes->m_hMem)
                        return ReportResult(0, E_UNSPEC, 0, 0);
        }
        else
        {
                m_pMemBytes = CMemBytes::Create(hMem); // Create the lockbytes

                if (m_pMemBytes == NULL)
                        return ReportResult(0, E_OUTOFMEMORY, 0, 0);
        }

        m_pMemBytes->AddRef();
        *ppv = (LPVOID) m_pMemBytes;
        return NOERROR;
}

//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------



STDMETHODIMP CMarshalMemBytes::ReleaseMarshalData(IStream FAR* pStm)
{
        VDATEHEAP();

        // reduce ref count on hglobal (matches that done in MarshalInterface)
        HRESULT error;
        HANDLE hMem;

        VDATEIFACE( pStm );

        error = pStm->Read(&hMem,sizeof(hMem),NULL);
        if (error == NOERROR)
                ReleaseMemStm(&hMem);

        return error;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_DisconnectObject)
STDMETHODIMP CMarshalMemBytes::DisconnectObject(DWORD dwReserved)
{
        VDATEHEAP();

        return NOERROR;
}


//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------


#pragma SEG(CMarshalMemBytes_Create)
STDSTATICIMP_(CMarshalMemBytes FAR*) CMarshalMemBytes::Create(
                                                      CMemBytes FAR* pMemBytes)
{
        VDATEHEAP();

        CMarshalMemBytes FAR* pMMB;

        //VDATEPTRIN rejects NULL
        if( pMemBytes )
                GEN_VDATEPTRIN( pMemBytes, CMemBytes,
                    (CMarshalMemBytes FAR *)NULL);

        pMMB = new(MEMCTX_TASK, NULL) CMarshalMemBytes;

        if (pMMB == NULL)
                return NULL;

        if (pMemBytes != NULL)
        {
                pMMB->m_pMemBytes = pMemBytes;
                pMMB->m_pMemBytes->AddRef();
        }

        pMMB->m_refs = 1;

        return pMMB;
}

//+-------------------------------------------------------------------------
//
//  Member:
//
//  Synopsis:
//
//  Effects:
//
//  Arguments:
//
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Derivation:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//
//  Notes:
//
//--------------------------------------------------------------------------



#pragma SEG(CMemBytesUnMarshal)
STDAPI_(IUnknown FAR*) CMemBytesUnMarshal(void)
{
        VDATEHEAP();

        return CMarshalMemBytes::Create(NULL);
}

#endif   // !WIN32  -- win32 builds use standard marshalling for
        // streams and lockbytes.