// --------------------------------------------------------------------------------
// Vstream.cpp
// Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
// Ronald E. Gray
// --------------------------------------------------------------------------------
#include "pch.hxx"
#include "vstream.h"
#include "dllmain.h"
#include "demand.h"

// --------------------------------------------------------------------------------
// Utilities
// --------------------------------------------------------------------------------
inline ULONG ICeil(ULONG x, ULONG interval)
{
    return (x ? (((x-1)/interval) + 1) * interval : 0);
}

// --------------------------------------------------------------------------------
// CVirtualStream::CVirtualStream
// --------------------------------------------------------------------------------
CVirtualStream::CVirtualStream(void)
{
    m_cRef          = 1; 
    m_cbSize        = 0;
    m_cbCommitted   = 0;
    m_cbAlloc       = 0;
    m_dwOffset      = 0;
    m_pstm          = NULL;
    m_pb            = 0;
    m_fFileErr      = FALSE;
    InitializeCriticalSection(&m_cs);
}

// --------------------------------------------------------------------------------
// CVirtualStream::~CVirtualStream
// --------------------------------------------------------------------------------
CVirtualStream::~CVirtualStream(void)
{
    if (m_pb)
        VirtualFree(m_pb, 0, MEM_RELEASE);
    if (m_pstm)
        m_pstm->Release();

    DeleteCriticalSection(&m_cs);
}

// --------------------------------------------------------------------------------
// CVirtualStream::QueryInterface
// --------------------------------------------------------------------------------
STDMETHODIMP CVirtualStream::QueryInterface(REFIID riid, LPVOID *ppv)
{
    // check params
    if (ppv == NULL)
        return TrapError(E_INVALIDARG);

    // Init
    *ppv = NULL;

    // Find IID
    if (    (IID_IUnknown == riid)
        ||  (IID_IStream == riid)
        ||  (IID_IVirtualStream == riid))
        *ppv = (IStream *)this;
    else
    {
        *ppv = NULL;
        return TrapError(E_NOINTERFACE);
    }

    // AddRef It
    AddRef();

    // Done
    return (ResultFromScode(S_OK));
}

// --------------------------------------------------------------------------------
// CVirtualStream::AddRef
// --------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CVirtualStream::AddRef(void)
{
    return InterlockedIncrement((LONG*)&m_cRef);
}


// --------------------------------------------------------------------------------
// CVirtualStream::SyncFileStream
// --------------------------------------------------------------------------------
HRESULT CVirtualStream::SyncFileStream()
{
    LARGE_INTEGER   li;
    HRESULT         hr;

    // figure out where to set the file stream be subtracting the memory portion
    // of the stream from the offset
#ifdef MAC
    if (m_dwOffset < m_cbAlloc)
        LISet32(li, 0);
    else
    {
        LISet32(li, m_dwOffset);
        li.LowPart -= m_cbAlloc;
    }
#else   // !MAC
    if (m_dwOffset < m_cbAlloc)
        li.QuadPart = 0;
    else
        li.QuadPart = m_dwOffset - m_cbAlloc;
#endif  // MAC

    // seek in the stream
    hr = m_pstm->Seek(li, STREAM_SEEK_SET, NULL);

    // reset the file err member based on the current error
    m_fFileErr = !!hr;

    return hr;
}
// --------------------------------------------------------------------------------
// CVirtualStream::Release
// --------------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CVirtualStream::Release(void)
{
    ULONG cRef = InterlockedDecrement((LONG*)&m_cRef);
    if (0 != cRef)
    {
#ifdef	DEBUG
        return cRef;
#else
        return 0;
#endif
    }
    delete this;
    return 0;
}

