/*++

   Copyright (c) 1998    Microsoft Corporation

   Module  Name :

        pe_dispi.cxx

   Abstract:

        This module provides the implementation for the protocol
        event dispatchers

   Author:

           Keith Lau    (KeithLau)    6/24/98

   Project:

           SMTP Server DLL

   Revision History:

            KeithLau            Created

--*/

#define INCL_INETSRV_INCS
#include "smtpinc.h"

#include "initguid.h"

//
// ATL includes
//
#define _ATL_NO_DEBUG_CRT
#define _ASSERTE _ASSERT
#define _WINDLL
#include "atlbase.h"
extern CComModule _Module;
#include "atlcom.h"
#undef _WINDLL

//
// SEO includes
//
#include "seo.h"
#include "seolib.h"

#include <memory.h>
#include "smtpcli.hxx"
#include "smtpout.hxx"
#include <smtpguid.h>

//
// Dispatcher implementation
//
#include "pe_dispi.hxx"


// =================================================================
// Outbound command generation dispatcher
//

//
// These are the commands that the default handlers hook
//
char *COutboundDispatcher::s_rgszDefaultCommand[PE_STATE_MAX_STATES] =
{
    "ehlo",
    "mail",
    "rcpt",
    NULL,
    "quit"
};

//
// This is what we use to map an event type to an internal index
//
const GUID *COutboundDispatcher::s_rgrguidEventTypes[PE_STATE_MAX_STATES] =
{
    &CATID_SMTP_ON_SESSION_START,
    &CATID_SMTP_ON_MESSAGE_START,
    &CATID_SMTP_ON_PER_RECIPIENT,
    &CATID_SMTP_ON_BEFORE_DATA,
    &CATID_SMTP_ON_SESSION_END
};

//
// Generic dispatcher methods
//
HRESULT CGenericProtoclEventDispatcher::GetLowerAnsiStringFromVariant(
            CComVariant &vString,
            LPSTR       pszString,
            DWORD       *pdwLength
            )
{
    HRESULT hr = S_OK;
    DWORD   dwInLength;

    if (!pszString)
        return(E_POINTER);
    if (!pdwLength)
        return(E_INVALIDARG);

    // Default to NULL
    *pszString = NULL;

    if (vString.vt == VT_BSTR)
    {
        DWORD dwLength = lstrlenW(vString.bstrVal) + 1;

        // Set the size anyway
        dwInLength = *pdwLength;
        *pdwLength = dwLength;

        if (dwLength > dwInLength)
            return(HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER));

        // copy the rule into an ascii string
        if (WideCharToMultiByte(CP_ACP, 0, vString.bstrVal,
                                -1, pszString, dwLength, NULL, NULL) <= 0)
            return(HRESULT_FROM_WIN32(GetLastError()));

        // Convert to lower case once and for all to avoid strcmpi
        while (*pszString)
        {
            *pszString = (CHAR)tolower(*pszString);
            pszString++;
        }
    }
    else
        hr = E_INVALIDARG;
    return(hr);
}

