/*++

   Copyright (c) 2000 Microsoft Corporation.  All rights reserved.

--*/

// EBScannerDataFilter.h : Declaration of the CEBScannerDataFilter

#ifndef __EBSCANNERDATAFILTER_H_
#define __EBSCANNERDATAFILTER_H_

#include "resource.h"       // main symbols

#include "EBFTPDataFilter.h"

/////////////////////////////////////////////////////////////////////////////
// CEBScannerDataFilter
class ATL_NO_VTABLE CEBScannerDataFilter :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IFWXDataFilter,
    public IFWXExternalIOCompletion,
    public IFWXIOCompletion
{
    CComPtr<IFWXSocket>  m_spExternalSocket;
    CComPtr<IFWXSocket>  m_spInternalSocket;
    CComPtr<IFWXSession> m_spIFWXSession;

    CComPtr<IFWXFirewall> m_spCallBackInterface;
    CComPtr<IFWXPreparedData> m_PreparedData;

    CComObject<CEBFTPDataFilter> *m_pControlDataFilter;

    HANDLE            m_FileHandle;
    DWORD             m_FileSize;
    DWORD             m_BytesSent;
    HANDLE            m_FileMapping;
    PBYTE             m_FileView;

    void _WriteNextChunk();
    void _ScanFile();
    void _Abort();
    void _AbortWithConstantMessage(LPSTR FtpReply);

public:
    CEBScannerDataFilter()
    {
        m_FileSize = 0;
        m_pControlDataFilter = NULL;
        m_FileHandle = INVALID_HANDLE_VALUE;
        m_FileMapping= INVALID_HANDLE_VALUE;
        m_FileView   = NULL;
    }

    ~CEBScannerDataFilter() 
    {
        if (m_pControlDataFilter) m_pControlDataFilter->Release();
        if (m_FileView) UnmapViewOfFile(m_FileView);
        if (m_FileMapping != INVALID_HANDLE_VALUE) CloseHandle(m_FileMapping);
        if (m_FileHandle != INVALID_HANDLE_VALUE) CloseHandle(m_FileHandle);
    }

    void Initialize(
        CComObject<CEBFTPDataFilter> *pControlDataFilter,
        IFWXFirewall *pCallback,
        IFWXSession *IFWXSession,
        IFWXPreparedData *PreparedData
        ) 
    {
        pControlDataFilter->AddRef();
        m_pControlDataFilter = pControlDataFilter;
        m_spCallBackInterface = pCallback;
        m_spIFWXSession = IFWXSession;
        m_PreparedData = PreparedData;
    }

BEGIN_COM_MAP(CEBScannerDataFilter)
    COM_INTERFACE_ENTRY(IFWXDataFilter)
END_COM_MAP()

// IFWXDataFilter
public:
    STDMETHODIMP SetSockets(
        IFWXSocket *piInternalSocket,
        IFWXSocket *piExternalSocket,
        IFWXConnection *piConnection,
        IUnknown *punkFilterContext
        );

    STDMETHODIMP Detach();

// IFWXIOCompletion
    STDMETHODIMP CompleteAsyncIO(
        BOOL      fSuccess,
        DWORD     Win32ErrorCode,
        IFWXIOBuffer *pIOBuffer,
        UserContextType UserData,
        PSOCKADDR From,
        INT       FromLen
        );

// IFWXExternalIOCompletion
    HRESULT
    STDMETHODCALLTYPE
    CompleteAsyncIO(
        /* [in] */ BOOL fSuccess,
        /* [in] */ DWORD NumberOfBytesTransfered,
        /* [in] */ DWORD Win32ErrorCode,
        /* [in] */ IFWXOverlapped __RPC_FAR *pOverlapped,
        /* [in] */ UserContextType UserData
        );


private:

    IFWXSocket * _GetExternalSocket() 
    {
        IFWXSocket *ret;
        Lock();
        ret = m_spExternalSocket;
        if (ret) ret->AddRef();
        Unlock();
        return ret;
    }

    IFWXSocket * _GetInternalSocket() 
    {
        IFWXSocket *ret;
        Lock();
        ret = m_spInternalSocket;
        if (ret) ret->AddRef();
        Unlock();
        return ret;
    }
};

class ATL_NO_VTABLE CPreparedRuleDataBase :
    public CComObjectRootEx<CComMultiThreadModel>,
    public IFWXPerRuleDataplugin,
    public IFWXPreparedData
{
public:
    static const unsigned int MAX_DATA = 30;
private:
BEGIN_COM_MAP(CPreparedRuleDataBase)
    COM_INTERFACE_ENTRY(IFWXPreparedData)
    COM_INTERFACE_ENTRY(IFWXPerRuleDataplugin)
END_COM_MAP()

CPreparedRuleDataBase()
{
    m_ScanFor[0] = 0;
    m_DataSize = 1;
}
    HRESULT STDMETHODCALLTYPE SetData(
            /* [in] */ DWORD dwBufferSize,
            /* [size_is][in] */ BYTE *Buffer
            ) 
    {
        
        if (dwBufferSize > MAX_DATA) 
        {
            return E_UNEXPECTED;
        }
        memcpy(m_ScanFor, (const char *)Buffer, dwBufferSize);
        m_DataSize = dwBufferSize;
        return S_OK;
    }


 
    HRESULT STDMETHODCALLTYPE GetData(
            /* [out][in] */ DWORD *pDataSize,
            /* [size_is][out] */ BYTE *Data
	        ) 
    {
        if (m_DataSize > *pDataSize) 
        {
            *pDataSize = m_DataSize;
            return E_OUTOFMEMORY;
        }
        memcpy((char *)(Data), m_ScanFor, m_DataSize);
        *pDataSize = m_DataSize;
        return S_OK;
    }

    HRESULT STDMETHODCALLTYPE CompareRulesData(
            /* [in]]*/  IFWXPerRuleDataplugin *pProcessedRulesData
    ) {
        HRESULT hr;
        char  ScanFor[MAX_DATA];
        DWORD DataSize;

        CComQIPtr <IFWXPreparedData> iPreparedData = pProcessedRulesData;
        if (iPreparedData == NULL) {
            return E_INVALIDARG;
        }
        hr = iPreparedData->GetData(&DataSize , (BYTE *)ScanFor);
        if(FAILED(hr)) {
            return hr;
        }
        if (DataSize != m_DataSize) {
            return S_FALSE;
        }
        return memcmp(m_ScanFor, ScanFor, DataSize) ? S_FALSE : S_OK;
    }


    
    char  m_ScanFor[MAX_DATA];
    unsigned int m_DataSize;
    
};

typedef CComObject<CPreparedRuleDataBase> CPreparedRuleData;
#endif //__EBSCANNERDATAFILTER_H_