// --------------------------------------------------------------------------------
// CVirtualStream::Read
// --------------------------------------------------------------------------------
#ifndef WIN16
STDMETHODIMP CVirtualStream::Read(LPVOID pv, ULONG cb, ULONG *pcbRead)
#else
STDMETHODIMP CVirtualStream::Read(VOID HUGEP *pv, ULONG cb, ULONG *pcbRead)
#endif // !WIN16
{
    // Locals
    HRESULT     hr      = ResultFromScode(S_OK);
    ULONG       cbGet   = 0;

        // Check
    AssertWritePtr(pv, cb);

    // Thread Safety
    EnterCriticalSection(&m_cs);

    // if the steam pointer is possibly out of sync
    // resync
    if (m_fFileErr)
    {
        hr = SyncFileStream();
        if (hr) goto err;
    }
    
    // make sure there's something to read
    if (m_dwOffset < m_cbSize)
    {
        // figure out what we're getting out of memory
        if (m_dwOffset < m_cbCommitted)
        {
            if (m_cbSize > m_cbCommitted)
                cbGet = min(cb, m_cbCommitted - m_dwOffset);
            else
                cbGet = min(cb, m_cbSize - m_dwOffset);
            // copy the memory stuff
            CopyMemory((LPBYTE)pv, m_pb + m_dwOffset, cbGet);

        }

        // if we still have stuff to read
        // and we've used all of the memory
        // and we do have a stream, try to get the rest of the data out of the stream
        if (    (cbGet != cb)
           &&   (m_cbCommitted == m_cbAlloc)
           &&   m_pstm)
        {
            ULONG           cbRead;

    #ifdef	DEBUG
            LARGE_INTEGER   li  = {0, 0};
            ULARGE_INTEGER  uli = {0, 0};

            if (!m_pstm->Seek(li, STREAM_SEEK_CUR, &uli))
#ifdef MAC
                Assert(((m_dwOffset + cbGet) - m_cbAlloc) == uli.LowPart);
#else   // !MAC
                Assert(((m_dwOffset + cbGet) - m_cbAlloc) == uli.QuadPart);
#endif  // MAC
    #endif
            hr = m_pstm->Read(((LPBYTE)pv) + cbGet, cb - cbGet, &cbRead);
            if (hr)
            {
                m_fFileErr = TRUE;
                goto err;
            }

            cbGet += cbRead;
        }

        m_dwOffset += cbGet;
    }
    
    if (pcbRead)
        *pcbRead = cbGet;
err:
    // Thread Safety
    LeaveCriticalSection(&m_cs);

    // Done
    return hr;
}

// --------------------------------------------------------------------------------
// CVirtualStream::SetSize
// --------------------------------------------------------------------------------
HRESULT CVirtualStream::SetSize(ULARGE_INTEGER uli)
{
    // Locals
    HRESULT     hr          = ResultFromScode(S_OK);
    ULONG       cbDemand    = uli.LowPart;
    ULONG       cbCommit    = ICeil(cbDemand, g_dwSysPageSize);
    
    if (uli.HighPart != 0)
		return(ResultFromScode(STG_E_MEDIUMFULL));
        
    // Thread Safety
    EnterCriticalSection(&m_cs);
    
    // if we haven't initialized memory, do it now
    if (!m_cbAlloc)
    {
        LPVOID  pv;
        ULONG   cb  = 32 * g_dwSysPageSize; // use 32 pages

        while ((!(pv = VirtualAlloc(NULL, cb, MEM_RESERVE, PAGE_READWRITE)))
               && (cb > g_dwSysPageSize))
        {
            cb /= 2;
        }
        if (!pv)
        {
            hr = ResultFromScode(E_OUTOFMEMORY);
            goto err;
        }
        m_cbAlloc   = cb;
        m_pb        = (LPBYTE)pv;
    }
        
    if (cbCommit  < m_cbCommitted)
    {
        // shrink the stream
        LPBYTE  pb  =m_pb;
        ULONG   cb;

        // figure out the begining of the last page in the range not used
        pb += cbCommit;

        // figure out the size of the range being decommitted
        cb = m_cbCommitted - cbCommit;
                  
#ifndef MAC
        VirtualFree(pb, cb, MEM_DECOMMIT);
#endif  // !MAC

        // figure out what we have left committed
        m_cbCommitted = cbCommit;
        
    }
    else if (cbCommit > m_cbCommitted)
    {
        LPBYTE  pb;

        // figure out how much memory to commit
        cbCommit = (cbDemand <= m_cbAlloc)
                   ?    ICeil(cbDemand,  g_dwSysPageSize)
                   :    m_cbAlloc;

        if (cbCommit > m_cbCommitted)
        {
#ifndef MAC
            if (!VirtualAlloc(m_pb, cbCommit, MEM_COMMIT, PAGE_READWRITE))
            {
                hr = ResultFromScode(E_OUTOFMEMORY);
                goto err;
            }
#endif  // !MAC
        }

        m_cbCommitted = cbCommit;

        // Wow, we've used all of memory, start up the disk
        if (cbDemand > m_cbAlloc)
        {
            ULARGE_INTEGER uliAlloc;

            // no stream? better create it now
            if (!m_pstm)
            {                
                hr = CreateTempFileStream(&m_pstm);
                if (hr) goto err;
            }
            uliAlloc.LowPart = cbDemand - m_cbAlloc;
            uliAlloc.HighPart = 0;
            
            hr = m_pstm->SetSize(uliAlloc);
            if (hr) goto err;
            
            // if the current offset beyond the end of the memory allocation,
            // initialize the stream pointer correctly
            if (m_dwOffset > m_cbAlloc)
            {
                hr = SyncFileStream();
                if (hr) goto err;
            }
        }
    }

    m_cbSize = cbDemand;
    
err:
    // Thread Safety
    LeaveCriticalSection(&m_cs);
    // Done
    return hr;
}