HRESULT CGenericProtoclEventDispatcher::InsertBinding(
            LPPE_COMMAND_NODE   *ppHeadNode,
            LPPE_BINDING_NODE   pBinding,
            LPSTR               pszCommandKeyword,
            DWORD               dwCommandKeywordSize
            )
{
    DWORD                   dwPriority;
    BOOL                    fReorder = FALSE;
    LPPE_COMMAND_NODE       pNode;

    TraceFunctEnter("CGenericProtoclEventDispatcher::InsertBinding");

    if (!ppHeadNode || !pBinding || !pszCommandKeyword)
        return(E_POINTER);

    pNode = *ppHeadNode;
    while (pNode)
    {
        // All strings come in lower case
        if (!strcmp(pszCommandKeyword, pNode->pszCommandKeyword))
        {
            DebugTrace((LPARAM)0, "Found command %s", pszCommandKeyword);

            // Now we determine if we have changed the max priority
            // if we increased the priority (i.e. lower value), then
            // we will have to reposition out node
            dwPriority = pBinding->dwPriority;
            if (pBinding->dwPriority < dwPriority)
            {
                pBinding->dwPriority = dwPriority;
                fReorder = TRUE;
                DebugTrace((LPARAM)0, "Reordering commands");
            }

            // Now insert the binding in the right order
            LPPE_BINDING_NODE   pWalk = pNode->pFirstBinding;
            LPPE_BINDING_NODE   pPrev = (LPPE_BINDING_NODE)&(pNode->pFirstBinding);
            if (!pWalk)
            {
                pBinding->pNext = pNode->pFirstBinding;
                pNode->pFirstBinding = pBinding;
            }
            else while (pWalk)
            {
                if (pWalk->dwPriority > dwPriority)
                    break;
                pPrev = pWalk;
                pWalk = pWalk->pNext;
            }
            pBinding->pNext = pWalk;
            pPrev->pNext = pBinding;

            if (!fReorder)
                return(S_OK);
            else
                break;
        }

        // Next!
        pNode = pNode->pNext;
    }

    if (!fReorder)
    {
        char    *pTemp;
        DWORD   dwSize = sizeof(PE_COMMAND_NODE);

        // Not found, create a new command node, plus a buffer
        // for the command keyword
        dwSize += dwCommandKeywordSize;
        pTemp = new char [dwSize];
        if (!pTemp)
            return(E_OUTOFMEMORY);

        pNode = (LPPE_COMMAND_NODE)pTemp;
        pTemp = (char *)(pNode + 1);

        DebugTrace((LPARAM)0,
                    "Creating node for command %s",
                    pszCommandKeyword);

        strcpy(pTemp, pszCommandKeyword);
        dwPriority = pBinding->dwPriority;
        pBinding->pNext = NULL;
        pNode->pszCommandKeyword = pTemp;
        pNode->dwHighestPriority = dwPriority;
        pNode->pFirstBinding = pBinding;
    }

    // Insert based on top priority
    LPPE_COMMAND_NODE   pWalk = *ppHeadNode;
    LPPE_COMMAND_NODE   pPrev = (LPPE_COMMAND_NODE)ppHeadNode;
    if (!pWalk)
    {
        pNode->pNext = NULL;
        *ppHeadNode = pNode;
        return(S_OK);
    }
    while (pWalk)
    {
        if (pWalk->dwHighestPriority > dwPriority)
            break;
        pPrev = pWalk;
        pWalk = pWalk->pNext;
    }
    pNode->pNext = pWalk;
    pPrev->pNext = pNode;

    TraceFunctLeave();
    return(S_OK);
}

HRESULT CGenericProtoclEventDispatcher::InsertBindingWithHash(
            LPPE_COMMAND_NODE   *rgpHeadNodes,
            DWORD               dwHashSize,
            LPPE_BINDING_NODE   pBinding,
            LPSTR               pszCommandKeyword,
            DWORD               dwCommandKeywordSize
            )
{
    TraceFunctEnter("CGenericProtoclEventDispatcher::InsertBindingWithHash");

    if (!rgpHeadNodes || !pBinding || !pszCommandKeyword)
        return(E_POINTER);

    DWORD dwHash = GetHashValue(
                dwHashSize,
                pszCommandKeyword,
                dwCommandKeywordSize);

    HRESULT hr = InsertBinding(
                &(rgpHeadNodes[dwHash]),
                pBinding,
                pszCommandKeyword,
                dwCommandKeywordSize);

    TraceFunctLeave();
    return(hr);
}

