CFileMap.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "CFileMap.h"

namespace AxPipe {
    static void *
    MapUserView(HANDLE hMapping, longlong llOffset, size_t cbLen, void **ppvUserView, DWORD dwAccess) {
        static DWORD dwAllocationGranularity;

        if (ppvUserView == NULL) {
            return NULL;
        }

        // Get system allocation granularity to use with the memory mapping functions
        if (!dwAllocationGranularity) {
            SYSTEM_INFO SystemInfo;
            GetSystemInfo(&SystemInfo); // No error return!
            dwAllocationGranularity = SystemInfo.dwAllocationGranularity;
        }

        DWORD dwMisAlign = (DWORD)(llOffset % dwAllocationGranularity);
        cbLen += dwMisAlign;
        llOffset -= dwMisAlign;

        void *vpView = MapViewOfFile(hMapping, dwAccess, (*(LARGE_INTEGER*)&llOffset).HighPart, (*(LARGE_INTEGER*)&llOffset).LowPart, cbLen);
        ASSAPI(vpView != NULL);
        *ppvUserView = (char *)vpView + dwMisAlign;
        return vpView;
    }
    CSegMap::CSegMap(void *pOwner, size_t cb, void *pv, void *pView, longlong llPos, bool fReadOnly) : CSeg(cb, pv, fReadOnly) {
        m_pView = pView;
        m_pOwner = pOwner;
        m_llPos = llPos;
    }

    CSegMap::~CSegMap() {
        if (m_pView) {
            UnmapViewOfFile(m_pView);
            m_pView = NULL;
        }
    }
    
    longlong
    CSegMap::GetPos() {
        return m_llPos;
    }

    void *
    CSegMap::ClassId() {
        static int i;
        return &i;
    }

    void *
    CSegMap::RTClassId() {
        return ClassId();
    }
    
    bool
    CSegMap::IsOwner(void *pOwner) {
        return m_pOwner == pOwner;
    }

    CSourceMemFile::CSourceMemFile() {
        m_szFileName = NULL;
        m_hFile = INVALID_HANDLE_VALUE;
        m_hMapping = NULL;
    }

    HANDLE
    CSourceMemFile::GetHandle() {
        return m_hFile;
    }

    CSourceMemFile *CSourceMemFile::Init(const _TCHAR *szFileName, size_t cbChunk) {
        m_cbChunk = cbChunk;
        size_t cbLen = lstrlen(szFileName);
        CopyMemory(m_szFileName = new _TCHAR[cbLen+1], szFileName, (cbLen + 1) * sizeof (_TCHAR));
        return this;
    }