// --------------------------------------------------------------------------------
// CVirtualStream::QueryStat
// --------------------------------------------------------------------------------
STDMETHODIMP CVirtualStream::Stat(STATSTG *pStat, DWORD grfStatFlag)
{
    // Invalid Arg
    if (NULL == pStat)
        return TrapError(E_INVALIDARG);

    // Fill pStat
    pStat->type = STGTY_STREAM;
    pStat->cbSize.HighPart = 0;
    pStat->cbSize.LowPart = m_cbSize;

    // Done
    return S_OK;
}

// --------------------------------------------------------------------------------
// CVirtualStream::QueryStat
// --------------------------------------------------------------------------------
void CVirtualStream::QueryStat(ULARGE_INTEGER *puliOffset, ULARGE_INTEGER *pulSize)
{
#ifdef MAC
    if (puliOffset)
        ULISet32(*puliOffset, m_dwOffset);
    if (pulSize)
        ULISet32(*pulSize, m_cbSize);
#else   // !MAC
    if (puliOffset)
        puliOffset->QuadPart = (LONGLONG)m_dwOffset;
    if (pulSize)
        pulSize->QuadPart = (LONGLONG)m_cbSize;
#endif  // MAC
}

// --------------------------------------------------------------------------------
// CVirtualStream::Seek
// --------------------------------------------------------------------------------
STDMETHODIMP CVirtualStream::Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
{
    // Locals
    HRESULT     hr  = ResultFromScode(S_OK);
    BOOL    	fForward;
	ULONG       ulOffset;
#ifdef MAC
    ULONG       llCur;
#else   // !MAC
	LONGLONG    llCur;
#endif  // MAC

    // Thread Safety
    EnterCriticalSection(&m_cs);
    
    // look for starting position
	if (dwOrigin == STREAM_SEEK_CUR)
		llCur = m_dwOffset;
	else if (dwOrigin == STREAM_SEEK_END)
		llCur = m_cbSize;
	else
		llCur = 0;

#ifdef MAC
    Assert(0 == dlibMove.HighPart);
    llCur += dlibMove.LowPart;
#else   // !MAC
    llCur += dlibMove.QuadPart;
#endif  // MAC

    // limit to 4 Gig
    if (llCur > 0xFFFFFFFF)
        goto seekerr;

    // if we have a stream and
    // we are currently in the file stream or the new seek seeks into the 
    // stream and the seek will not grow the stream, reseek in the stream
    if (    m_pstm
        &&  (   (m_dwOffset > m_cbAlloc)
            ||  (llCur > m_cbAlloc))
        &&  (llCur <= m_cbSize))
    {
        LARGE_INTEGER   li;
        
#ifdef MAC
        LISet32(li ,llCur < m_cbAlloc ? 0 : llCur - m_cbAlloc);
#else   // !MAC
        li.QuadPart = llCur < m_cbAlloc ? 0 : llCur - m_cbAlloc;
#endif  // MAC

        hr = m_pstm->Seek(li, STREAM_SEEK_SET, NULL);
        if (hr)
        {
            m_fFileErr = TRUE;
            goto err;
        }
    }

    m_dwOffset = (ULONG)llCur;

	if (plibNewPosition)
#ifdef MAC
        LISet32(*plibNewPosition, llCur);
#else   // !MAC
        plibNewPosition->QuadPart = llCur;
#endif  // MAC

err:
    
    // Thread Safety
    LeaveCriticalSection(&m_cs);

    return hr;
    
seekerr:
	hr = ResultFromScode(STG_E_MEDIUMFULL);
    goto err;
    // Done
}