HRESULT CGenericProtoclEventDispatcher::FindCommandFromHash(
            LPPE_COMMAND_NODE   *rgpHeadNodes,
            DWORD               dwHashSize,
            LPSTR               pszCommandKeyword,
            DWORD               dwCommandKeywordSize,
            LPPE_COMMAND_NODE   *ppCommandNode
            )
{
    TraceFunctEnter("CGenericProtoclEventDispatcher::FindCommandFromHash");

    if (!rgpHeadNodes || !pszCommandKeyword || !ppCommandNode)
        return(E_POINTER);

    DWORD dwHash = GetHashValue(
                dwHashSize,
                pszCommandKeyword,
                dwCommandKeywordSize);

    LPPE_COMMAND_NODE   pNode = rgpHeadNodes[dwHash];

    while (pNode)
    {
        if (!strcmp(pszCommandKeyword, pNode->pszCommandKeyword))
        {
            *ppCommandNode = pNode;
            TraceFunctLeave();
            return(S_OK);
        }
        pNode = pNode->pNext;
    }
    TraceFunctLeave();
    return(S_FALSE);
}

HRESULT CGenericProtoclEventDispatcher::CleanupCommandNodes(
            LPPE_COMMAND_NODE   pHeadNode,
            LPPE_COMMAND_NODE   pSkipNode
            )
{
    LPPE_COMMAND_NODE   pNode;
    while (pHeadNode)
    {
        pNode = pHeadNode->pNext;
        if (pHeadNode != pSkipNode)
        {
            char    *pTemp = (char *)pHeadNode;
            delete [] pTemp;
        }
        pHeadNode = pNode;
    }
    return(S_OK);
}


//
// Inbound dispatcher methods
//

HRESULT CInboundDispatcher::AllocBinding(
            REFGUID         rguidEventType,
            IEventBinding   *piBinding,
            CBinding        **ppNewBinding
            )
{
    if (ppNewBinding)
        *ppNewBinding = NULL;
    if (!piBinding || !ppNewBinding)
        return(E_POINTER);

    *ppNewBinding = new CInboundBinding(this);

    if (*ppNewBinding == NULL)
        return(E_OUTOFMEMORY);
    return(S_OK);
}

HRESULT STDMETHODCALLTYPE CInboundDispatcher::ChainSinks(
            IUnknown                    *pServer,
            IUnknown                    *pSession,
            IMailMsgProperties          *pMsg,
            ISmtpInCommandContext       *pContext,
            DWORD                       dwStopAtPriority,
            LPPE_COMMAND_NODE           pCommandNode,
            LPPE_BINDING_NODE           *ppResumeFrom
            )
{
    HRESULT hr = S_OK;

    LPPE_BINDING_NODE   pBinding = NULL;

    TraceFunctEnterEx((LPARAM)this, "CInboundDispatcher::ChainSinks");

    // These are the essential pointers that CANNOT be NULL
    if (!pContext || !pCommandNode || !ppResumeFrom)
        return(E_POINTER);

    // What we do is strictly determined by the ppPreviousCommand
    // and ppResumeFrom pointers. The logic is as follows:
    //
    // pCmdNode     ppResumeFrom    Action
    //    NULL          X           Error (E_POINTER)
    //   !NULL          NULL        Error (ERROR_NO_MORE_ITEMS)
    //   !NULL         !NULL        Start from the exact binding specified in
    //                                *ppResumeFrom
    //
    // On exit, these pointers will be updated to the following:
    //
    // *ppResumeFrom      - This will be set to the next binding to resume from
    //                      This will be set to NULL if there are no more bindings

    pBinding = *ppResumeFrom;
    if (!pBinding)
    {
        _ASSERT(FALSE);
        ErrorTrace((LPARAM)this, "ERROR! Empty binding chain!!");
        return(HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS));
    }

    // We know exactly where to start chaining ... Do it.
    // Break when:
    // 1) The default handler binding is encountered, or
    // 2) Sinks results are S_OK
    // 3) No more bindings left
    CInboundBinding     *pInboundBinding;
    IUnknown            *pUnkSink = NULL;
    ISmtpInCommandSink  *pSink;

    hr = S_OK;
    *ppResumeFrom = pBinding;
    while (pBinding && (hr == S_OK))
    {
        // One of the exiting conditions
        if (pBinding->dwPriority > dwStopAtPriority)
            break;

        // Get the containing binding class
        pInboundBinding = CONTAINING_RECORD(
                    pBinding, CInboundBinding, m_bnInfo);

        // Call the sink
        hr = m_piEventManager->CreateSink(
                    pInboundBinding->m_piBinding,
                    NULL,
                    &pUnkSink);
        if (SUCCEEDED(hr))
        {
            hr = pUnkSink->QueryInterface(
                        IID_ISmtpInCommandSink,
                        (LPVOID *)&pSink);
            pUnkSink->Release();
            pUnkSink = NULL;
            if (SUCCEEDED(hr))
            {
                hr = pSink->OnSmtpInCommand(
                            pServer,
                            pSession,
                            pMsg,
                            pContext);
                pSink->Release();
                if (hr == MAILTRANSPORT_S_PENDING)
                    break;
            }
            else
                hr = S_OK;
        }
        else
            hr = S_OK;

        // Next
        pBinding = pBinding->pNext;
        *ppResumeFrom = pBinding;
    }

    TraceFunctLeaveEx((LPARAM)this);
    return(hr);
}