    bool CSourceMemFile::OutOpen() {
        m_hFile = CreateFile(m_szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
        if (m_hFile == INVALID_HANDLE_VALUE) {
            SetError(ERROR_CODE_GENERIC, _T("CSourceMemFile::CSourceMemFile failed to open %s"), m_szFileName);
            return false;                   // No point propagating if we already failed
        }
        ((LARGE_INTEGER *)&m_cbFileSize)->LowPart =
            GetFileSize(m_hFile, (LPDWORD)&(((LARGE_INTEGER *)&m_cbFileSize)->HighPart));
        m_cbStreamPos = 0;
        m_hMapping = CreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
        if (!m_hMapping) {
            SetError(ERROR_CODE_GENERIC, _T("CSourceMemFile::CSourceMemFile failed to create file mapping for %s"), m_szFileName);
            return false;                   // No use propagating of we already failed.
        }
        return true;
    }

    bool CSourceMemFile::OutClose(void) {
        if (m_hMapping) {
            if (!CloseHandle(m_hMapping)) {
                SetError(ERROR_CODE_GENERIC, _T("CSourceMemFile::Close failed to close mapping"));
                return true;
            }
            m_hMapping = NULL;
        }
        if (m_hFile != INVALID_HANDLE_VALUE) {
            if (!CloseHandle(m_hFile)) {
                SetError(ERROR_CODE_GENERIC, _T("CSourceMemFile::Close failed to close file"));
                return true;
            }
            m_hFile = INVALID_HANDLE_VALUE;
        }
        return true;
    }
    CSeg *CSourceMemFile::In() {
        if (m_cbStreamPos == m_cbFileSize) {
            return new CSeg;    // Return a zero-sized segment.
        }
        size_t cbThisChunk = m_cbChunk;
        if (m_cbStreamPos + cbThisChunk > m_cbFileSize) {
            cbThisChunk = (size_t)(m_cbFileSize - m_cbStreamPos);
        }

        void *pView, *pUserView;
        pView = MapUserView(m_hMapping, m_cbStreamPos, cbThisChunk, &pUserView, FILE_MAP_READ);
        CSeg *pSeg = new CSegMap(NULL, cbThisChunk, pUserView, pView, m_cbStreamPos, true);
        m_cbStreamPos += cbThisChunk;
        return pSeg;
    }

    CSinkMemFile::CSinkMemFile() {
        m_szFileName = NULL;
        m_hFile = INVALID_HANDLE_VALUE;
        m_hMapping = NULL;
        InitializeCriticalSection(&m_CritSect);
        m_cbOutPos = m_cbInPos = 0;
    }

    CSinkMemFile::~CSinkMemFile() {
        delete[] m_szFileName;
        DeleteCriticalSection(&m_CritSect);
    }

    HANDLE
    CSinkMemFile::GetHandle() {
        return m_hFile;
    }

    CSinkMemFile *
    CSinkMemFile::Init(const TCHAR *szFileName, size_t cbChunk) {
        m_cbChunk = cbChunk;
        size_t cbLen = lstrlen(szFileName);
        CopyMemory(m_szFileName = new _TCHAR[cbLen+1], szFileName, (cbLen + 1) * sizeof (_TCHAR));
        return this;
    }

    bool
    CSinkMemFile::OutClose() {
        if (m_hMapping) {
            do { // Once, poor mans try
                if (!CloseHandle(m_hMapping)) {
                    SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Close failed to close mapping"));
                    break;
                }
                m_hMapping = NULL;
            } while (false);
        }
        if (m_hFile != INVALID_HANDLE_VALUE) {
            do { // Once
                //
                //  Set end of file pointer, this is determined by m_cbOutPos
                //
                if (SetFilePointer(m_hFile, ((LARGE_INTEGER *)&m_cbOutPos)->LowPart, &((LARGE_INTEGER *)&m_cbOutPos)->HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
                    SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Close set file pointer to end failed"));
                    break;
                }
                if (!SetEndOfFile(m_hFile)) {
                    DWORD dwErr = GetLastError();
                    SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Close can't set end of file"));
                    break;
                }
                if (!CloseHandle(m_hFile)) {
                    SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Close failed to close file"));
                    break;
                }
                m_hFile = INVALID_HANDLE_VALUE;
            } while (false);
        }
        return true;
    }
    CSeg *
    CSinkMemFile::OutGetSeg(size_t cb) {
        CSeg *pSeg;

        EnterCriticalSection(&m_CritSect);
        // We can only get a mapped segment if we have an open file already.
        longlong cbPos = m_cbInPos > m_cbOutPos ? m_cbInPos : m_cbOutPos;
        if (m_hFile != INVALID_HANDLE_VALUE) {
            if (cbPos + cb > m_cbMappingSize) {
                m_cbMappingSize = cbPos + cb;
                if (m_hMapping) {
                    // This actually works even if we have open views, the order
                    // of calls to unmapview and closehandle is not important.
                    if (!CloseHandle(m_hMapping)) {
                        SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::OutGetSeg failed to close mapping"));
                        LeaveCriticalSection(&m_CritSect);
                        return NULL;
                    }
                    m_hMapping = NULL;
                }
            }
            if (!m_hMapping) {
                // Now create a mapping that is large enough for the largest stream to date.
                m_hMapping = CreateFileMapping(m_hFile, NULL, PAGE_READWRITE, ((LARGE_INTEGER *)&m_cbMappingSize)->HighPart, ((LARGE_INTEGER *)&m_cbMappingSize)->LowPart, NULL);
                if (!m_hMapping) {
                    SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::OutGetSeg failed to create file mapping"));
                    LeaveCriticalSection(&m_CritSect);
                    return NULL;
                }
            }
            void *pView, *pUserView;
            pView = MapUserView(m_hMapping, cbPos, cb, &pUserView, FILE_MAP_WRITE|FILE_MAP_READ);
            pSeg = new CSegMap(this, cb, pUserView, pView, cbPos);
        } else {
            pSeg = new CSeg(cb);
        }
        m_cbInPos = cbPos + cb;
        LeaveCriticalSection(&m_CritSect);
        return pSeg;
    }
    void
    CSinkMemFile::Out(CSeg *pSeg) {
        if (CSeg::IsSeg(pSeg)) {
            // We need to be in a critical section, since the previous section of
            // the pipe may be in a different thread and may request allocation from
            // OutGetSeg().
            EnterCriticalSection(&m_CritSect);
            if (pSeg->Len()) {
                // If this is not a CSegMap, or if it is, we're not the owner then we allocate an output.
                if ((pSeg->RTClassId() != CSegMap::ClassId()) || !((CSegMap *)pSeg)->IsOwner(this)) {
                    CSeg *pOutSeg = OutGetSeg(pSeg->Len());
                    if (!pOutSeg) {
                        SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Out() [OutGetSeg() returned NULL]"));
                    } else {
                        CopyMemory(pOutSeg->PtrWr(), pSeg->PtrRd(), pSeg->Len());
                        pOutSeg->Release();
                    }
                } else {
                    // If we're 'short' of data in the output, we move the segment
                    // back. This can happen if an earlier requested segment was cut
                    // short before being output.
                    CSegMap *pSegMap = (CSegMap *)pSeg;
                    if (pSegMap->GetPos() > m_cbOutPos) {
                        void *pView, *pUserView;
                        pView = MapUserView(m_hMapping, m_cbOutPos, pSegMap->Len(), &pUserView, FILE_MAP_WRITE|FILE_MAP_READ);
                        if (!pView) {
                            SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Out() [MapUserView() returned NULL]"));
                        } else {
                            CopyMemory(pUserView, pSegMap->PtrRd(), pSegMap->Len());
                            if (!(UnmapViewOfFile(pView))) {
                                SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Out() [UnmapViewOfFile() failed]"));
                            }
                        }
                    } else if (pSegMap->GetPos() < m_cbOutPos) {
                        // If we've already output into this segment, it's run over and
                        // we've violated the stream model. This can happen if a non-mapped
                        // segment is gotten, and then before it's 'output', a non-mapped
                        // segment is output. This is an error condition.
                        SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::Out() [Output sequence error]"));
                    }
                    // If (which is the normal case) the output-position is the same as the
                    // segment's start, everything is ok and we do nothing.
                }
            }
            m_cbOutPos += pSeg->Len();
            pSeg->Release();
            LeaveCriticalSection(&m_CritSect);
        }
    }
    bool
    CSinkMemFile::OutOpen() {
        // If it's there, open for writing, otherwise create it.
        m_hFile = CreateFile(m_szFileName, GENERIC_WRITE|GENERIC_READ, 0, NULL, OPEN_ALWAYS, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
        if (m_hFile == INVALID_HANDLE_VALUE) {
            SetError(ERROR_CODE_GENERIC, _T("CSinkMemFile::CSinkMemFile failed to open %s"), m_szFileName);
        }
        ((LARGE_INTEGER *)&m_cbMappingSize)->LowPart = GetFileSize(m_hFile, (LPDWORD)&(((LARGE_INTEGER *)&m_cbMappingSize)->HighPart));
        m_cbOutPos = m_cbInPos = 0;
        return true;
    }
};

---