// --------------------------------------------------------------------------------
// CVirtualStream::Write
// --------------------------------------------------------------------------------
#ifndef WIN16
STDMETHODIMP CVirtualStream::Write(const void *pv, ULONG cb, ULONG *pcbWritten)
#else
STDMETHODIMP CVirtualStream::Write(const void HUGEP *pv, ULONG cb, ULONG *pcbWritten)
#endif // !WIN16
{
    // Locals
    HRESULT     hr      = ResultFromScode(S_OK);
    ULONG       cbNew;
    ULONG       cbWrite = 0;

    // Thread Safety
    EnterCriticalSection(&m_cs);

    // figure out where we'll end up
    cbNew = cb + m_dwOffset;

    // make sure that we won't wrap
    if (cbNew < m_dwOffset)
        goto stmfull;

    // if that is past the end of the stream, make more stream
    if (cbNew > m_cbSize)
    {
        ULARGE_INTEGER uli = {cbNew, 0};
        hr = SetSize(uli);
        if (hr) goto err;
    }
        
    // figure out what we're putting into memory
    if (m_dwOffset < m_cbCommitted)
    {
        cbWrite = min(cb, m_cbCommitted - m_dwOffset);

        // copy the memory stuff
        CopyMemory(m_pb + m_dwOffset, (LPBYTE)pv, cbWrite);
    }

    // if we still have stuff to write, dump to the file
    if (cbWrite != cb)
    {
        ULONG   cbWritten;

        Assert(m_pstm);
        
#ifdef	DEBUG
        LARGE_INTEGER   li  = {0, 0};
        ULARGE_INTEGER  uli = {0, 0};

        if (!m_pstm->Seek(li, STREAM_SEEK_CUR, &uli))
#ifdef MAC
            Assert(0 == uli.HighPart);
            Assert(((m_dwOffset + cbWrite) - m_cbAlloc) == uli.LowPart);
#else   // !MAC
            Assert(((m_dwOffset + cbWrite) - m_cbAlloc) == uli.QuadPart);
#endif  // MAC
#endif
        
        hr = m_pstm->Write(((LPBYTE)pv) + cbWrite, cb - cbWrite, &cbWritten);
        if (hr)
        {
            m_fFileErr = TRUE;
            goto err;
        }
        
        cbWrite += cbWritten;
    }

    m_dwOffset += cbWrite;
    
    if (pcbWritten)
        *pcbWritten = cbWrite;
err:
   
    // Thread Safety
    LeaveCriticalSection(&m_cs);

    // Done
    return hr;

stmfull:
	hr = ResultFromScode(STG_E_MEDIUMFULL);
    goto err;
}


STDMETHODIMP CVirtualStream::CopyTo(LPSTREAM pstmDst,
                                    ULARGE_INTEGER uli,
                                    ULARGE_INTEGER* puliRead,
                                    ULARGE_INTEGER* puliWritten)
{
    HRESULT         hr          = 0;
    UINT            cbBuf;
    ULONG           cbRemain;
    ULONG           cbReadMem   = 0;
    ULONG           cbWriteMem  = 0;
#ifdef MAC
    ULARGE_INTEGER  uliRead     = {0, 0};    
    ULARGE_INTEGER  uliWritten  = {0, 0};    
#else   // !MAC
    ULARGE_INTEGER  uliRead     = {0};    
    ULARGE_INTEGER  uliWritten  = {0};    
#endif  // MAC

    // Initialize the outgoing params
    if (puliRead)
    {
        ULISet32((*puliRead), 0);
    }

    if (puliWritten)
    {
        ULISet32((*puliWritten), 0);
    }
    
    if (!m_cbSize)
        goto err;

    // if the request is greater than the max ULONG, bring the request down to
    // the max ULONG
    if (uli.HighPart)
#ifdef MAC
        ULISet32(uli, ULONG_MAX);
#else   // !MAC
        uli.QuadPart = 0xFFFFFFFF;
#endif  // MAC

    if (m_dwOffset < m_cbCommitted)
    {
        if (m_cbSize < m_cbAlloc)
            cbReadMem = (ULONG)min(uli.LowPart, m_cbSize - m_dwOffset);
        else
            cbReadMem = (ULONG)min(uli.LowPart, m_cbAlloc - m_dwOffset);

        hr = pstmDst->Write(m_pb + m_dwOffset, cbReadMem, &cbWriteMem);
        if (!hr && (cbReadMem != cbWriteMem))
            hr = ResultFromScode(E_OUTOFMEMORY);
        if (hr) goto err;

        uli.LowPart -= cbReadMem;
    }

    // if we didn't get it all from memory and there is information in
    // the file stream, read from the file stream
    if (    uli.LowPart
        &&  (m_cbSize > m_cbAlloc)
        &&  m_pstm)
    {
        hr = m_pstm->CopyTo(pstmDst, uli, &uliRead, &uliWritten);
        if (hr)
        {
            m_fFileErr = TRUE;
            goto err;
        }
    }

    m_dwOffset += uliRead.LowPart + cbReadMem;
    
    // Total cbReadMem and ulRead because we have them both.
#ifdef MAC
    if (puliRead)
    {
        ULISet32(*puliRead, uliRead.LowPart);
        Assert(INT_MAX - cbReadMem >= puliRead->LowPart);
        puliRead->LowPart += cbReadMem;
    }

    if (puliWritten)
        puliWritten->LowPart = uliWritten.LowPart + cbWriteMem;
#else   // !MAC
    if (puliRead)
        puliRead->QuadPart = cbReadMem + uliRead.LowPart;

    // Add in cbWriteMem because any written from the file stream was
    // already set
    if (puliWritten)
        puliWritten->QuadPart = uliWritten.LowPart + cbWriteMem;
#endif  // MAC

err:
    return (hr);
}