//
// CInboundDispatcher::CInboundBinding methods
//
HRESULT CInboundDispatcher::CInboundBinding::Init(
            IEventBinding *piBinding
            )
{
    HRESULT hr;
    CComPtr<IEventPropertyBag>  piEventProperties;
    CComVariant                 vRule;
    CHAR                        szCommandKeyword[256];
    DWORD                       cchCommandKeyword = 0;

    TraceFunctEnterEx((LPARAM)this,
            "CInboundDispatcher::CInboundBinding::Init");

    if (!piBinding || !m_pDispatcher)
        return(E_POINTER);

    // get the parent initialized
    hr = CBinding::Init(piBinding);
    if (FAILED(hr)) return hr;

    // Store the priority
    m_bnInfo.dwPriority = CBinding::m_dwPriority;
    m_bnInfo.dwFlags = 0;

    // get the binding database
    hr = m_piBinding->get_SourceProperties(&piEventProperties);
    if (FAILED(hr)) return hr;

    // get the rule from the binding database
    hr = piEventProperties->Item(&CComVariant("Rule"), &vRule);
    if (FAILED(hr)) return hr;

    // Process the VARIANT to obtain a lower-case ANSI string
    if (hr == S_OK)
    {
        cchCommandKeyword = sizeof(szCommandKeyword);
        hr = GetLowerAnsiStringFromVariant(
                    vRule,
                    szCommandKeyword,
                    &cchCommandKeyword);
    }

    // We cannot proceed without a rule, so we discard this binding
    if (FAILED(hr))
    {
        ErrorTrace((LPARAM)this,
                "Failed to get keyword, error %08x", hr);
        return(hr);
    }
    if (!cchCommandKeyword || !(*szCommandKeyword))
        return(E_INVALIDARG);

    DebugTrace((LPARAM)this, "Rule: %s", szCommandKeyword);

    // Call the dispatcher to insert the node into the command list
    hr = CGenericProtoclEventDispatcher::InsertBindingWithHash(
                m_pDispatcher->m_rgpCommandList,
                m_pDispatcher->m_dwHashSize,
                &m_bnInfo,
                szCommandKeyword,
                cchCommandKeyword);
    if (SUCCEEDED(hr))
        m_pDispatcher->m_fSinksInstalled = TRUE;

    TraceFunctLeaveEx((LPARAM)this);
    return(hr);
}


//
// Outbound dispatcher methods
//
void COutboundDispatcher::InitializeDefaultCommandBindings()
{
    for (DWORD i = 0; i < PE_STATE_MAX_STATES; i++)
    {
        if (s_rgszDefaultCommand[i])
        {
            // Set up the list head
            m_rgpCommandList[i] = &(m_rgcnDefaultCommand[i]);

            // Set up the command node
            m_rgpCommandList[i]->pNext = NULL;
            m_rgpCommandList[i]->pszCommandKeyword = s_rgszDefaultCommand[i];
            m_rgpCommandList[i]->dwHighestPriority = PRIO_DEFAULT;
            m_rgpCommandList[i]->pFirstBinding = &(m_rgbnDefaultCommand[i]);

            // Set up the binding node
            m_rgbnDefaultCommand[i].pNext = NULL;
            m_rgbnDefaultCommand[i].dwPriority = PRIO_DEFAULT;
            m_rgbnDefaultCommand[i].dwFlags = PEBN_DEFAULT;
        }
        else
            m_rgpCommandList[i] = NULL;
    }
}

HRESULT COutboundDispatcher::AllocBinding(
            REFGUID         rguidEventType,
            IEventBinding   *piBinding,
            CBinding        **ppNewBinding
            )
{
    if (ppNewBinding)
        *ppNewBinding = NULL;
    if (!piBinding || !ppNewBinding)
        return(E_POINTER);

    *ppNewBinding = new COutboundBinding(this, rguidEventType);

    if (*ppNewBinding == NULL)
        return(E_OUTOFMEMORY);
    return(S_OK);
}

HRESULT STDMETHODCALLTYPE COutboundDispatcher::ChainSinks(
            IUnknown                *pServer,
            IUnknown                *pSession,
            IMailMsgProperties      *pMsg,
            ISmtpOutCommandContext  *pContext,
            DWORD                   dwEventType,
            LPPE_COMMAND_NODE       *ppPreviousCommand,
            LPPE_BINDING_NODE       *ppResumeFrom
            )
{
    HRESULT hr = S_OK;

    LPPE_COMMAND_NODE   pCommand = NULL;
    LPPE_BINDING_NODE   pBinding = NULL;

    _ASSERT(dwEventType < PE_OET_INVALID_EVENT_TYPE);

    TraceFunctEnterEx((LPARAM)this, "COutboundDispatcher::ChainSinks");

    // These are the essential pointers that CANNOT be NULL
    if (!pContext || !ppPreviousCommand || !ppResumeFrom)
        return(E_POINTER);

    // If we encounter a bad event type, just gracefully return
    // without doing anythig
    if (dwEventType >= PE_OET_INVALID_EVENT_TYPE)
    {
        *ppResumeFrom = NULL;
        ErrorTrace((LPARAM)this,
                "Skipping event due to bad event type %u",
                dwEventType);
        return(S_OK);
    }

    // What we do is strictly determined by the ppPreviousCommand
    // and ppResumeFrom pointers. The logic is as follows:
    //
    // ppPrevCmd    ppResumeFrom    Action
    //    NULL          NULL        Start from the first command for this event type
    //    NULL         !NULL        Start from the first command for this event type
    //   !NULL          NULL        Start from the first binding for the command
    //                                that follows *ppPreviousCommand
    //   !NULL         !NULL        Start from the exact binding specified in
    //                                *ppResumeFrom
    //
    // On exit, these pointers will be updated to the following:
    //
    // *ppPreviousCommand - This will point to the command node of the command
    //                      that was just processed
    // *ppResumeFrom      - This will be set to the next binding to resume from
    //                      This will be set to NULL if there are no more bindings

    if (!*ppPreviousCommand)
    {
        pCommand = m_rgpCommandList[dwEventType];
        if (!pCommand)
        {
            // Ooooops! We peeked with SinksInstalled() but now we have no sinks
            // This is an error but we will recover gracefully
            _ASSERT(pCommand);
            ErrorTrace((LPARAM)this, "ERROR! Empty command chain!!");
            return(HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS));
        }

        // We check this downstream
        pBinding = pCommand->pFirstBinding;
    }
    else if (*ppResumeFrom)
    {
        // We resume from the exact binding as specified
        pCommand = *ppPreviousCommand;
        pBinding = *ppResumeFrom;
    }
    else
    {
        // We start with the next command in the list
        pCommand = (*ppPreviousCommand)->pNext;
        if (!pCommand)
        {
            DebugTrace((LPARAM)this, "No more commands to chain");
            *ppPreviousCommand = NULL;
            *ppResumeFrom = NULL;
            return(HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS));
        }

        // We check this downstream
        pBinding = pCommand->pFirstBinding;
    }

    // DEBUG Check: we want the retail perf to be as high as possible
    // and we want it to be fail safe as well. We will do an internal
    // check here to make sure that any command node has at least one
    // binding, and that we have bindings when we expect them.
#ifdef DEBUG
    if (!pBinding)
    {
        // Ooooops! We have a command node without a binding. This is a blatant
        // error but we recover gracefully
        _ASSERT(pBinding);
        ErrorTrace((LPARAM)this, "ERROR! Empty binding chain!!");
        return(HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS));
    }
#endif

    // We know exactly where to start chaining ... Do it.
    // Break when:
    // 1) The default handler binding is encountered, or
    // 2) Sinks results are S_OK
    // 3) No more bindings left
    COutboundBinding    *pOutboundBinding;
    IUnknown            *pUnkSink = NULL;
    ISmtpOutCommandSink *pSink;
    COutboundContext    *pCContext;

    // Initialize pContext->m_pCurrentCommandContext
    pCContext = (COutboundContext *)pContext;
    pCContext->m_pCurrentCommandContext = pCommand;

    hr = S_OK;
    while (pBinding && (hr == S_OK))
    {
        // One of the exiting conditions
        if (pBinding->dwFlags & PEBN_DEFAULT)
            break;

        // Get the containing binding class
        pOutboundBinding = CONTAINING_RECORD(
                    pBinding, COutboundBinding, m_bnInfo);

        // Call the sink
        hr = m_piEventManager->CreateSink(
                    pOutboundBinding->m_piBinding,
                    NULL,
                    &pUnkSink);
        if (SUCCEEDED(hr))
        {
            hr = pUnkSink->QueryInterface(
                        IID_ISmtpOutCommandSink,
                        (LPVOID *)&pSink);
            pUnkSink->Release();
            pUnkSink = NULL;
            if (SUCCEEDED(hr))
            {
                // Pre-fill in the next binding to avoid
                // race conditions in the async case
                *ppResumeFrom = pBinding->pNext;
                hr = pSink->OnSmtpOutCommand(
                            pServer,
                            pSession,
                            pMsg,
                            pContext);
                pSink->Release();
                if (hr == MAILTRANSPORT_S_PENDING)
                    hr = S_OK;
                //  break;
            }
            else
                hr = S_OK;
        }
        else
            hr = S_OK;

        // Next
        pBinding = pBinding->pNext;
    }

    // Return where to resume from ...
    *ppPreviousCommand = pCommand;
    *ppResumeFrom = pBinding;

    TraceFunctLeaveEx((LPARAM)this);
    return(hr);
}

//
// COutboundDispatcher::COutboundBinding methods
//
COutboundDispatcher::COutboundBinding::COutboundBinding(
            COutboundDispatcher *pDispatcher,
            REFGUID             rguidEventType
            )
{
    _ASSERT(pDispatcher);
    m_pDispatcher = pDispatcher;

    // Based on the event type GUID, we can calculate which
    // event type id this goes to
    for (m_dwEventType = 0;
         m_dwEventType < PE_OET_INVALID_EVENT_TYPE;
         m_dwEventType++)
        if (rguidEventType == *(s_rgrguidEventTypes[m_dwEventType]))
            break;
    // If the GUID is not recognized, then the final value of
    // m_dwEventType will be PE_OET_INVALID_EVENT_TYPE, which
    // we will not process in this dispatcher
}


HRESULT COutboundDispatcher::COutboundBinding::Init(
            IEventBinding *piBinding
            )
{
    HRESULT hr;
    CComPtr<IEventPropertyBag>  piEventProperties;
    CComVariant                 vRule;
    CHAR                        szCommandKeyword[256];
    DWORD                       cchCommandKeyword = 0;

    TraceFunctEnterEx((LPARAM)this,
            "COutboundDispatcher::COutboundBinding::Init");

    if (!piBinding || !m_pDispatcher)
        return(E_POINTER);

    // If the event type GUID is unknown, invalidate this binding
    if (m_dwEventType >= PE_OET_INVALID_EVENT_TYPE)
        return(E_INVALIDARG);

    // get the parent initialized
    hr = CBinding::Init(piBinding);
    if (FAILED(hr)) return hr;

    // Store the priority
    m_bnInfo.dwPriority = CBinding::m_dwPriority;
    m_bnInfo.dwFlags = 0;

    // get the binding database
    hr = m_piBinding->get_SourceProperties(&piEventProperties);
    if (FAILED(hr)) return hr;

    // get the rule from the binding database
    hr = piEventProperties->Item(&CComVariant("Rule"), &vRule);
    if (FAILED(hr)) return hr;

    // Process the VARIANT to obtain a lower-case ANSI string
    if (hr == S_OK)
    {
        cchCommandKeyword = sizeof(szCommandKeyword);
        hr = GetLowerAnsiStringFromVariant(
                    vRule,
                    szCommandKeyword,
                    &cchCommandKeyword);
    }
    else if(hr == S_FALSE)
    {
        //
        // Treat no rule as an empty string rule
        //
        szCommandKeyword[0] = '\0';
        cchCommandKeyword = 1;
    }


    // We cannot proceed without a rule, so we discard this binding
    if (FAILED(hr))
    {
        ErrorTrace((LPARAM)this,
                "Failed to get keyword, error %08x", hr);
        return(hr);
    }
    if (!cchCommandKeyword)
        return(E_INVALIDARG);

    DebugTrace((LPARAM)this, "Rule: %s", szCommandKeyword);

    // Call the dispatcher to insert the node into the command list
    hr = CGenericProtoclEventDispatcher::InsertBinding(
                &((m_pDispatcher->m_rgpCommandList)[m_dwEventType]),
                &m_bnInfo,
                szCommandKeyword,
                cchCommandKeyword);
    if (SUCCEEDED(hr))
        m_pDispatcher->m_fSinksInstalled = TRUE;

    TraceFunctLeaveEx((LPARAM)this);
    return(hr);
}


//
// CResponseDispatcher mathods
//

HRESULT CResponseDispatcher::AllocBinding(
            REFGUID         rguidEventType,
            IEventBinding   *piBinding,
            CBinding        **ppNewBinding
            )
{
    if (ppNewBinding)
        *ppNewBinding = NULL;
    if (!piBinding || !ppNewBinding)
        return(E_POINTER);

    *ppNewBinding = new CResponseBinding(this);

    if (*ppNewBinding == NULL)
        return(E_OUTOFMEMORY);
    return(S_OK);
}

HRESULT STDMETHODCALLTYPE CResponseDispatcher::ChainSinks(
            IUnknown                    *pServer,
            IUnknown                    *pSession,
            IMailMsgProperties          *pMsg,
            ISmtpServerResponseContext  *pContext,
            DWORD                       dwStopAtPriority,
            LPPE_COMMAND_NODE           pCommandNode,
            LPPE_BINDING_NODE           *ppResumeFrom
            )
{
    HRESULT hr = S_OK;

    LPPE_BINDING_NODE   pBinding = NULL;

    TraceFunctEnterEx((LPARAM)this, "CResponseDispatcher::ChainSinks");

    // These are the essential pointers that CANNOT be NULL
    if (!pContext || !pCommandNode || !ppResumeFrom)
        return(E_POINTER);

    // What we do is strictly determined by the ppPreviousCommand
    // and ppResumeFrom pointers. The logic is as follows:
    //
    // pCmdNode     ppResumeFrom    Action
    //    NULL          X           Error (E_POINTER)
    //   !NULL          NULL        Error (ERROR_NO_MORE_ITEMS)
    //   !NULL         !NULL        Start from the exact binding specified in
    //                                *ppResumeFrom
    //
    // On exit, these pointers will be updated to the following:
    //
    // *ppResumeFrom      - This will be set to the next binding to resume from
    //                      This will be set to NULL if there are no more bindings

    pBinding = *ppResumeFrom;
    if (!pBinding)
    {
        _ASSERT(FALSE);
        ErrorTrace((LPARAM)this, "ERROR! Empty binding chain!!");
        return(HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS));
    }

    // We know exactly where to start chaining ... Do it.
    // Break when:
    // 1) The default handler binding is encountered, or
    // 2) Sinks results are S_OK
    // 3) No more bindings left
    CResponseBinding        *pResponseBinding;
    IUnknown                *pUnkSink = NULL;
    ISmtpServerResponseSink *pSink;

    hr = S_OK;
    *ppResumeFrom = pBinding;
    while (pBinding && (hr == S_OK))
    {
        // One of the exiting conditions
        if (pBinding->dwPriority > dwStopAtPriority)
            break;

        // Get the containing binding class
        pResponseBinding = CONTAINING_RECORD(
                    pBinding, CResponseBinding, m_bnInfo);

        // Call the sink
        hr = m_piEventManager->CreateSink(
                    pResponseBinding->m_piBinding,
                    NULL,
                    &pUnkSink);
        if (SUCCEEDED(hr))
        {
            hr = pUnkSink->QueryInterface(
                        IID_ISmtpServerResponseSink,
                        (LPVOID *)&pSink);
            pUnkSink->Release();
            pUnkSink = NULL;
            if (SUCCEEDED(hr))
            {
                // Pre-fill in the next binding to avoid
                // race conditions in the async case
                hr = pSink->OnSmtpServerResponse(
                            pServer,
                            pSession,
                            pMsg,
                            pContext);
                pSink->Release();
                if (hr == MAILTRANSPORT_S_PENDING)
                    hr = S_OK;
                //  break;
            }
            else
                hr = S_OK;
        }
        else
            hr = S_OK;

        // Next
        pBinding = pBinding->pNext;
        *ppResumeFrom = pBinding;
    }

    TraceFunctLeaveEx((LPARAM)this);
    return(hr);
}

//
// CResponseDispatcher::CResponseBinding methods
//
HRESULT CResponseDispatcher::CResponseBinding::Init(
            IEventBinding *piBinding
            )
{
    HRESULT hr;
    CComPtr<IEventPropertyBag>  piEventProperties;
    CComVariant                 vRule;
    CHAR                        szCommandKeyword[256];
    DWORD                       cchCommandKeyword = 0;

    TraceFunctEnterEx((LPARAM)this,
            "CResponseDispatcher::CResponseBinding::Init");

    if (!piBinding || !m_pDispatcher)
        return(E_POINTER);

    // get the parent initialized
    hr = CBinding::Init(piBinding);
    if (FAILED(hr)) return hr;

    // Store the priority
    m_bnInfo.dwPriority = CBinding::m_dwPriority;
    m_bnInfo.dwFlags = 0;

    // get the binding database
    hr = m_piBinding->get_SourceProperties(&piEventProperties);
    if (FAILED(hr)) return hr;

    // get the rule from the binding database
    hr = piEventProperties->Item(&CComVariant("Rule"), &vRule);
    if (FAILED(hr)) return hr;

    // Process the VARIANT to obtain a lower-case ANSI string
    if (hr == S_OK)
    {
        cchCommandKeyword = sizeof(szCommandKeyword);
        hr = GetLowerAnsiStringFromVariant(
                    vRule,
                    szCommandKeyword,
                    &cchCommandKeyword);
    }

    // We cannot proceed without a rule, so we discard this binding
    if (FAILED(hr))
    {
        ErrorTrace((LPARAM)this,
                "Failed to get keyword, error %08x", hr);
        return(hr);
    }
    if (!cchCommandKeyword || !(*szCommandKeyword))
        return(E_INVALIDARG);

    DebugTrace((LPARAM)this, "Rule: %s", szCommandKeyword);

    // Call the dispatcher to insert the node into the command list
    hr = CGenericProtoclEventDispatcher::InsertBindingWithHash(
                m_pDispatcher->m_rgpCommandList,
                m_pDispatcher->m_dwHashSize,
                &m_bnInfo,
                szCommandKeyword,
                cchCommandKeyword);
    if (SUCCEEDED(hr))
        m_pDispatcher->m_fSinksInstalled = TRUE;

    TraceFunctLeaveEx((LPARAM)this);
    return(hr);
}