Tricks of the Windows Gam…ming Gurus (2nd Edition)/Disc2.iso/msdn_vcb/samples/vc98/sdk/dbmsg/mapi/remote.xp/xplogon.cpp

C/C++ Source or Header | 1996-04-11 | 123.3 KB | 3,225 lines

//////////////////////////////////////////////////////////////////////////////
//
//  File Name
//      XPLOGON.CPP
//
//  Description
//      This file implements the IXPLogon interface with the methods specified
//      in the MAPI SPI 1.0.
//
//  Authors
//      Irving De la Cruz
//      Les Thaler
//
//  Revision: 1.7
//
// Written for Microsoft Windows Developer Support
// Copyright (c) 1995-1996 Microsoft Corporation. All rights reserved.
//
//
#include "XPWDSR.H"

#define DO_INFO_TRACES
#ifdef DO_INFO_TRACES
#define InfoTrace(a)   TraceInfoMessage(a)
#else
#define InfoTrace(a)
#endif // DO_INFO_TRACES

// Remark this line to turn verbose tracing OFF
MAPIUID guidABEntries = AB_UID_PROVIDER;
MAPIUID guidXPABEntries = XP_WINDS_AB_ENTRIES;
MAPIUID * puidWINDSEntries;
TCHAR gszProviderName[] = TEXT("WINDS Transport Service");
LPTSTR gszWINDSAddressType = WINDS_ADDRESS_TYPE;
LPTSTR * gpszXPAddressTypes;

void CALLBACK UploadTimerProc (HWND    hOwnerWnd,
                               UINT    Message,
                               UINT    idEvent,
                               DWORD   dwTime);

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::CXPLogon()
//
//    Parameters
//      hInstance               Instance of the provider DLL
//      pSupObj                 Pointer to IMAPISupport object used in
//                              CXPLogon methods
//      pszHeadersFile          Full file path where the remote headers are
//                              store in the local computer.
//      fGetHeaders             Weather or not to get the headers of the
//                              mailbox during a scheduled connection.
//      pUserMailboxInfo        Pointer to a MAILBOX_INFO structure with the
//                              information of the logged user as store in
//                              the WINDS server.
//      dwMailboxID             ID of the user in the WINDS system.
//      pszRemoteServer         Name of the remote WINDS server to which
//                              this transport communicates
//      hUIMutex                Handle to a WINDS mutex to allow single access
//                              to the UI configuration of this provider.
//
//    Purpose
//      Constructor of the object. Parameters are passed to initialize the
//      data members with the appropiate values.
//
//    Return Value
//      None
//
CXPLogon::CXPLogon (HINSTANCE       hInstance,
                    LPMAPISUP       pSupObj,
                    LPTSTR          pszHeadersFile,
                    BOOL            fGetHeaders,
                    PMAILBOX_INFO   pUserMailboxInfo,
                    DWORD           dwMailboxID,
                    LPTSTR          pszRemoteServer,
                    HANDLE          hUIMutex)
{
    InfoTrace ("CXPLogon: Constructor called");
    m_cRef           = 1;
    m_pIdentityProps = NULL;
    m_hInstance      = hInstance;
    m_pSupObj        = pSupObj;
    m_pStatusObj     = NULL;
    m_pIdentityProps = NULL;
    ZeroMemory (&m_stDelivTime, sizeof(SYSTEMTIME));
    m_uTimerID       = 0;
    m_hTimerWnd      = NULL;
    m_fABWDSInstalled = FALSE;
    m_fGetHeaders    = fGetHeaders;
    m_hUIMutex       = hUIMutex;
    m_raAction       = REMOTE_ACTION_IDLE;
    m_UserInfo       = *pUserMailboxInfo;
    ZeroMemory (&m_UserEID, CB_PRIVATE_EID);
    m_UserEID.uidGlobal = guidABEntries;
    m_UserEID.bVersion = ENTRYID_VERSION;
    m_UserEID.bObject = MAPI_MAILUSER;
    m_UserEID.dwObjID = dwMailboxID;

    m_pSupObj->AddRef();

    lstrcpy (m_szHeaders, pszHeadersFile);
    lstrcpy (m_szServer, pszRemoteServer);

    wsprintf (m_szAddress, TEXT("%s\\%s"), m_szServer, m_UserInfo.szMailboxName);

    // Initialize the messages download list object
    m_List.SetLogon(this);
    if (!m_List.Init())
    {
        throw CException (E_OUTOFMEMORY);
    }
    SetTransportState (WAITING);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::~CXPLogon()
//
//    Parameters
//      None
//
//    Purpose
//      Destructor of CXPLogon. Releases memory allocated for internal
//      properties during the life of this transport logon object.
//
//    Return Value
//      None
//
CXPLogon::~CXPLogon()
{
    InfoTrace ("CXPLogon: Destructor called");
    gpfnFreeBuffer (m_pIdentityProps);
    CloseHandle (m_hUIMutex);

    EmptyInboundQueue();

    // Delete CMAPIStatus Object
/*    if (m_pStatusObj)
    {
        m_pStatusObj->Release();
        m_pStatusObj = NULL;
    }
*/
    // Release the IMAPISupport object
    m_pSupObj->Release();
    m_pSupObj = NULL;

    // Just as a safety precaution, make sure the timer is off.
    StopUploadTimer();

    // Just in case the DLL is still hanging around
    PrivUninitialize3DCtl (m_hInstance);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::QueryInterface()
//
//    Parameters
//      { Refer to OLE Documentation on this method }
//
//    Purpose
//      Returns a pointer to a interface requested if the interface is
//      supported and implemented by this object. If it is not supported, it
//      returns NULL
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::QueryInterface (REFIID riid, LPVOID * ppvObj)
{
    // OLE requires NULLing parameter
    *ppvObj = NULL;
    // If this is one of the two IID return an interface pointer to it
    if (riid == IID_IXPLogon || riid == IID_IUnknown)
    {
        *ppvObj = (LPVOID)this;
        // Increase usage count of this object
        AddRef();
        return S_OK;
    }
    // This object does not support the interface requested
    return E_NOINTERFACE;
}

///////////////////////////////////////////////////////////////////////////////
// IXPLogon virtual member functions implementation
//

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::AddressType()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      Called by the MAPI Spooler when initializing this XP logon object to
//      allow the transport to register the address it will handle
//
//    Return Value
//      S_OK always
//
STDMETHODIMP CXPLogon::AddressTypes (ULONG *        pulFlags,
                                     ULONG *        pcAdrType,
                                     LPTSTR **      pppAdrTypeArray,
                                     ULONG *        pcMAPIUID,
                                     LPMAPIUID **   pppMAPIUIDArray)
{
    InfoTrace ("CXPLogon::AddressTypes method called");
    CheckParameters_IXPLogon_AddressTypes (this,
                                           pulFlags,
                                           pcAdrType,
                                           pppAdrTypeArray,
                                           pcMAPIUID,
                                           pppMAPIUIDArray);

    // This is how many address type strings we are returning in pppAdrTypeArray
    *pcAdrType = 1;

    // Copy address types back to the MAPI pointer
    gpszXPAddressTypes = &gszWINDSAddressType;
    *pppAdrTypeArray = gpszXPAddressTypes;
    *pulFlags = fMapiUnicode;

    // The UID for routing message has to be set here. If it is not used, set it NULL.
    // In the case of WINDS transport registers support for the UID of
    // the WINDS address book's entry ID
    puidWINDSEntries = &guidABEntries;
    *pcMAPIUID = 1;
    *pppMAPIUIDArray = &puidWINDSEntries;
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::RegisterOptions()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      This transport does not registers any per-recipient or per-message
//      option processing, so we return 0 options. And NULL in the OPTIONDATA
//      structure pointer.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::RegisterOptions (ULONG *         pulFlags,
                                        ULONG *         pcOptions,
                                        LPOPTIONDATA *  ppOptions)
{
    InfoTrace ("CXPLogon::RegisterOptions method called");
    CheckParameters_IXPLogon_RegisterOptions (this,
                                              pulFlags,
                                              pcOptions,
                                              ppOptions);
    *pulFlags = 0;
    *pcOptions = 0;
    *ppOptions = NULL;
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::TransportNotify()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      Update the status row registered by this transport with MAPI
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::TransportNotify (ULONG * pulFlags, LPVOID * ppvData)
{
    InfoTrace ("CXPLogon::TransportNotify method called");
    CheckParameters_IXPLogon_TransportNotify (this,
                                              pulFlags,
                                              ppvData);

    ULONG ulOldStatus = GetTransportStatusCode();
    // Set appropriate status flags and re-register status row
    if (*pulFlags & NOTIFY_BEGIN_INBOUND)
    {
        InfoTrace ("CXPLogon::TransportNotify: Begin INBOUND logic");
        AddStatusBits (STATUS_INBOUND_ENABLED);
    }
    if (*pulFlags & NOTIFY_END_INBOUND)
    {
        InfoTrace ("CXPLogon::TransportNotify: Terminate INBOUND logic");
        RemoveStatusBits (STATUS_INBOUND_ENABLED);
    }
    if (*pulFlags & NOTIFY_BEGIN_OUTBOUND)
    {
        InfoTrace ("CXPLogon::TransportNotify: Begin OUTBOUND logic");
        AddStatusBits (STATUS_OUTBOUND_ENABLED);
        InitializeTimer();
        StartUploadTimer();
    }
    if (*pulFlags & NOTIFY_END_OUTBOUND)
    {
        InfoTrace ("CXPLogon::TransportNotify: Terminate OUTBOUND logic");
        RemoveStatusBits (STATUS_OUTBOUND_ENABLED);
        StopUploadTimer();
    }
    if (*pulFlags & NOTIFY_BEGIN_OUTBOUND_FLUSH)
    {
        InfoTrace ("CXPLogon::TransportNotify: Begin OUTBOUND flush");
        // If the spooler need to flush us for some reason, we put ourselves
        // in FLUSH and tell the spooler to give us any deferred messages
        // it has queued up for us.
        AddStatusBits (UPLOADING_MESSAGES); // Add these bits to the status code
        SetTransportState (READY);
        m_pSupObj->SpoolerNotify (NOTIFY_SENTDEFERRED, NULL);
    }
    if (*pulFlags & NOTIFY_END_INBOUND_FLUSH)
    {
        InfoTrace ("CXPLogon::TransportNotify: Terminate INBOUND flush");
        if (FALSE == m_List.AreTherePendingDownloads())
        {
            RemoveStatusBits (DOWNLOADING_MESSAGES); // Tell the spooler to take us off from inbound flush
            AddStatusBits (STATUS_OFFLINE); // The transport is now OFF line
            UpdateStatus (TRUE, TRUE);
        }
    }
    if (*pulFlags & NOTIFY_END_OUTBOUND_FLUSH)
    {
        InfoTrace ("CXPLogon::TransportNotify: Terminate OUTBOUND flush");
        if (GetTransportStatusCode() & UPLOADING_MESSAGES)
        {
            // When the spooler finished sending messages to our CXPLogon::SubmitMessage
            // method, he will call us to let us know there is nothing else we need to
            // flush, and we need to reset our status row.
            RemoveStatusBits (UPLOADING_MESSAGES); // Tell the spooler to take us off from outbound flush
            AddStatusBits (STATUS_OFFLINE); // The transport is now OFF line
            if (PENDING_RETURN_CODE != GetTransportState())
            {
                SetTransportState (WAITING);
            }
        }
    }

    // We get called here if user deletes/modifies queued msg in Outbox.
    // If the user modifies and resends it, we get called again at SubmitMessage.
    // If the user closes the message viewer or just saves it, it's removed
    // from the spooler queue and discarded.
    if (*pulFlags & NOTIFY_ABORT_DEFERRED)
    {
        InfoTrace ("CXPLogon::TransportNotify: Abort deferred message");
    }
    if (*pulFlags & NOTIFY_CANCEL_MESSAGE)
    {
        InfoTrace ("CXPLogon::TransportNotify: Cancel message");
    }
    if (ulOldStatus != GetTransportStatusCode())
    {
        UpdateStatus();
    }
    if (*pulFlags & NOTIFY_BEGIN_INBOUND)
    {
        // If we have pending message from a previous session, notify the
        // spooler that we are ready to give them to the store.
        if (m_List.AreTherePendingDownloads())
        {
            // Put ourselves into flush mode and have the spooler call us until
            // we are finished putting the downloaded messages into the default store.
            AddStatusBits (DOWNLOADING_MESSAGES); // Add these bits to the status code
            UpdateStatus();
        }
    }
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::Idle()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      Stub method. We should not get called here, because we told
//      the spooler not to call us here.
//
//    Return Value
//      S_OK always.
//
STDMETHODIMP CXPLogon::Idle (ULONG ulFlags)
{
    InfoTrace ("CXPLogon::Idle method called");
    CheckParameters_IXPLogon_Idle (this, ulFlags);
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::TransportLogoff()
//
//    Parameters
//      ulFlags     Priority with which the transport should log off
//
//    Purpose
//      This method is called by the spooler when the transport should do final
//      arragements before it gets released.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::TransportLogoff (ULONG ulFlags)
{
    InfoTrace ("CXPLogon::TransportLogoff method called");
    CheckParameters_IXPLogon_TransportLogoff (this, ulFlags);
    StopUploadTimer();

    EmptyInboundQueue();

    // We should attempt to remove the transport's status row from
    // the system, but if we fail we won't fail the call.
    HRESULT hResult = m_pSupObj->ModifyStatusRow (0, NULL, 0);
    TraceResult ("CXPLogon::TransportLogoff: Failed to remove status row", hResult);

    if (m_pStatusObj)
    {
        m_pStatusObj->Release();
        m_pStatusObj = NULL;
    }

    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::SubmitMessage()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      This method is called by the spooler when a client submits a
//      message to a recipient whose address type this transport handles.
//      The spooler calls this method twice for each deferred message.
//      The first time (before the delivery time) when the message is
//      submitted by the client, we simply return. The message is then queued
//      by the spooler for later delivery. We keep track of when it's time
//      to send deferred messages.
//
//      The second time we're called, the state variable will be 'READY' and
//      we go ahead and start the actual transmission. While we're in the
//      body of this function, the implied state is 'SENDING'
//
//      If the client logs out of this session, any pending messages get
//      queued again the next time it logs in.
//
//      In this transport we get a recipient table, we restrict the table for
//      unmarked recipients. After the table is ready we invoke a helper
//      method to do the actual transmission.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::SubmitMessage (ULONG     ulFlags,
                                      LPMESSAGE pMsgObj,
                                      ULONG *   pulMsgRef,
                                      ULONG *   pulReturnParm)
{
    InfoTrace ("CXPLogon::SubmitMessage method called");
    CheckParameters_IXPLogon_SubmitMessage (this,
                                            ulFlags,
                                            pMsgObj,
                                            pulMsgRef,
                                            pulReturnParm);

    #ifdef _DEBUG
    // Before we get called in SubmitMessage or StartMessage, the spooler should have called
    // us in TransportNotify() to let us know which logic (IN, OUT, BOTH) of the
    // transporting mechanism should be activated for this IXPLogon session.
    if (!(GetTransportStatusCode() & STATUS_OUTBOUND_ENABLED))
    {
        TraceMessage ("CXPLogon::SubmitMessage: We can't send a message if the outbound is not enabled");
        ASSERTMSG (FALSE, "We can't submit a message if we have not started OUTBOUND logic");
        return MAPI_E_NOT_ME;
    }
    #endif // _DEBUG

    // Lock the object against the timer thread re-entrancy. Timer events are handle
    // in a separate thread. This section will get unlocked in the CPXLogon::EndMessage() call
    if (WAITING == GetTransportState())
    {
        // Not scheduled upload time, return and let IXPLogon::EndMessage() defer the message
        InfoTrace ("CXPLogon::SubmitMessage: Deferring message for scheduled submission");
        return S_OK;
    }
    InfoTrace ("CXPLogon::SubmitMessage: Processing deferred message");

    CheckSpoolerYield (TRUE);

    // Notify the MAPI spooler the transport is going to flush any queued up messages and submit them.
    // Transport to used shared resources, such as COM ports, should put them selves into flush mode
    // when submitting a batch of messages. This gives the transport the advantage of locking shared
    // resources across submitted messages and ensures that the spooler does not call other
    // transports while another is flushing because it could have something locked.
    // This transport does not uses any shared resources that we would need to lock, but for the
    // purposes of demonstration, we put our selves into flush mode until the MAPI spooler
    // tells us to step down.
    if (!(GetTransportStatusCode() & UPLOADING_MESSAGES))
    {
        AddStatusBits (UPLOADING_MESSAGES);
        UpdateStatus();
    }

    // Get the recipient table from the message
    LPMAPITABLE pTable = NULL;
    HRESULT hResult = pMsgObj->GetRecipientTable (fMapiUnicode, &pTable);
    if (hResult)
    {
        TraceResult ("CXPLogon::SubmitMessage: Failed to get the recipient table", hResult);
        goto ErrorExit;
    }

    // The spooler marks all the message recipients this transport has to
    // handle with PR_RESPONSIBILITY set to FALSE
    SPropValue spvRecipUnsent;
    spvRecipUnsent.ulPropTag                       = PR_RESPONSIBILITY;
    spvRecipUnsent.Value.b                         = FALSE;

    SRestriction srRecipientUnhandled;
    srRecipientUnhandled.rt                        = RES_PROPERTY;
    srRecipientUnhandled.res.resProperty.relop     = RELOP_EQ;
    srRecipientUnhandled.res.resProperty.ulPropTag = PR_RESPONSIBILITY;
    srRecipientUnhandled.res.resProperty.lpProp    = &spvRecipUnsent;

    hResult = pTable->Restrict (&srRecipientUnhandled, 0L);
    if (hResult)
    {
        TraceResult ("CXPLogon::SubmitMessage: Failed to restrict the recipient table", hResult);
        goto ErrorExit;
    }

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    hResult = HrAddColumns (pTable,
                            (LPSPropTagArray)&sptRecipTable,
                            gpfnAllocateBuffer,
                            gpfnFreeBuffer);
    if (hResult)
    {
        TraceResult ("CXPLogon::SubmitMessage: Failed to expand the columns in the recipient table", hResult);
        goto ErrorExit;
    }

    LPSRowSet pRecipRows;
    hResult = HrQueryAllRows (pTable,
                              NULL,
                              NULL,
                              NULL,
                              0,
                              &pRecipRows);
    if (!hResult)
    {
        // Let the MAPI spooler do other things
        CheckSpoolerYield();
        // Send to the recipients which we can reach, and generate NDR's for the ones we can't
        hResult = SendMailMessage (pMsgObj, pRecipRows);
        FreeProws (pRecipRows);
        if (!hResult)
        {
            // Now we need to save changes on the message and close it.
            // After this, the message object can't be used.
            hResult = pMsgObj->SaveChanges (0);
            TraceResult ("CXPLogon::SubmitMessage: Failed to save the message object", hResult);
        }
    }

ErrorExit:
     // Release the table, we're finished with it
    if (pTable)
    {
        pTable->Release();
    }

    // Release the spooler's message if needed to
    if (pMsgObj)
    {
        pMsgObj->Release ();
    }

    // In case there is a warning or error floating around, don't let it escape to the spooler.
    if (FAILED(hResult))
    {
        // We default to MAPI_E_NOT_ME so that the spooler would attempt handle
        // the message to other transport (currently running in this profile)
        // that handle the same address type as ours.
        TraceMessage ("CXPLogon::SubmitMessage: An error occurred in the submission, returning MAPI_E_NOT_ME");
        hResult = MAPI_E_NOT_ME;
    }
    else
    {
        hResult = S_OK;
    }
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::EndMessage()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      This method is called by the spooler for each message we're to
//      deliver. It's the mate to SubmitMessage. We're called here twice
//      for each deferred message and once for non-deferred (realtime)
//      messages.
//
//      We first check the transport state, and if we're
//      WAITING for the scheduled delivery time to arrive, we return
//      END_DONT_RESEND in *pulFlags, which tells the spooler to queue this
//      message for deferred delivery.
//
//      If the state is SENDING, we're getting called here after
//      a message has been dequeued and delivered. Return 0 in *pulFlags
//      to tell the spooler the message has been delivered.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::EndMessage (ULONG ulMsgRef, ULONG * pulFlags)
{
    InfoTrace ("CXPLogon::EndMessage method called");
    CheckParameters_IXPLogon_EndMessage (this, ulMsgRef, pulFlags);

    if (WAITING == GetTransportState())
    {
        // Tell spooler to queue msg for deferred delivery
        *pulFlags = END_DONT_RESEND;
    }
    else
    {
        *pulFlags = 0;
    }
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::Poll()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      Stub method. We should not get called here, because we told
//      the spooler not to call us here.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::Poll (ULONG * pulIncoming)
{
    InfoTrace ("CXPLogon::Poll method called");
    CheckParameters_IXPLogon_Poll (this, pulIncoming);
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::StartMessage()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      This method gets called when an incoming message is pending to be
//      processed.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::StartMessage (ULONG      ulFlags,
                                     LPMESSAGE  pMsgObj,
                                     ULONG *    pulMsgRef)
{
    InfoTrace ("CXPLogon::StartMessage method called");
    CheckParameters_IXPLogon_StartMessage (this, ulFlags, pMsgObj, pulMsgRef);

    // Initialize the pseudo-timer for the SpoolerYield() call
    CheckSpoolerYield (TRUE);

    HRESULT hResult = S_OK;
    LPSTREAM pFileStream = NULL;
    CCachedStream * pStream = NULL;
    LPITNEF pTNEFObj = NULL;
    SPropTagArray sptExcludedProps = { 0 };

    PLIST_NODE pNode = m_List.GetDownloadNode();
    if (!pNode)
    {
        RemoveStatusBits (DOWNLOADING_MESSAGES); // Remove these bits from the status code
        UpdateStatus();
        if (READY == GetTransportState())
        {
            SetTransportState (WAITING);
        }
        goto ErrorExit;
    }
    // Close the file so that we may open it in the call below
    if (pNode->hFile)
    {
        CloseHandle (pNode->hFile);
        // NULL the handle to avoid closing the file again during cleanup.
        pNode->hFile = NULL;
    }
    // Open the stream where the message properties are.
    hResult = OpenStreamOnFile (gpfnAllocateBuffer,
                                gpfnFreeBuffer,
                                STGM_READ,
                                pNode->szFileName,
                                NULL,
                                &pFileStream);
    if (hResult)
    {
        TraceResult ("CXPLogon::StartMessage: Failed to open stream on the message file", hResult);
        goto ErrorExit;
    }
    try
    {
        // Create a buffer IStream interface for the TNEF decoding
        pStream = new CCachedStream (pFileStream, XPSOF_READ);
        if (!pStream)
        {
            TraceMessage ("CXPLogon::StartMessage: Failed to allocate cached stream object");
            hResult = E_OUTOFMEMORY;
        }
    }
    catch (CException & Exception)
    {
        hResult = Exception.GetError();
    }
    pFileStream->Release();
    pFileStream = NULL;
    if (hResult)
    {
        goto ErrorExit;
    }
    hResult = OpenTnefStream (m_pSupObj,
                              pStream,
                              TNEF_FILE_NAME,
                              TNEF_DECODE,
                              pMsgObj,
                              0,    // Not needed when decoding TNEF
                              &pTNEFObj);
    if (hResult)
    {
        TraceResult ("CXPLogon::StartMessage: Failed to open TNEF stream object", hResult);
        goto ErrorExit;
    }

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    // Get the properties for the message which are encoded in the TNEF
    // message stream. The sptExcludedProps argument, is just a stub,
    // we are not excluding any properties
    LPSTnefProblemArray pProblems;
    pProblems = NULL;
    hResult = pTNEFObj->ExtractProps (TNEF_PROP_EXCLUDE, &sptExcludedProps, &pProblems);
    if (pProblems)
    {
        gpfnFreeBuffer (pProblems);
        pProblems = NULL;
    }
    if (hResult)
    {
        TraceResult ("CXPLogon::StartMessage: Failed to open TNEF stream", hResult);
        goto ErrorExit;
    }
    if (MAPI_E_CORRUPT_DATA == SetIncomingProps (pMsgObj, pNode))
    {
        pNode = NULL; // To avoid deleting it below.
    }

    // Save all chages and new properties, back on the message
    // Don't release the message object. The spooler is still using it.
    // After this, the message object can't be used by this transport.
    hResult = pMsgObj->SaveChanges (0);
    TraceResult ("CXPLogon::StartMessage: Failed to save the message object", hResult);

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

ErrorExit:
    // Release used objects
    if (pTNEFObj)
    {
        pTNEFObj->Release();
    }
    if (pStream)
    {
        pStream->Release();
    }
    if (pNode)
    {
        if (pNode->hFile)
        {
            CloseHandle (pNode->hFile);
        }
        // Delete the file ONLY if the we were successful putting the
        // file data into the message. Otherwise leave the file in
        // the directory, and it will be picked up later
        if (S_OK == hResult)
        {
            DeleteFile (pNode->szFileName);
        }
        delete pNode;
    }
    m_List.UpdateProgress();
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::OpenStatusEntry()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      This method is called to get an IMAPIStatus object for this XPLOGON
//      session.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::OpenStatusEntry (LPCIID          pInterface,
                                        ULONG           ulFlags,
                                        ULONG *         pulObjType,
                                        LPMAPISTATUS *  ppEntry)
{
    InfoTrace ("CXPLogon::OpenStatusEntry method called");
    CheckParameters_IXPLogon_OpenStatusEntry (this,
                                              pInterface,
                                              ulFlags,
                                              pulObjType,
                                              ppEntry);
    if (MAPI_MODIFY & ulFlags)
    {
        TraceMessage ("CXPLogon::OpenStatusEntry: We don't support WRITE access to the status object");
        return E_ACCESSDENIED;
    }

    HRESULT hResult = S_OK;
    // Now, if we already have created a status object on this logon context,
    // we'll just use QueryInterface to get a new copy (AddRef() it) of the object
    if (!m_pStatusObj)
    {
        // Get the profile section of the PROVIDER so that we may get some properties,
        // assigned by MAPI to this provider, directly on the status object.
        LPPROFSECT pProfileObj = NULL;
        m_pSupObj->OpenProfileSection (NULL, 0, &pProfileObj);
        // If we don't have an object, create it, and save a copy in the logon object
        m_pStatusObj = new CMAPIStatus (this, pProfileObj);
        if (!m_pStatusObj)
        {
            TraceMessage ("CXPLogon::OpenStatusEntry: Could not allocate new CMAPIStatus object");
            hResult = E_OUTOFMEMORY;
        }
        // The constructor of CMAPIStatus AddRef()'ed this object
        if (pProfileObj)
        {
            pProfileObj->Release();
        }
    }
    if (!hResult)
    {
        // The transport will return *ppEntry == NULL or a pointer to the new memory allocated
        m_pStatusObj->AddRef();
        *ppEntry = m_pStatusObj;
        *pulObjType = MAPI_STATUS;
    }
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::ValidateState()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      This function gets caller by a client in order to validate the
//      transport logon properties. This function open the profile with the
//      most up-to-date properties and then compares them to what the transport
//      has stored internally
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::ValidateState (ULONG ulUIParam, ULONG ulFlags)
{
    InfoTrace ("CXPLogon::ValidateState method called");
    CheckParameters_IXPLogon_ValidateState (this,
                                            ulUIParam,
                                            ulFlags);

    // Try to open the transport profile section
    LPPROFSECT pProfileObj;
    HRESULT hResult = OpenServiceProfileSection (m_pSupObj, &pProfileObj, gpfnFreeBuffer);
    if (hResult)
    {
        return hResult;
    }

    LPSPropValue pProps = NULL;
    ULONG ulPropCount;
    // Read the properties stored in the profile of this user
    hResult = pProfileObj->GetProps ((LPSPropTagArray)&sptLogonProps,
                                     fMapiUnicode,
                                     &ulPropCount,
                                     &pProps);
    TraceResult ("CXPLogon::ValidateState: Failed to get profile properties", hResult);
    if (!hResult)
    {
        // Now, compare what the transport thinks the information in the profile is
        // to the real data. If they are different, tell the spooler the transport
        // would like to be reloaded
        if (lstrcmp (m_UserInfo.szMailboxName, pProps[MAILBOX_NAME].Value.LPSZ)||
            lstrcmp (m_UserInfo.szPassword, pProps[PASSWORD].Value.LPSZ) ||
            lstrcmp (m_UserInfo.szFullName, pProps[USER_NAME].Value.LPSZ) ||
            lstrcmpi (m_szServer, pProps[SERVER_NAME].Value.LPSZ))
        {
            hResult = m_pSupObj->SpoolerNotify (NOTIFY_CONFIG_CHANGE, NULL);
            TraceResult ("CXPLogon::ValidateState: Failed to notify the spooler", hResult);
        }
    }
    pProfileObj->Release();
    gpfnFreeBuffer (pProps);
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::FlushQueues()
//
//    Parameters
//      { Refer to MAPI Documentation on this method }
//
//    Purpose
//      Called by the MAPI spooler when, upon request of the client or
//      ourselves, we need to flush the inbound or outbound queue.
//      Here we make connections to the server to download messages, refresh
//      the remote message headers, and request the spooler to send us any
//      deferred messages.
//      Transport connecting only in FlushQueues() allow the MAPI spooler to
//      better manage contention of multiple transport accessing common
//      communication resources (such as COM ports) and let the spooler give us
//      messages to process when is best for the overall subsystem.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::FlushQueues (ULONG       ulUIParam,
                                    ULONG       cbTargetTransport,
                                    LPENTRYID   pTargetTransport,
                                    ULONG       ulFlags)
{
    InfoTrace ("CXPLogon::FlushQueues method called");
    CheckParameters_IXPLogon_FlushQueues (this,
                                          ulUIParam,
                                          cbTargetTransport,
                                          pTargetTransport,
                                          ulFlags);

    HRESULT hResult = S_OK;
    // Update status flags and then update update the transport status rows
    if (ulFlags & FLUSH_UPLOAD)
    {
        // If the remote server is offline, the transport is not going to send the deferred messages
        if (TRUE == IsWINDSServerAvailable (m_szServer))
        {
            // If we are already in delivery mode submitted messages will not get deferred,
            // so don't bother the spooler asking for deferred messages.
            if (READY != GetTransportState())
            {
                // Guard against re-entrancy from the timer call back which happens on a separate thread
                if (PROCESSING_TIMER_EVENT != GetTransportState())
                {
                    SetTransportState (READY);
                }
                // We pass NULL for the entry ID so that the spooler would resend ALL the
                // deferred messages. Transport may pass individual entry IDs for specific messages.
                hResult = m_pSupObj->SpoolerNotify (NOTIFY_SENTDEFERRED, NULL);
            }
        }
    }
    if (ulFlags & FLUSH_DOWNLOAD)
    {
        if (HEADERS_AND_DOWNLOAD == GetTransportState())
        {
            m_hRemoteActionErr = ProcessHeaders();
            if (!m_hRemoteActionErr && !m_fCancelPending)
            {
                m_pSupObj->SpoolerYield (0);
                if (m_List.AreTherePendingDownloads())
                {
                    // Put ourselves into flush mode and have the spooler call us until
                    // we are finished putting the downloaded messages into the default store.
                    AddStatusBits (DOWNLOADING_MESSAGES); // Add these bits to the status code
                }
                if (!m_fCancelPending)
                {
                    // Upload any deferred messages the spooler has for our transport
                    if (IsWINDSServerAvailable (m_szServer))
                    {
                        m_pSupObj->SpoolerNotify (NOTIFY_SENTDEFERRED, NULL);
                    }
                    if (!m_fCancelPending)
                    {
                        m_hRemoteActionErr = DownloadMessageHeaders();
                        if (!m_hRemoteActionErr && !(GetTransportStatusCode() & DOWNLOADING_MESSAGES))
                        {
                            RemoveStatusBits (STATUS_INBOUND_FLUSH);
                            UpdateStatus (TRUE, TRUE);
                            m_pSupObj->SpoolerYield (0);
                        }
                    }
                }
            }
            SetTransportState (PENDING_RETURN_CODE);
            AddStatusBits (STATUS_OFFLINE);
            if (m_hRemoteActionErr)
            {
                RemoveStatusBits (STATUS_INBOUND_FLUSH);
                UpdateStatus (TRUE, TRUE);
            }
            else
            {
                if (m_fCancelPending)
                {
                    UpdateStatus (TRUE, TRUE);
                }
                else
                {
                    UpdateStatus();
                }
            }
        }
        else
        {
            if (PROCESSING_TIMER_EVENT == GetTransportState())
            {
                if (m_fGetHeaders)
                {
                    RemoveStatusBits (STATUS_OFFLINE);
                    UpdateStatus();
                    DownloadMessageHeaders();
                    AddStatusBits (STATUS_OFFLINE);
                    UpdateStatus();
                }
            }
            else
            {
                if (m_List.AreTherePendingDownloads())
                {
                    // Put ourselves into flush mode and have the spooler call us until
                    // we are finished putting the downloaded messages into the default store.
                    AddStatusBits (DOWNLOADING_MESSAGES); // Add these bits to the status code
                    UpdateStatus();
                }
            }
        }
    }
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::ProcessHeaders()
//
//    Parameters
//      None.
//
//    Purpose
//      This method is called from the status object's ValidateState when
//      it's passed PROCESS_XP_HEADER_CACHE. It starts the download processing.
//      First we get the header folder contents table and restrict it to rows
//      where PR_MSG_STATUS is >= MSGSTATUS_REMOTE_DOWNLOAD. These are rows
//      for messages that have the MSGSTATUS_REMOTE_DOWNLOAD, or
//      MSGSTATUS_REMOTE_DELETE, or both, bits set.
//
//      We then connect to the server to obtain the download named pipe and
//      start the download.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::ProcessHeaders()
{
    // If we don't have a folder in the status object or the folder doesn't
    // have an initialized contents table, there is nothing to do.
    if (!m_pStatusObj->m_pHeaderFolder || !m_pStatusObj->m_pHeaderFolder->m_pTableData)
    {
        return S_OK;
    }

    // Get headers folder contents table, some are marked for download
    LPMAPITABLE pTable;
    HRESULT hResult = m_pStatusObj->m_pHeaderFolder->m_pTableData->HrGetView (NULL, NULL, 0, &pTable);
    if (hResult)
    {
        TraceResult ("CXPLogon::ProcessHeaders: Failed to get a view on the contents table", hResult);
        return hResult;
    }

    // we only want rows marked for download, form restriction
    SPropValue spvFilter = { 0 };
    spvFilter.ulPropTag = PR_MSG_STATUS;
    spvFilter.Value.l = MSGSTATUS_REMOTE_DOWNLOAD;

    // This restriction relies in the current values of the flags in PR_MSG_STATUS
    SRestriction srStatus = { 0 };
    srStatus.rt = RES_PROPERTY;
    srStatus.res.resProperty.relop = RELOP_GE;
    srStatus.res.resProperty.ulPropTag = PR_MSG_STATUS;
    srStatus.res.resProperty.lpProp = &spvFilter;

    hResult = pTable->Restrict (&srStatus, 0);
    if (hResult)
    {
        // This is a non-fatal error (i.e. the implementation does not support restrictions)
        TraceResult ("CXPLogon::ProcessHeaders: Failed to restrict the table", hResult);
    }
    ULONG ulRowCount;
    // Providers and client should not, when ever possible, use IMAPITable::GetRowCount()
    // because depending on the implementation of the table, the returned count by not
    // be exact.
    // We use it here for convenience knowing the fact the MAPI's ITableData implementation
    // returns and EXACT count of the rows in the memory table.
    hResult = pTable->GetRowCount (0, &ulRowCount);
    if (hResult)
    {
        goto ErrorExit;
    }
    // Nothing to do.
    if (0 == ulRowCount)
    {
        goto ErrorExit;
    }
    else
    {
        // Make sure our download directory is around.
        TCHAR szTmpDir[_MAX_PATH], szDownloadDir[_MAX_PATH];
        GetTempPath (_MAX_PATH, szTmpDir);
        lstrcat (szTmpDir, WINDS_DATA_DIRECTORY);
        wsprintf (szDownloadDir, WINDS_DOWNLOAD_DIR_NAME_FORMAT, szTmpDir, m_UserInfo.szMailboxName);
        CreateDirectory (szDownloadDir, NULL);
    }

    // Initialize the progress property in the status row of this transport.
    UpdateProgress (0, REMOTE_ACTION_DOWNLOADING_MSGS);

    // Make a call to the remote server to open the connection
    HANDLE hPipe;
    hResult = OpenRemoteServerDownLoadPipe (m_szServer, m_UserInfo.szMailboxName, &hPipe);
    if (hResult)
    {
        goto ErrorExit;
    }
    // Do the actual download transmission now.
    hResult = m_List.DownLoadMsgs (pTable, ulRowCount, hPipe);
    CloseHandle (hPipe);

    TerminateRemoteConnections();

ErrorExit:
    TraceResult ("CXPLogon::ProcessHeaders", hResult);
    pTable->Release();
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::UpdateProgress()
//
//    Parameters
//      lPercentComplete    Percent completion of download
//      raFlag              Flag that indicate to what remote action the
//                          update is tied to, so that we may properly
//                          update PR_REMOTE_PROGRESS_TEXT.
//
//    Purpose
//      Sets the status row property PR_REMOTE_PROGRESS with a number from
//      0-100. In example, if 10 messages are queued and 5 have been
//      downloaded, lPercentComplete will be 50, regardless of individual
//      messages' sizes.
//
//    Return Value
//      None.
//
void WINAPI CXPLogon::UpdateProgress (long          lPercentComplete,
                                      REMOTE_ACTION raFlag)
{
    SPropValue spProgress[2] = { 0 };
    ULONG cProps = 1;
    TCHAR szRemoteProgress[64] = { 0 };
    spProgress[0].ulPropTag = PR_REMOTE_PROGRESS;
    spProgress[0].Value.l = lPercentComplete;
    if (raFlag != m_raAction)
    {
        spProgress[1].ulPropTag = PR_REMOTE_PROGRESS_TEXT;
        spProgress[1].Value.LPSZ = szRemoteProgress;
        DWORD idString;
        m_raAction = raFlag;
        switch (raFlag)
        {
            case REMOTE_ACTION_DOWNLOADING_MSGS :
                idString = IDS_REMOTE_DOWNLOADING;
                break;
            case REMOTE_ACTION_PROCESSING_MSGS :
                idString = IDS_REMOTE_PROCESSING_MSGS;
                break;
            case REMOTE_ACTION_HEADER_REFRESH :
                idString = IDS_REMOTE_REFRESHING_HEADERS;
                break;
            case REMOTE_ACTION_IDLE :
                idString = 0;
                break;
        }
        if (idString)
        {
            LoadString (m_hInstance, idString, szRemoteProgress, 64);
        }
        cProps++;
    }

    HRESULT hResult = m_pSupObj->ModifyStatusRow (cProps, spProgress, STATUSROW_UPDATE);
    TraceResult ("CXPLogon::UpdateProgress: Failed to modify the status row", hResult);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::LoadStatusString()
//
//    Parameters
//      pString         Pointer to a string which will hold the status string
//      uStringSize     Maximum number of characters allowed in the string
//
//    Purpose
//      Loads a string from the transport's stringtable. This method is called
//      by the CXPLogon::UpdateStatus method when updating a status row. This
//      method loads the string based on the status bits of the transport
//      status code
//
//    Return Value
//      TRUE            If the string was found in the string table.
//      FALSE           The string was not found. The String indicated by
//                      pString is set to hold 0 characters
//
BOOL WINAPI CXPLogon::LoadStatusString (LPTSTR pString, UINT uStringSize)
{
    UINT uStringID;
    DWORD dwStatusCode = GetTransportStatusCode();
    if (dwStatusCode & (DOWNLOADING_MESSAGES | UPLOADING_MESSAGES))
    {
        uStringID = IDS_XP_STATUS_TIMER_EVENT;
    }
    else
    {
        if (dwStatusCode & DOWNLOADING_MESSAGES)
        {
            if (dwStatusCode & STATUS_OFFLINE)
            {
                uStringID = IDS_XP_STATUS_FLUSHING_INBOUND;
            }
            else
            {
                uStringID = IDS_XP_STATUS_INBOUND_AND_HEADERS;
            }
        }
        else
        {
            if (dwStatusCode & UPLOADING_MESSAGES)
            {
                uStringID = IDS_XP_STATUS_FLUSHING_OUTBOUND;
            }
            else
            {
                if (dwStatusCode & STATUS_INBOUND_ENABLED &&
                    dwStatusCode & STATUS_OUTBOUND_ENABLED)
                {
                    uStringID = IDS_XP_STATUS_READY;
                }
                else
                {
                    uStringID = IDS_XP_STATUS_AVAILABLE;
                }
            }
        }
    }
    if (LoadString (m_hInstance, uStringID, pString, uStringSize))
    {
        return TRUE;
    }
    pString[0] = '\0';
    return FALSE;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::MakeSearchKey()
//
//    Parameters
//      pParentMemBlock     Pointer the a block of memory allocated with the
//                          MAPI Mem. alloc. functions.
//      pszAddress          String with the actual mail address
//      pcbSearchKey        Pointer to a ULONG which returns the size
//                          (in bytes) of the newly created search key
//      ppSearchKey         Pointer to an array ob BYTES
//
//    Purpose
//      Returns a MAPI search key of the form TYPE:ADDRESS in upper case.
//      The string is allocated with the MAPI Mem Alloc functions and linked
//      to the block of memory indicated by pParentMemBlock
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::MakeSearchKey (LPVOID        pParentMemBlock,
                                      LPTSTR        pszAddress,
                                      ULONG *       pcbSearchKey,
                                      LPBYTE *      ppSearchKey)
{
    LPTSTR pszSearchKey;
    // The 2 is for the COLON and the NULL terminator
    ULONG cbStrSize = sizeof (TCHAR) * (2 + lstrlen (WINDS_ADDRESS_TYPE) + lstrlen (pszAddress));
    HRESULT hResult = gpfnAllocateMore (cbStrSize, pParentMemBlock, (LPVOID *)&pszSearchKey);
    TraceResult ("CXPLogon::MakeSearchKey: Failed to allocate search key string", hResult);
    if (!hResult)
    {
        // We need to convert the address to upper case
        wsprintf (pszSearchKey, TEXT("%s:%s"), WINDS_ADDRESS_TYPE, pszAddress);
        CharUpper (pszSearchKey);
        *pcbSearchKey = cbStrSize;
        *ppSearchKey = (LPBYTE)pszSearchKey;
    }
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::UpdateStatus()
//
//    Parameters
//      fAddValidate
//      fValidateOkState
//
//    Purpose
//      Updates the transport status row of this transport in the MAPI Mail
//      subsystem. Updates the flags according the internal state flags
//      maintained in status code of the transport and loads a readable status
//      string to reset the status row. The caller of this method should update
//      the status code member variable prior to calling UpdateStatus()
//
//    Return Value
//      None
//
void WINAPI CXPLogon::UpdateStatus (BOOL fAddValidate, BOOL fValidateOkState)
{
    ULONG cProps = 1;
    SPropValue rgProps[3] = { 0 };
    //  Store the new Transport Provider Status Code
    rgProps[0].ulPropTag = PR_STATUS_CODE;
    rgProps[0].Value.l = GetTransportStatusCode();

    TCHAR szStatus[64];
    if  (LoadStatusString (szStatus, sizeof(szStatus) - 1 ))
    {
        rgProps[1].ulPropTag = PR_STATUS_STRING;
        rgProps[1].Value.LPSZ = szStatus;
        cProps++;
    }
    if (fAddValidate)
    {
        ULONG index;
        if (2 == cProps)
        {
            index = 2;
        }
        else
        {
            index = 1;
        }
        rgProps[index].ulPropTag = PR_REMOTE_VALIDATE_OK;
        rgProps[index].Value.b = fValidateOkState;
        cProps++;
    }
    //  OK. Notify the messaging subsystem of state changes in this transport.
    HRESULT hResult = m_pSupObj->ModifyStatusRow (cProps, rgProps, STATUSROW_UPDATE);
    TraceResult ("CXPLogon::UpdateStatus: ModifyStatusRow failed", hResult);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::InitializeTransportStatusFlags()
//
//    Parameters
//      ulFlags     Flags passed in to initialize the transport status flags.
//
//    Purpose
//      Initialize the transport status flags with the flags passed in by the
//      MAPI spooler. This method gets called when initializing a CXPLogon
//      object in the CXPProvider::TransportLogon method.
//
//    Return Value
//      None
//
void WINAPI CXPLogon::InitializeTransportStatusFlags (ULONG ulFlags)
{
    AddStatusBits (STATUS_AVAILABLE | STATUS_OFFLINE | STATUS_REMOTE_ACCESS);
    if (!(ulFlags & LOGON_NO_INBOUND))
    {
        AddStatusBits (STATUS_INBOUND_ENABLED);
    }
    if (!(ulFlags & LOGON_NO_OUTBOUND))
    {
        AddStatusBits (STATUS_OUTBOUND_ENABLED);
    }
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::SetIdentityProps()
//
//    Parameters
//      None
//
//    Purpose
//      Initializes the transport ID array with the properties found in the
//      profile for the user.
//      If the ABWDS address book is installed, we open an entry in it to
//      supply the identity properties.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::SetIdentityProps()
{
    // Allocate the property array for transport. This memory block is freed
    // in the destructor of the CXPLogon object
    HRESULT hResult = gpfnAllocateBuffer (sizeof(SPropValue)*NUM_IDENTITY_PROPS, (LPVOID *)&m_pIdentityProps);
    if (hResult)
    {
        TraceResult ("CXPLogon::SetIdentityProps: Failed to allocate property array", hResult);
        return hResult;
    }
    LPMAILUSER pUser;
    ULONG ulObjType;
    TCHAR szSearchKey[128];
    LPTSTR pStr;
    // Try to open out entry ID in the ABWDS address book (see if it is around)
    // If the call fails, we must create a one-off for our identity.
    hResult = m_pSupObj->OpenEntry (CB_PRIVATE_EID,
                                    (LPENTRYID)&m_UserEID,
                                    NULL,
                                    0,
                                    &ulObjType,
                                    (LPUNKNOWN *)&pUser);
    if (S_OK == hResult)
    {
        ASSERTMSG (MAPI_MAILUSER == ulObjType, "What kind object is this?");

        // Looks like ABWDS is around, mark the internal flag.
        // ABWDS is the native WINDS address book service provider. If present,
        // instead of creating a one-off entry for the transport identity, we
        // will simply open an entry in the WINDS address book and get the
        // necessary properties out from it.
        m_fABWDSInstalled = TRUE;

        m_pIdentityProps[XPID_NAME].ulPropTag = PR_SENDER_NAME;
        m_pIdentityProps[XPID_NAME].Value.LPSZ = m_UserInfo.szFullName;
        m_pIdentityProps[XPID_EID].ulPropTag = PR_SENDER_ENTRYID;
        m_pIdentityProps[XPID_EID].Value.bin.cb = CB_PRIVATE_EID;
        m_pIdentityProps[XPID_EID].Value.bin.lpb = (LPBYTE)&m_UserEID;
        wsprintf (szSearchKey,
                  TEXT("%s:%s\\%s"),
                  WINDS_ADDRESS_TYPE,
                  m_szServer,       // this is already in the format "\\<servername>"
                  m_UserInfo.szMailboxName);
        CharUpper (szSearchKey);
        hResult = gpfnAllocateMore (Cbtszsize(szSearchKey), m_pIdentityProps, (LPVOID *)&pStr);
        if (hResult)
        {
            TraceResult ("CXPLogon::SetIdentityProps: Failed to allocate string for native search key", hResult);
            m_pIdentityProps[XPID_SEARCH_KEY].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_SENDER_SEARCH_KEY));
        }
        else
        {
            lstrcpy (pStr, szSearchKey);
            m_pIdentityProps[XPID_SEARCH_KEY].ulPropTag = PR_SENDER_SEARCH_KEY;
            m_pIdentityProps[XPID_SEARCH_KEY].Value.bin.cb = Cbtszsize(pStr);
            m_pIdentityProps[XPID_SEARCH_KEY].Value.bin.lpb = (LPBYTE)pStr;
        }
        pUser->Release();
        return hResult;
    }

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_SENDER_ENTRYID property. Create an entry for the user and
    // set it in the property array
    m_pIdentityProps[XPID_EID].ulPropTag = PR_SENDER_ENTRYID;
    LPBYTE lpeid = NULL;
    ULONG  cbeid = 0;
    hResult = m_pSupObj->CreateOneOff (m_UserInfo.szFullName,
                                       WINDS_ADDRESS_TYPE,
                                       m_szAddress,
                                       fMapiUnicode,
                                       &cbeid,
                                       (LPENTRYID *)&lpeid);
 if (hResult)
    {
        TraceResult ("CXPLogon::SetIdentityProps: Failed to create a one off identity", hResult);
        m_pIdentityProps[XPID_EID].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_SENDER_ENTRYID));
        return hResult;
    }

    hResult = gpfnAllocateMore(cbeid, m_pIdentityProps,
                            (LPVOID *)&m_pIdentityProps[XPID_EID].Value.bin.lpb);
    if(hResult)
    {
        TraceResult ("CXPLogon::SetIdentityProps: Failed to allocate memory", hResult);
        m_pIdentityProps[XPID_EID].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_SENDER_ENTRYID));
        gpfnFreeBuffer(lpeid);
        lpeid = NULL;
        return hResult;
    }

    m_pIdentityProps[XPID_EID].Value.bin.cb = cbeid;
    CopyMemory(m_pIdentityProps[XPID_EID].Value.bin.lpb, lpeid, cbeid);

    gpfnFreeBuffer(lpeid);
    lpeid = NULL;

    //////////////////////////////////////////////////////////////////////////
    // Set the PR_SENDER_NAME property
    m_pIdentityProps[XPID_NAME].ulPropTag = PR_SENDER_NAME;
    LPTSTR pStr1, pStr2 = m_UserInfo.szFullName;
    hResult = gpfnAllocateMore (Cbtszsize(pStr2), m_pIdentityProps, (LPVOID *)&pStr1);
    if (hResult)
    {
        TraceResult ("CXPLogon::SetIdentityProps: Memory allocation failed for display name string", hResult);
        m_pIdentityProps[XPID_NAME].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_SENDER_NAME));
        return hResult;
    }
    lstrcpy (pStr1, pStr2);
    m_pIdentityProps[XPID_NAME].Value.LPSZ = pStr1;

    //////////////////////////////////////////////////////////////////////////
    // Set the PR_SENDER_SEARCH_KEY property
    m_pIdentityProps[XPID_SEARCH_KEY].ulPropTag = PR_SENDER_SEARCH_KEY;
    // First, create the search key
    hResult = MakeSearchKey (m_pIdentityProps,
                             m_szAddress,
                             &m_pIdentityProps[XPID_SEARCH_KEY].Value.bin.cb,
                             &m_pIdentityProps[XPID_SEARCH_KEY].Value.bin.lpb);
    if (hResult)
    {
        m_pIdentityProps[XPID_SEARCH_KEY].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_SENDER_SEARCH_KEY));
    }
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::SetSessionFlags()
//
//    Parameters
//      [IN, OUT]   pulFlags    Flags returned to caller
//
//    Purpose
//      To set the flags we will return to the spooler during the CXPLogon
//      initialization in the CXPProvider::TransportLogon method. The ulFlags
//      parameter is filled as a return value to the caller
//
//    Return Value
//      None
//
void WINAPI CXPLogon::SetSessionFlags (ULONG * pulFlags)
{
    if (*pulFlags & LOGON_NO_CONNECT)
    {
        // Nothing is set
        *pulFlags = 0;
    }
    else
    {
        // We DON'T want the MAPI spooler to call our IXPLogon::Idle method (LOGON_SP_IDLE not added)
        // We DON'T want the MAPI spooler to call our IXPLogon::Poll method (LOGON_SP_POLL not added)
        // Also the names have to be fully resolved (LOGON_SP_RESOLVE)
        *pulFlags = LOGON_SP_RESOLVE;
    }
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::SendMailMessage()
//
//    Parameters
//      pMsgObj     Pointer to an IMessage object passed to us by the
//                  MAPI spooler.
//      pRecipRows  Row set with ALL the rows from the recipient table which
//                  have the properties of the recipients we are sending the
//                  message to.
//
//    Purpose
//      This method gets called by SubmitMessage() to do the delivery of the
//      message to the list of recipients. Each recipient will have the
//      PR_RESPONSIBILITY property set indicating weather or not message
//      reached the recipient.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::SendMailMessage (LPMESSAGE pMsgObj, LPSRowSet pRecipRows)
{
    LPSPropValue pMsgProps = NULL;
    LPADRLIST pAdrList = NULL, pAdrListFailed = NULL;
    LPSTnefProblemArray pProblems = NULL;
    CCachedStream * pStream = NULL;
    LPSTREAM pFileStream;
    HANDLE hMsgFile = NULL;
    HRESULT hOpenConnect, hUploadError;
    BOOL fErrorInServer, fSentSuccessfully;
    ULONG ulRow, ulCount1 = 0 , ulCount2 = 0;
    LPTSTR pszServer, pszMailbox;
    LPSPropValue pProps;
    TCHAR szHeaderText[1024], szTmpFile[_MAX_PATH], szConnectInfo[MAX_STRING_SIZE+1] = { 0 };
    if (!GetMsgTempFileName (szTmpFile))   // Not the Win32 API, but an internal implementation
    {
        return E_FAIL;
    }

    // Create a stream where all message information will be saved.
    HRESULT hResult = OpenStreamOnFile (gpfnAllocateBuffer,
                                        gpfnFreeBuffer,
                                        STGM_CREATE | STGM_READWRITE,
                                        szTmpFile,
                                        NULL,
                                        &pFileStream);
    if (hResult)
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to create stream object", hResult);
        return hResult;
    }
    try
    {
        pStream = new CCachedStream (pFileStream, XPSOF_READWRITE);
        if (!pStream)
        {
            TraceMessage ("CXPLogon::SendMailMessage: Failed to allocate cached stream object");
            hResult = E_OUTOFMEMORY;
        }
    }
    catch (CException & Exception)
    {
        hResult = Exception.GetError();
    }
    pFileStream->Release();
    pFileStream = NULL;
    if (hResult)
    {
        return hResult;
    }

    // The wKey is a key used to identify the TNEF property stream. Transports
    // should generate a pseudo-random number for this field. Here we get
    // a number based upon the system's tic count
    // Note that this number cannot be zero of the  OpenTnefStream call will be fail.
    WORD wKey = LOWORD (GetTickCount());
    if (!wKey)
    {
        ASSERTMSG (FALSE, "I'll be darn! It's zero!!!");
        wKey = LOWORD (GetTickCount()) + 1;
        ASSERTMSG (0 != wKey, "No way! What is going on!?!?");
    }
    LPITNEF pTNEFObj = NULL;
    hResult = OpenTnefStream (m_pSupObj,
                              pStream,
                              TNEF_FILE_NAME,
                              TNEF_ENCODE | TNEF_PURE,
                              pMsgObj,
                              wKey,
                              &pTNEFObj);
    if (hResult)
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to create TNEF object", hResult);
        goto ErrorExit;
    }

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    // Get the current time. We need to set some properties that require the time
    SYSTEMTIME st;
    FILETIME ft;
    GetSystemTime (&st);
    SystemTimeToFileTime (&st, &ft);

    SetOutgoingProps (pMsgObj, ft);

    // Check what properties there are and exclude the Non-Transmittables ones
    LPSPropTagArray pTags;
    hResult = pMsgObj->GetPropList (fMapiUnicode, &pTags);
    if (hResult)
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to get the message property tags", hResult);
        goto ErrorExit;
    }

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    // In this sample transport we opted to let TNEF encapsulate
    // the table of recipients of this message. This has a side effect: The
    // addresses of the recipients get munged into the TNEF stream. So, for
    // example, if the TNEF file goes through a foreign mail system and it
    // needs to translate the address of the recipients, it will not be
    // able to. A tranport using TNEF which trasmits messages to a foreign
    // mail system, must do custom processing of the recipients and their
    // address so the receiving side will understands them.
    // This sample code must be modified if you want it as the base code
    // for a gateway transport.
    // Here we also let TNEF encode all the attachments we want to send.
    ULONG cValues, i;
    cValues = 0;
    for (i=0; i<pTags->cValues; i++)
    {
        // Use the FIsTransmittable macro in MAPI to determine if a
        // property is transmittable or not.
        if (!FIsTransmittable(pTags->aulPropTag[i]) &&
            PR_MESSAGE_RECIPIENTS != pTags->aulPropTag[i] &&
            PR_MESSAGE_ATTACHMENTS != pTags->aulPropTag[i])
        {
            pTags->aulPropTag[cValues++] = pTags->aulPropTag[i];
        }
    }
    pTags->cValues = cValues;

    // Encode the properties now
    hResult = pTNEFObj->AddProps (TNEF_PROP_EXCLUDE, 0, NULL, pTags);
    gpfnFreeBuffer (pTags);
    if (FAILED(hResult)) // There could be warnings
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to Add the TNEF properties to the message stream", hResult);
        goto ErrorExit;
    }

    hResult = pTNEFObj->Finish (0, &wKey, &pProblems);
    if (FAILED(hResult)) // There could be warnings
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to save the TNEF props", hResult);
        goto ErrorExit;
    }
    if (pProblems)
    {
        TraceMessage ("CXPLogon::SendMailMessage: Some problem(s) occurred while finishing the TNEF encoding");
        gpfnFreeBuffer (pProblems);
        pProblems = NULL;
        // Don't have to fail submission
    }

    // Release used objects and NULL the object pointers to avoid re-releasing them during cleanup
    if (NULL != pTNEFObj)
    {
        pTNEFObj->Release();
        pTNEFObj = NULL;
    }
    if (NULL != pStream)
    {
        pStream->Release();
        pStream = NULL;
    }

    hMsgFile = CreateFile (szTmpFile,
                           GENERIC_READ,
                           0,
                           NULL,
                           OPEN_EXISTING,
                           FILE_ATTRIBUTE_TEMPORARY |
                           FILE_FLAG_DELETE_ON_CLOSE |
                           FILE_FLAG_SEQUENTIAL_SCAN,
                           NULL);
    if (INVALID_HANDLE_VALUE == hMsgFile)
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to open local msg file", GetLastError());
        hResult = E_FAIL;
        goto ErrorExit;
    }

    // Get some properties in the message need to send the message
    // and delivery report information
    hResult = pMsgObj->GetProps ((LPSPropTagArray)&sptPropsForHeader,
                                 fMapiUnicode,
                                 &cValues,
                                 &pMsgProps);
    if (FAILED(hResult))
    {
        TraceResult ("CXPLogon::SendMailMessage: Failed to get message props", hResult);
        goto ErrorExit;
    }

    // We need to check if the sender requeste a delivery report or not.
    BOOL fNeedDeliveryReport;
    if (PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED == pMsgProps[MSG_DR_REPORT].ulPropTag &&
        pMsgProps[MSG_DR_REPORT].Value.b)
    {
        fNeedDeliveryReport = TRUE;
    }
    else
    {
        fNeedDeliveryReport = FALSE;
    }

    // Create the header that we transmit to the server. The remote host will
    // store this information and make it available to us when then recipients
    // of the message ask for a headers update on their remote mailboxes.
    CreateMsgHeaderTextLine (pMsgProps, szHeaderText, ft);

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    hOpenConnect = OpenServerUploadPipe (m_szServer,
                                         m_UserInfo.szMailboxName,
                                         hMsgFile,
                                         szConnectInfo,
                                         &fErrorInServer);
    for (ulRow=0; ulRow<pRecipRows->cRows; ulRow++)
    {
        pProps = pRecipRows->aRow[ulRow].lpProps;

        // Assume the worst. If hOpenConnect is not S_OK, the fSentSuccessfully
        // must be FALSE to generate NDR for each recipient.
        fSentSuccessfully = FALSE;
        if (S_OK == hOpenConnect)
        {
            if (IsValidAddress (pProps[RECIP_EMAIL_ADR].Value.LPSZ, &pszServer, &pszMailbox))
            {
                // pszServer should be the same as m_szServer
                hUploadError = SendMsgToAccount (pszServer,
                                                 pszMailbox,
                                                 szHeaderText,
                                                 szConnectInfo,
                                                 &fErrorInServer);
                if (!hUploadError)
                {
                    // If we got here, we assume the message has been received in the server
                    fSentSuccessfully = TRUE;
                }
            }
            else
            {
                hUploadError = MAKE_HRESULT(1, FACILITY_WIN32, ERROR_INVALID_ADDRESS);
            }
        }
        else
        {
            hUploadError = hOpenConnect;
        }

        // Let the MAPI spooler do other things
        CheckSpoolerYield();

        // Set the PR_RESPONSIBILITY flag to indicated we have handled this
        // recipient (row). If the flag is not modified, MAPI will pass this
        // message to the next transport in the profile that knows how to
        // handle the address types this transport knows.
        // In this case WE want to be the last to handle the message. If
        // we fail the submission, we should tell MAPI to generate an NDR.
        pProps[RECIP_RESPONSIBILITY].ulPropTag = PR_RESPONSIBILITY;
        pProps[RECIP_RESPONSIBILITY].Value.b = TRUE;

        // Set the report time for DR's and NDR's
        pProps[RECIP_REPORT_TIME].ulPropTag = PR_REPORT_TIME;
        pProps[RECIP_REPORT_TIME].Value.ft = ft;

        if (!fSentSuccessfully)
        {
            // Make the spooler generate an NDR instead of DR
            pProps[RECIP_DELIVER_TIME].ulPropTag = PR_NULL;

            // The Spooler will generate an NDR report and will fill in
            // all required properties in the StatusRecips call. The only
            // thing we need to do is to fill in a specific per-recipient
            // text description of the problem. It's good to have real
            // info from the transport indicating the real cause for the
            // failure
            wsprintf (szHeaderText,
                      TEXT("\tThe WINDS transport service failed to deliver the message to this recipient.\r\n"
                           "\tRecipient Address: Server: %s  Mailbox: %s. Delivery error: %#08X.  %s"),
                           (pszServer ? pszServer : ""),
                           (pszMailbox ? pszMailbox : ""),
                           hUploadError,
                      (fErrorInServer ? TEXT("The error occurred in the server host.") :
                                        TEXT("The error occurred in local processing.")));
            if (fErrorInServer && hUploadError)
            {
                DWORD dwServerErrorIDS = 0;
                switch (hUploadError)
                {
                    case HRESULT_FROM_WIN32(ERROR_INVALID_ACCOUNT_NAME) :
                        dwServerErrorIDS = IDS_DELIVERY_ERROR_INVALID_ACCT;
                        break;
                    case HRESULT_FROM_WIN32(ERROR_NO_SUCH_USER) :
                        dwServerErrorIDS = IDS_DELIVERY_ERROR_NO_SUCH_USER;
                        break;
                    case HRESULT_FROM_WIN32 (ERROR_HOST_UNREACHABLE) :
                        dwServerErrorIDS = IDS_DELIVERY_ERROR_OFFLINE_SERVER;
                        break;
                    case HRESULT_FROM_WIN32 (ERROR_INVALID_ADDRESS) :
                        dwServerErrorIDS = IDS_DELIVERY_ERROR_INVALID_ADDRESS;
                        break;
                    case E_OUTOFMEMORY :
                        dwServerErrorIDS = IDS_DELIVERY_ERROR_OUTOFMEMORY;
                        break;
                    case E_INVALIDARG :
                        dwServerErrorIDS = IDS_DELIVERY_ERROR_INVALID_PARAM;
                        break;
                }
                if (!dwServerErrorIDS && FACILITY_STORAGE == HRESULT_FACILITY(hUploadError))
                {
                    dwServerErrorIDS = IDS_DELIVERY_ERROR_ISTORAGE;
                }
                if (!dwServerErrorIDS && FACILITY_WIN32 == HRESULT_FACILITY(hUploadError))
                {
                    dwServerErrorIDS = IDS_DELIVERY_ERROR_WIN32;
                }
                if (dwServerErrorIDS)
                {
                    TCHAR szBuffer[256];
                    if (LoadString (m_hInstance, dwServerErrorIDS, szBuffer, 255))
                    {
                        lstrcat (szHeaderText, TEXT("\r\n\t"));
                        lstrcat (szHeaderText, szBuffer);
                    }
                }
            }
            LPTSTR pStr;
            hResult = gpfnAllocateMore (Cbtszsize(szHeaderText), pProps, (LPVOID *)&pStr);
            if (SUCCEEDED(hResult))
            {
                // Copy the formatted string and hook it into the
                // pre-allocated (by MAPI) column
                lstrcpy (pStr, szHeaderText);
                pProps[RECIP_REPORT_TEXT].ulPropTag = PR_REPORT_TEXT;
                pProps[RECIP_REPORT_TEXT].Value.LPSZ = pStr;
            }
            else
            {
                pProps[RECIP_REPORT_TEXT].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_REPORT_TEXT));
                pProps[RECIP_REPORT_TEXT].Value.err = hResult;
                TraceResult ("CXPLogon::SendMailMessage: memory allocation failed for the NDR report string", hResult);
            }
        }
        else
        {
            // For delivery report, each recipient must have this property set.
            // Otherwise the spooler will default to generate an NDR instead.
            pProps[RECIP_DELIVER_TIME].ulPropTag = PR_DELIVER_TIME;
            pProps[RECIP_DELIVER_TIME].Value.ft = ft;

            pProps[RECIP_REPORT_TEXT].ulPropTag = PROP_TAG (PT_ERROR, PROP_ID (PR_REPORT_TEXT));
            pProps[RECIP_REPORT_TEXT].Value.err = S_OK;
        }

        // Based on the result of the submission to the remote host we determine into
        // which address list to add this recipient
        LPADRLIST * ppTmpList = (fSentSuccessfully ? &pAdrList : &pAdrListFailed);
        ULONG ulTmpCount = (fSentSuccessfully ? ulCount1 : ulCount2);

        // Does the list where this recipient goes have enough room for one more entry?
        // If not, resize the address list to hold QUERY_SIZE more entries.
        if (!(*ppTmpList) || ((*ppTmpList)->cEntries + 1 > ulTmpCount))
        {
            hResult= GrowAddressList (ppTmpList, 10, &ulTmpCount);
            if (hResult)
            {
                goto ErrorExit;
            }
            ulCount1 = (fSentSuccessfully ? ulTmpCount : ulCount1);
            ulCount2 = (!fSentSuccessfully ? ulTmpCount : ulCount2);
        }

        // We have room now so store the new ADRENTRY. As part of the
        // storage, we're going to copy the SRow pointer from the SRowSet
        // into the ADRENTRY. Once we've done this, we won't need the
        // SRowSet any more ... and the SRow will be released when
        // we unwind the ADRLIST
        (*ppTmpList)->aEntries[(*ppTmpList)->cEntries].cValues = pRecipRows->aRow[ulRow].cValues;
        (*ppTmpList)->aEntries[(*ppTmpList)->cEntries].rgPropVals = pRecipRows->aRow[ulRow].lpProps;

        // Increase the number of entries in the address list
        (*ppTmpList)->cEntries++;

        // Now that we are finished with this row (it is in the right
        // adrlist) we want to disassociate it from the rowset
        // so we don't delete this before we modify the recipients list
        pRecipRows->aRow[ulRow].lpProps = NULL;
        pRecipRows->aRow[ulRow].cValues = 0;

    }

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    // Do we have some recipients that the message arrived to?
    if (pAdrList)
    {
        hResult = pMsgObj->ModifyRecipients (MODRECIP_MODIFY, pAdrList);
        TraceResult ("CXPLogon::SendMailMessage: ModifyRecipients failed (DELIVERED)", hResult);
        hResult = S_OK; // We'll drop the error code from the modify recipients call
        if (fNeedDeliveryReport)
        {
            hResult = m_pSupObj->StatusRecips (pMsgObj, pAdrList);
            TraceResult ("CXPLogon::SendMailMessage: StatusRecips (DR) failed", hResult);
            if (!HR_FAILED(hResult))
            {
                // If we were successful, we should null out the pointer becase MAPI released
                // the memory for this structure. And we should not try to release it
                // again in the cleanup code.
                pAdrList = NULL;
            }
        }
    }
    // Do we have some recipients that the message DID NOT arrived to?
    if (pAdrListFailed)
    {
        hResult = pMsgObj->ModifyRecipients (MODRECIP_MODIFY, pAdrListFailed);
        // We'll drop the error code from the modify recipients call
        TraceResult ("CXPLogon::SendMailMessage: ModifyRecipients failed (NON-DELIVERED)", hResult);

        // The address list has the entries with the PR_RESPONSIBILITY set, so the
        // spooler will know if it has to generate NDR reports.
        hResult = m_pSupObj->StatusRecips (pMsgObj, pAdrListFailed);
        TraceResult ("CXPLogon::SendMailMessage: StatusRecips (NDR) failed", hResult);
        if (!HR_FAILED(hResult))
        {
            // If we were successful, we should null out the pointer becase MAPI released
            // the memory for this structure. And we should not try to release it
            // again in the cleanup code.
            pAdrListFailed = NULL;
        }
    }

ErrorExit:
    gpfnFreeBuffer (pProblems);
    gpfnFreeBuffer (pMsgProps);
    FreePadrlist (pAdrList);
    FreePadrlist (pAdrListFailed);

    // Release used objects
    if (pTNEFObj)
    {
        pTNEFObj->Release();
    }
    if (pStream)
    {
        pStream->Release();
    }
    // Close the file if it has been opened
    CloseHandle (hMsgFile);

    // Delete the message file in case the function fails before the call to CreateFile() above
    DeleteFile (szTmpFile);

    // Call the sender function will NULL parameters to reset internal data buffers
    if (lstrlen(szConnectInfo))
    {
        FinishUploadConnection (m_szServer, szConnectInfo);
    }

    // Once we have sent all messages to the remote server(s), terminate all connections
    TerminateRemoteConnections();

    // Let the MAPI spooler do other things
    CheckSpoolerYield();

    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::SetOutgoingProps()
//
//    Parameters
//      pMsgObj     Pointer to the IMessage object we are processing.
//      ft          FILETIME structure with the time the message is
//                  being delivered.
//
//    Purpose
//      This function checks that the sender information is on the message
//      so that we may get replies from the intended recipients.
//
//    Return Value
//      None.
//
void WINAPI CXPLogon::SetOutgoingProps (LPMESSAGE pMsgObj, FILETIME ft)
{
    LPSPropValue pSender;
    ULONG ulValues;
    HRESULT hResult = pMsgObj->GetProps ((LPSPropTagArray)&sptOutMsgProps, fMapiUnicode, &ulValues, &pSender);
    if (FAILED(hResult))
    {
        TraceResult ("CXPLogon::SetOutgoingProps: Failed to get properties from the message", hResult);
        pSender = NULL; // So that we may recover and continue using default values
    }
    ASSERT (2 == ulValues);
    #define NUM_OUTGOING_PROPS  11
    SPropValue spvProps[NUM_OUTGOING_PROPS] = { 0 };
    ULONG i = 0;
    // If no sender has been stamped on the message use the identity of the transport
    if (!pSender || PR_SENDER_ENTRYID != pSender[0].ulPropTag)
    {
        spvProps[i].ulPropTag = PR_SENDER_NAME;
        spvProps[i++].Value.LPSZ = m_UserInfo.szFullName;

        spvProps[i].ulPropTag = PR_SENDER_EMAIL_ADDRESS;
        spvProps[i++].Value.LPSZ = m_szAddress;

        spvProps[i].ulPropTag = PR_SENDER_ADDRTYPE;
        spvProps[i++].Value.LPSZ = WINDS_ADDRESS_TYPE;

        spvProps[i].ulPropTag = PR_SENDER_ENTRYID;
        spvProps[i++].Value.bin = m_pIdentityProps[XPID_EID].Value.bin;

        spvProps[i].ulPropTag = PR_SENDER_SEARCH_KEY;
        spvProps[i++].Value.bin = m_pIdentityProps[XPID_SEARCH_KEY].Value.bin;
    }
    // The MS Exchange mail viewer requires these properties
    if (!pSender || PR_SENT_REPRESENTING_NAME != pSender[1].ulPropTag)
    {
        spvProps[i].ulPropTag = PR_SENT_REPRESENTING_NAME;
        spvProps[i++].Value.LPSZ = m_UserInfo.szFullName;
        spvProps[i].ulPropTag = PR_SENT_REPRESENTING_SEARCH_KEY;
        spvProps[i++].Value.bin = m_pIdentityProps[XPID_SEARCH_KEY].Value.bin;
        spvProps[i].ulPropTag = PR_SENT_REPRESENTING_ENTRYID;
        spvProps[i++].Value.bin = m_pIdentityProps[XPID_EID].Value.bin;
        spvProps[i].ulPropTag = PR_SENT_REPRESENTING_ADDRTYPE;
        spvProps[i++].Value.LPSZ = WINDS_ADDRESS_TYPE;
        spvProps[i].ulPropTag = PR_SENT_REPRESENTING_EMAIL_ADDRESS;
        spvProps[i++].Value.LPSZ = m_szAddress;
    }
    gpfnFreeBuffer (pSender);

    // Set the time when this transport actually transmitted the message
    spvProps[i].ulPropTag = PR_MESSAGE_DELIVERY_TIME;
    spvProps[i++].Value.ft = ft;
    spvProps[i].ulPropTag = PR_PROVIDER_SUBMIT_TIME;
    spvProps[i++].Value.ft = ft;

    ASSERT (i <= NUM_OUTGOING_PROPS);
    hResult = pMsgObj->SetProps (i, spvProps, NULL);
    TraceResult ("CXPLogon::SetOutgoingProps: Failed to set properties in the message", hResult);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::SetIncomingProps()
//
//    Parameters
//      pMsgObj     Pointer to the IMessage object we are processing.
//
//    Purpose
//      This function sets the PR_SENT_REPRESENTING_xxx properties in an
//      incoming message if those properties aren't already in the message.
//      For these properties we use the values for the sender of the message.
//      We also walk the recipient list restricted to the address type of our
//      transport looking for us, the recipient of the message, s that we may
//      set the PR_MESSAGE_TO_xxx and PR_MESSAGE_RECIP_ME properties in
//      the message.
//
//    Return Value
//      An HRESULT
//
HRESULT WINAPI CXPLogon::SetIncomingProps (LPMESSAGE pMsgObj, PLIST_NODE pNode)
{
    // This is the maximum number of properties that we could set in the message
    #define NUM_INCOMING_PROPS      28
    SPropValue spvProps[NUM_INCOMING_PROPS] =  { 0 };
    ULONG ulValues, i = 0;
    BOOL fNameIsMissing = FALSE, fAddressIsMissing = FALSE;
    TCHAR szUnknown[] = TEXT("Unknown"), szAddress[128];
    TCHAR szUnknownAddress[] = TEXT("\\\\Unknown\\Unknown"), szSender[MAX_STRING_SIZE+1];
    LPTSTR pszAlias, pszServer;
    LPSPropValue pProps = NULL, pSenderSKEY = NULL, pSenderEID = NULL, pObjProps = NULL;
    LPVOID lpToBeFreed = NULL;

    HRESULT hResult = pMsgObj->GetProps ((LPSPropTagArray)&sptNewMsgProps, fMapiUnicode, &ulValues, &pProps);
    if (FAILED(hResult))
    {
        TraceResult ("CXPLogon::SetIncomingProps: Failed to get the message changes", hResult);
        goto RecoverAndContinue;
    }
    hResult = S_OK; // Get rid of any warnings
    // These properties should ALWAYS be in an incoming message, but just in case, we have a backup plan.
    if ((PR_SENDER_NAME != pProps[NEW_SENDER_NAME].ulPropTag ||
        PR_SENDER_EMAIL_ADDRESS != pProps[NEW_SENDER_EMAIL].ulPropTag) && !pNode->fRetry)
    {
        pNode->fRetry = TRUE;
        m_List.ReQueueNode (pNode);
        gpfnFreeBuffer (pProps);
        return MAPI_E_CORRUPT_DATA;
    }

    if (PR_SENDER_NAME != pProps[NEW_SENDER_NAME].ulPropTag)
    {
        fNameIsMissing = TRUE;
        pProps[NEW_SENDER_NAME].ulPropTag = PR_SENDER_NAME;
        if (PR_SENDER_EMAIL_ADDRESS == pProps[NEW_SENDER_EMAIL].ulPropTag)
        {
            // Decompose the address and get the alias. At least this is better that UNKNOWN!
            lstrcpy (szAddress, pProps[NEW_SENDER_EMAIL].Value.LPSZ);
            DecomposeAddress (szAddress, &pszServer, &pszAlias);
            lstrcpy (szSender, pszAlias);
            pProps[NEW_SENDER_NAME].Value.LPSZ = szSender;
        }
        else
        {
            // This is the best we can do.
            pProps[NEW_SENDER_NAME].Value.LPSZ = szUnknown;
        }
    }
    if (PR_SENDER_EMAIL_ADDRESS != pProps[NEW_SENDER_EMAIL].ulPropTag)
    {
        pProps[NEW_SENDER_EMAIL].ulPropTag = PR_SENDER_EMAIL_ADDRESS;
        pProps[NEW_SENDER_EMAIL].Value.LPSZ = szUnknownAddress;
        fAddressIsMissing = TRUE;
    }
    spvProps[i].ulPropTag = PR_SENDER_ADDRTYPE;
    spvProps[i++].Value.LPSZ = WINDS_ADDRESS_TYPE;
    spvProps[i].ulPropTag = PR_SENT_REPRESENTING_ADDRTYPE;
    spvProps[i++].Value.LPSZ = WINDS_ADDRESS_TYPE;

    // Looks like ABWDS is around, mark the internal flag.
    // ABWDS is the native WINDS address book service provider. If present,
    // instead of creating a one-off entry for the sender, we
    // will simply open the entry in the WINDS address book and get the
    // necessary properties out from it.
    // Note that in other to open an entry in the ABWDS address book provider
    // we need to have at least the email address of the sender, otherwise we
    // will default to create one-off entries in the sender (and delagate sender)
    if (m_fABWDSInstalled && !fAddressIsMissing)
    {
        PRIVATE_XP_ENTRYID eidEntry = { 0 };
        eidEntry.uidGlobal = guidXPABEntries;
        eidEntry.uidWINDSEntries = guidABEntries;
        // Decompose the address and get the alias.
        DecomposeAddress (pProps[NEW_SENDER_EMAIL].Value.LPSZ, &pszServer, &pszAlias);
        lstrcpy (eidEntry.szObjectAlias, pszAlias);
        // Put the Email address back to what it was
        RecomposeAddress (pszServer, pszAlias, pProps[NEW_SENDER_EMAIL].Value.LPSZ);
        LPMAILUSER pUser = NULL;
        ULONG ulObjType;
        const static SizedSPropTagArray (3, sptWINDSObjProps) =
        {
            3,
            {
                PR_DISPLAY_NAME,
                PR_SEARCH_KEY,
                PR_ENTRYID
            }
        };

        HRESULT hTmpResult = m_pSupObj->OpenEntry (CB_PRIVATE_XP_EID,
                                                   (LPENTRYID)&eidEntry,
                                                   NULL,
                                                   0,
                                                   &ulObjType,
                                                   (LPUNKNOWN *)&pUser);
        if (!hTmpResult)
        {
            hTmpResult = pUser->GetProps ((LPSPropTagArray)&sptWINDSObjProps,
                                          fMapiUnicode,
                                          &ulValues,
                                          &pObjProps);
            if (SUCCEEDED(hTmpResult)) // We might get warnings
            {
                if (PR_DISPLAY_NAME == pObjProps[0].ulPropTag &&
                    PR_SEARCH_KEY == pObjProps[1].ulPropTag &&
                    PR_ENTRYID == pObjProps[2].ulPropTag)
                {
                    if (fNameIsMissing)
                    {
                        spvProps[i].ulPropTag = PR_SENDER_NAME;
                        spvProps[i++].Value.LPSZ = pObjProps[0].Value.LPSZ;
                    }
                    spvProps[i].ulPropTag = PR_SENDER_SEARCH_KEY;
                    spvProps[i++].Value.bin = pObjProps[1].Value.bin;
                    spvProps[i].ulPropTag = PR_ENTRYID;
                    spvProps[i++].Value.bin = pObjProps[2].Value.bin;
                    if (PR_SENT_REPRESENTING_NAME != pProps[NEW_SENT_NAME].ulPropTag &&
                        PR_SENT_REPRESENTING_EMAIL_ADDRESS != pProps[NEW_SENT_EMAIL].ulPropTag)
                    {
                        // If the message doesn't have PR_SENT_REPRESENTING_xxx use the sender
                        // properties for the delagate sender properties
                        spvProps[i].ulPropTag    = PR_SENT_REPRESENTING_NAME;
                        spvProps[i++].Value.LPSZ = pObjProps[0].Value.LPSZ;
                        spvProps[i].ulPropTag    = PR_SENT_REPRESENTING_SEARCH_KEY;
                        spvProps[i++].Value.bin  = pObjProps[1].Value.bin;
                        spvProps[i].ulPropTag    = PR_SENT_REPRESENTING_ENTRYID;
                        spvProps[i++].Value.bin  = pObjProps[2].Value.bin;
                        spvProps[i].ulPropTag    = PR_SENT_REPRESENTING_ADDRTYPE;
                        spvProps[i++].Value.LPSZ = WINDS_ADDRESS_TYPE;
                        spvProps[i].ulPropTag    = PR_SENT_REPRESENTING_EMAIL_ADDRESS;
                        spvProps[i++].Value.LPSZ = pProps[NEW_SENDER_EMAIL].Value.LPSZ;
                    }
                }
                else
                {
                    // We couldn't find the properties needed from the WINDS
                    // address book entry. Continue with one-off entries
                    hTmpResult = MAPI_W_ERRORS_RETURNED;
                }
            }
            pUser->Release();
        }
        if (S_OK == hTmpResult)
        {
            goto ContinueAddingProps;
        }
    }

    // We need to make a search key for this recipient.
    spvProps[i].ulPropTag = PR_SENDER_SEARCH_KEY;
    hResult = MakeSearchKey (pProps,
                             pProps[NEW_SENDER_EMAIL].Value.LPSZ,
                             &spvProps[i].Value.bin.cb,
                             &spvProps[i].Value.bin.lpb);
    if (!hResult)
    {
        pSenderSKEY = &spvProps[i];
        i++;
        // We need to create a one-off entry in the address book so that we may
        // reply to this recipient. If the recipient already exist, its
        // entry Id will be returned instead.
        spvProps[i].ulPropTag = PR_SENDER_ENTRYID;

        //else
        {
            hResult = m_pSupObj->CreateOneOff (pProps[NEW_SENDER_NAME].Value.LPSZ,
                                               WINDS_ADDRESS_TYPE,
                                               pProps[NEW_SENDER_EMAIL].Value.LPSZ,
                                               fMapiUnicode,
                                               &spvProps[i].Value.bin.cb,
                                               (LPENTRYID *)&spvProps[i].Value.bin.lpb);
        }
        if (hResult)
        {
            i--; // Ignore this property and the previous
        }
        else
        {
            pSenderEID = &spvProps[i];
            i++;
        }
    }
    TraceResult ("CXPLogon::SetIncomingProps: Failed to create a one-off for the sender", hResult);

    if (PR_SENT_REPRESENTING_NAME == pProps[NEW_SENT_NAME].ulPropTag &&
        PR_SENT_REPRESENTING_EMAIL_ADDRESS == pProps[NEW_SENT_EMAIL].ulPropTag)
    {
        spvProps[i].ulPropTag = PR_SENT_REPRESENTING_SEARCH_KEY;
        hResult = MakeSearchKey (pProps,
                                 pProps[NEW_SENT_EMAIL].Value.LPSZ,
                                 &spvProps[i].Value.bin.cb,
                                 &spvProps[i].Value.bin.lpb);
        if (!hResult)
        {
            i++;
            spvProps[i].ulPropTag = PR_SENT_REPRESENTING_ENTRYID;
            hResult = m_pSupObj->CreateOneOff (pProps[NEW_SENT_NAME].Value.LPSZ,
                                               WINDS_ADDRESS_TYPE,
                                               pProps[NEW_SENT_EMAIL].Value.LPSZ,
                                               fMapiUnicode,
                                               &spvProps[i].Value.bin.cb,
                                               (LPENTRYID *)&spvProps[i].Value.bin.lpb);
            if (hResult)
            {
                i--; // Ignore this property and the previous
            }
            else
            {
                lpToBeFreed = spvProps[i].Value.bin.lpb;
                i++;
            }
        }
        // We trace the error but is not fatal
        TraceResult ("CXPLogon::SetIncomingProps: Failed to create a oneoff for the delegated sender", hResult);
    }
    else
    {
        // If the message doesn't have PR_SENT_REPRESENTING_xxx properties AND we were
        // successful at creating the one-off for the sender, we set PR_SENT_REPRESENTING_xxx
        // to the same values as PR_SENDER_xxx
        if (!hResult)
        {
            spvProps[i].ulPropTag       = PR_SENT_REPRESENTING_NAME;
            spvProps[i++].Value.LPSZ    = pProps[NEW_SENDER_NAME].Value.LPSZ;
            spvProps[i].ulPropTag       = PR_SENT_REPRESENTING_ADDRTYPE;
            spvProps[i++].Value.LPSZ    = WINDS_ADDRESS_TYPE;
            spvProps[i].ulPropTag       = PR_SENT_REPRESENTING_EMAIL_ADDRESS;
            spvProps[i++].Value.LPSZ    = pProps[NEW_SENDER_EMAIL].Value.LPSZ;

            ASSERT (PR_SENDER_ENTRYID == pSenderEID->ulPropTag);
            spvProps[i].ulPropTag       = PR_SENT_REPRESENTING_ENTRYID;
            spvProps[i++].Value         = pSenderEID->Value;

            ASSERT (PR_SENDER_SEARCH_KEY == pSenderSKEY->ulPropTag);
            spvProps[i].ulPropTag       = PR_SENT_REPRESENTING_SEARCH_KEY;
            spvProps[i++].Value         = pSenderSKEY->Value;
        }
    }

ContinueAddingProps:
    // If the sender's address is the same as our address (the recipient), then the message
    // was sent from us, to ourselves, therefore we must set the flag bit in the message.
    if (0 == lstrcmpi (pProps[NEW_SENDER_EMAIL].Value.LPSZ, m_szAddress))
    {
        ASSERT (PR_MESSAGE_FLAGS == pProps[NEW_MSG_FLAGS].ulPropTag);
        spvProps[i].ulPropTag = PR_MESSAGE_FLAGS;
        spvProps[i++].Value.l = pProps[NEW_MSG_FLAGS].Value.l | MSGFLAG_FROMME;
    }

RecoverAndContinue:
    // We must stamp the message with this properties since we (this transport)
    // were the ones who processed the incoming message.
    spvProps[i].ulPropTag       = PR_RECEIVED_BY_ENTRYID;
    spvProps[i++].Value.bin     = m_pIdentityProps[XPID_EID].Value.bin;
    spvProps[i].ulPropTag       = PR_RECEIVED_BY_NAME;
    spvProps[i++].Value.LPSZ    = m_pIdentityProps[XPID_NAME].Value.LPSZ;
    spvProps[i].ulPropTag       = PR_RECEIVED_BY_SEARCH_KEY;
    spvProps[i++].Value.bin     = m_pIdentityProps[XPID_SEARCH_KEY].Value.bin;
    spvProps[i].ulPropTag       = PR_RECEIVED_BY_ADDRTYPE;
    spvProps[i++].Value.LPSZ    = WINDS_ADDRESS_TYPE;
    spvProps[i].ulPropTag       = PR_RECEIVED_BY_EMAIL_ADDRESS;
    spvProps[i++].Value.LPSZ    = m_szAddress;

    // In this transport we set PR_RCVD_xxx with the values of PR_RECEIVED_xxx
    spvProps[i].ulPropTag       = PR_RCVD_REPRESENTING_ENTRYID;
    spvProps[i++].Value.bin     = m_pIdentityProps[XPID_EID].Value.bin;
    spvProps[i].ulPropTag       = PR_RCVD_REPRESENTING_NAME;
    spvProps[i++].Value.LPSZ    = m_pIdentityProps[XPID_NAME].Value.LPSZ;
    spvProps[i].ulPropTag       = PR_RCVD_REPRESENTING_SEARCH_KEY;
    spvProps[i++].Value.bin     = m_pIdentityProps[XPID_SEARCH_KEY].Value.bin;
    spvProps[i].ulPropTag       = PR_RCVD_REPRESENTING_ADDRTYPE;
    spvProps[i++].Value.LPSZ    = WINDS_ADDRESS_TYPE;
    spvProps[i].ulPropTag       = PR_RCVD_REPRESENTING_EMAIL_ADDRESS;
    spvProps[i++].Value.LPSZ    = m_szAddress;

    SYSTEMTIME st;
    FILETIME ftTime;
    GetSystemTime (&st);
    SystemTimeToFileTime (&st, &ftTime);
    spvProps[i].ulPropTag = PR_MESSAGE_DOWNLOAD_TIME;
    spvProps[i++].Value.ft = ftTime;

    LPMAPITABLE pTable;
    LPSRowSet pRows;
    BOOL fFoundCC, fFoundTO;
    fFoundCC = fFoundTO = FALSE;
    LPSPropValue pRecip;
    SPropValue spvFilter = { 0 };
    spvFilter.ulPropTag = PR_ADDRTYPE;
    spvFilter.Value.LPSZ = WINDS_ADDRESS_TYPE;

    SRestriction srRecips = { 0 };
    srRecips.rt = RES_PROPERTY;
    srRecips.res.resProperty.relop = RELOP_EQ;
    srRecips.res.resProperty.ulPropTag = PR_ADDRTYPE;
    srRecips.res.resProperty.lpProp = &spvFilter;

    hResult = pMsgObj->GetRecipientTable (fMapiUnicode, &pTable);
    if (!hResult)
    {
        hResult = HrQueryAllRows (pTable,
                                  (LPSPropTagArray)&sptMsgRecipProps,
                                  &srRecips,
                                  NULL,
                                  0,
                                  &pRows);
        if (!hResult)
        {
            ASSERTMSG (pRows->cRows > 0, "Huh?, Zero rows?");
            for (ULONG ulIndex=0; ulIndex<pRows->cRows; ulIndex++)
            {
                pRecip = pRows->aRow[ulIndex].lpProps;
                ASSERTMSG (PR_EMAIL_ADDRESS == pRecip[0].ulPropTag, "Where is the PR_EMAIL_ADDRESS?");
                ASSERTMSG (PR_RECIPIENT_TYPE == pRecip[1].ulPropTag, , "Where is the PR_RECIPIENT_TYPE?");
                if (PR_EMAIL_ADDRESS == pRecip[0].ulPropTag)
                {
                    // We use the address for the comparison because the sender might
                    // have create a one-off to send us this message and the only thing that this
                    // transport can count on being the same across all computers
                    // is the email address. The display name is modifyable by the user.
                    if (0 == lstrcmpi (pRecip[0].Value.LPSZ, m_szAddress))
                    {
                        if (PR_RECIPIENT_TYPE == pRecip[1].ulPropTag)
                        {
                            if (MAPI_TO == pRecip[1].Value.l)
                            {
                                fFoundTO = TRUE;
                            }
                            else
                            {
                                if (MAPI_CC == pRecip[1].Value.l)
                                {
                                    fFoundCC = TRUE;
                                }
                            }
                        }
                    }
                }
            }
            FreeProws (pRows);
        }
        pTable->Release();
    }
    TraceResult ("CXPLogon::SetIncomingProps: Something went wrong setting PR_MESSAGE_xxx", hResult);

    if (!hResult)
    {
        spvProps[i].ulPropTag = PR_MESSAGE_TO_ME;
        spvProps[i++].Value.b = fFoundTO;

        spvProps[i].ulPropTag = PR_MESSAGE_CC_ME;
        spvProps[i++].Value.b = fFoundCC;

        spvProps[i].ulPropTag = PR_MESSAGE_RECIP_ME;
        spvProps[i++].Value.b = fFoundTO || fFoundCC;
    }
    ASSERT (i <= NUM_INCOMING_PROPS);
    hResult = pMsgObj->SetProps (i, spvProps, NULL);
    TraceResult ("CXPLogon::SetIncomingProps: Failed to set properties in the message", hResult);
    gpfnFreeBuffer(lpToBeFreed);
    if(pSenderEID)
        gpfnFreeBuffer(pSenderEID->Value.bin.lpb);
    gpfnFreeBuffer (pProps);
    gpfnFreeBuffer (pObjProps);
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::GetMsgTempFileName()
//
//    Parameters
//      pszFileName     Pointer to a buffer allocated by the caller where the
//                      function returns a fully qualified path and file for
//                      a uniquely named temporary file.
//
//    Purpose
//      This function creates a temporary file name. The file name will be
//      returned in the pszFileName buffer which must have been allocated by
//      the caller. The file will have a fully qualified path to its location.
//      The location of the file is on the TEMP directory, as set in the system,
//      and within it, in the directory for the downloads of the WINDS
//      message transport
//
//    Return Value
//      TRUE if the function is successful at creating a temporary
//      unique file name. FALSE otherwise.
//
BOOL WINAPI CXPLogon::GetMsgTempFileName (LPTSTR pszFileName)
{
    TCHAR szTmpDir[_MAX_PATH], szDownloadDir[_MAX_PATH];
    // Ask the system for the TEMP directory
    DWORD dwChars = GetTempPath (_MAX_PATH, szTmpDir);
    if (dwChars)
    {
        lstrcat (szTmpDir, WINDS_DATA_DIRECTORY);
        wsprintf (szDownloadDir, WINDS_DOWNLOAD_DIR_NAME_FORMAT, szTmpDir, m_UserInfo.szMailboxName);
        dwChars = ::GetTempFileName (szDownloadDir,         // Call the Win32 API
                                     XP_MSG_FILE_PREFIX,    // Our transport's fixed prefix for temp files
                                     0,                     // Use the time to create a pseudo-random number
                                     pszFileName);          // Destination buffer
    }
    if (!dwChars)
    {
        TraceResult ("CXPLogon::GetMsgTempFileName: Failed to get temp path or file name", GetLastError());
    }
    return (0 != dwChars ? TRUE : FALSE);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::CreateMsgHeaderTextLine()
//
//    Parameters
//      pProps              Array of properties of the message being
//                          submitted where we get the information to create a
//                          message header string to send to the server
//      pszBuffer           Buffer where the function copies the formated data
//                          for the server message header string
//      time                Reference to a FILETIME structure with the time
//                          the transport is delivering the message.
//
//    Purpose
//      This function creates a string with the data needed in the server
//      side to update the remote server mailboxes message header file of
//      the recipients.
//
//    Return Value
//      None
//
void WINAPI CXPLogon::CreateMsgHeaderTextLine (LPSPropValue     pProps,
                                               LPTSTR           pszBuffer,
                                               FILETIME &       time)
{
    // In case we don't find the properties in the array, we need
    // to supply default values for the strings. This method
    // should never fail.
    LPTSTR pszSubject = TEXT("<Subject Not Found>");
    LPTSTR pszMsgClass = TEXT("IPM.Note");
    TCHAR szDisplayTo[256] = { 0 };

    // In case we don't have the expected properties, assign default values.
    long lMsgFlags = 0;
    if (PR_MESSAGE_FLAGS == pProps[MSG_FLAGS].ulPropTag)
    {
        // Filter out the flags to only allow the ones listed
        lMsgFlags = pProps[MSG_FLAGS].Value.l & (MSGFLAG_UNMODIFIED |
                                                 MSGFLAG_HASATTACH |
                                                 MSGFLAG_FROMME |
                                                 MSGFLAG_RESEND);
    }
    if (pProps[MSG_SIZE].ulPropTag != PR_MESSAGE_SIZE)
    {
        pProps[MSG_SIZE].Value.l = 1024; // Default to 1Kb
    }
    if (pProps[MSG_PRIORITY].ulPropTag != PR_PRIORITY)
    {
        pProps[MSG_PRIORITY].Value.l = PRIO_NORMAL;
    }
    if (pProps[MSG_IMPORTANCE].ulPropTag != PR_IMPORTANCE)
    {
        pProps[MSG_IMPORTANCE].Value.l = IMPORTANCE_NORMAL;
    }
    if (pProps[MSG_SENSITIVITY].ulPropTag != PR_SENSITIVITY)
    {
        pProps[MSG_SENSITIVITY].Value.l = SENSITIVITY_NONE;
    }

    // Get the string of TO recipients. If the string is too long, set the elipsis at the end of the buffer
    if (pProps[MSG_DISP_TO].ulPropTag == PR_DISPLAY_TO)
    {
        LPTSTR pszDisplayTo = pProps[MSG_DISP_TO].Value.LPSZ;
        if (lstrlen (pszDisplayTo) > 256)
        {
            pszDisplayTo[252] = '.'; // Copy the elipsis for a long string
            pszDisplayTo[253] = '.';
            pszDisplayTo[254] = '.';
            pszDisplayTo[255] = 0;
        }
        LPTSTR pszOneName = strtok (pszDisplayTo, ";");
        if (pszOneName)
        {
            pszOneName[lstrlen(pszOneName) - 1] = 0;
            lstrcpy (szDisplayTo, &pszOneName[1]);
        }
        while (pszOneName)
        {
            pszOneName = strtok (NULL, ";");
            if (pszOneName)
            {
                pszOneName[0] = TEXT(';');
                pszOneName[1] = TEXT(' ');
                pszOneName[lstrlen(pszOneName) - 1] = 0;
                lstrcat (szDisplayTo, pszOneName);
            }
        }
    }
    if (0 == szDisplayTo[0])
    {
        lstrcpy (szDisplayTo, TEXT("<Display To Names Not Found>"));
    }
    // Get the message class string.
    if (pProps[MSG_CLASS].ulPropTag == PR_MESSAGE_CLASS)
    {
        pszMsgClass = pProps[MSG_CLASS].Value.LPSZ;
    }
    // Get the subject. If the string is too long, set the elipsis at the end of the buffer
    if (pProps[MSG_SUBJECT].ulPropTag == PR_SUBJECT)
    {
        pszSubject = pProps[MSG_SUBJECT].Value.LPSZ;
        if (lstrlen (pszSubject) > 256)
        {
            pszSubject[252] = '.'; // Copy the elipsis for a long string
            pszSubject[253] = '.';
            pszSubject[254] = '.';
            pszSubject[255] = 0;
        }
    }
    // Write the properties into the buffer. This buffer is the header
    // information we send to the server The buffer passed in must hold
    // at least 1024 characters
    wsprintf (pszBuffer,
              // The string must end with a ',' (for the parsing logic
              // in the downloading of the headers)
              TEXT("%d,%s,%d,%s,%d,%s,%s,%d,%d,%d,%d,%d,%d,%d,"),
              lstrlen(m_UserInfo.szFullName),
              m_UserInfo.szFullName,
              lstrlen(szDisplayTo),
              szDisplayTo,
              lstrlen(pszSubject),
              pszSubject,
              pszMsgClass,
              lMsgFlags,
              pProps[MSG_SIZE].Value.l,
              pProps[MSG_PRIORITY].Value.l,
              pProps[MSG_IMPORTANCE].Value.l,
              pProps[MSG_SENSITIVITY].Value.l,
              time.dwLowDateTime,
              time.dwHighDateTime);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::IsValidAddress()
//
//    Parameters
//      pszAddress      The address of the recipient. This string gets
//                      decomposed locally, so it can't be re-used by
//                      the caller.
//      ppszServer      Pointer to a location where the function returns
//                      the remote server name
//      ppszMailbox     Pointer to a location where the function returns
//                      the remote user mailbox name
//
//    Purpose
//      This functions takes the address of a recipient and makes sure it is
//      valid (as far as syntax) and decomposes the address into two
//      components: Remote server name and Remote user mailbox name. The
//      two component strings are returned to the caller.
//
//    Return Value
//      TRUE if the address of the recipient is valid. FALSE otherwise.
//
BOOL WINAPI CXPLogon::IsValidAddress (LPTSTR        pszAddress,
                                      LPTSTR *      ppszServer,
                                      LPTSTR *      ppszMailbox)
{
    // Make sure that we can read the string
    if (!pszAddress || IsBadStringPtr (pszAddress, 32))
    {
        TraceMessage ("CXPLogon::IsValidAddress: Invalid string pointer");
        return FALSE;
    }
    DecomposeAddress (pszAddress, ppszServer, ppszMailbox);
    // Validate the names of the server and the mailbox
    if (!IsValidServerName (*ppszServer) || !*ppszMailbox)
    {
        TraceMessage ("CXPLogon::IsValidAddress: Invalid address for remote server host");
        return FALSE;
    }
    return TRUE;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::GrowAddressList()
//
//    Parameters
//      ppAdrList           Pointer to an address where the old address list
//                          is and where the new resized address list will
//                          be returned
//      ulResizeBy          Number of new address entries to add to the list
//      pulOldAndNewCount   Number of entries in the old address list. In
//                          this parameter, upon sucessful return, will have
//                          the number of in the new address list
//
//    Purpose
//      In this function, given an address list with pulOldAndNewCount of
//      entries, we resize the address list to hold the old number of
//      entries plus the ulResizeBy entries. The old address list contents
//      are copied to the new list and the count reset. The memory for the
//      old address list is released here.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::GrowAddressList (LPADRLIST *   ppAdrList,
                                        ULONG         ulResizeBy,
                                        ULONG *       pulOldAndNewCount)
{
    LPADRLIST pNewAdrList;
    // Calculate how big the new buffer for the expanded address list should be
    ULONG cbSize = CbNewADRLIST ((*pulOldAndNewCount) + ulResizeBy);
    // Allocate the memory for it
    HRESULT hResult = gpfnAllocateBuffer (cbSize, (LPVOID *)&pNewAdrList);
    if (hResult)
    {
        // We can't continue
        TraceResult ("CXPLogon::GrowAddressList: Failed to allocate memory for resized address list", hResult);
        return hResult;
    }

    // Zero-out all memory for neatness
    ZeroMemory (pNewAdrList, cbSize);

    // If we had entries in the old address list, copy the memory from
    // the old addres list into the new expanded list
    if ((*pulOldAndNewCount))
    {
        CopyMemory (pNewAdrList, *ppAdrList, CbNewADRLIST ((*pulOldAndNewCount)));
    }

    // Set the number of entries in the new address list to the OLD size
    pNewAdrList->cEntries = (*pulOldAndNewCount);

    // We must return the number of available entries in the new expanded address list
    (*pulOldAndNewCount) += ulResizeBy;

    // Free the old memory and put the new pointer in place
    gpfnFreeBuffer (*ppAdrList);
    *ppAdrList = pNewAdrList;
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::CheckSpoolerYield()
//
//    Parameters
//      fReset      Resets the pseudo-timer
//
//    Purpose
//      Enforce the 0.2 second rule for transport that need to yield to the
//      MAPI spooler.  Called periodically while processing a message to
//      determine if we have used more than 0.2 seconds.  If so, then call
//      SpoolerYield(), else just continue.
//      This is called with fReset set to TRUE when we first enter one
//      of the Transport Logon methods (usually one that is known to
//      take a long time like StartMessage() or SubmitMessage(). )
//
//    Return Value
//      None.
//
void WINAPI CXPLogon::CheckSpoolerYield (BOOL fReset)
{
    DWORD dwStop;
    static DWORD dwStart;
    if (fReset)
    {
        dwStart = GetTickCount();
    }
    else
    {
        dwStop = GetTickCount();
        if ((dwStop - dwStart) > 200) // 200 milliseconds
        {
            m_pSupObj->SpoolerYield (0);
            dwStart = GetTickCount();
        }
    }
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::InitializeStatusRow()
//
//    Parameters
//      ulFlags     0 if the properties are being created the first time.
//                  MODIFY_FLAGS if a change is being made to the properties
//
//    Purpose
//      To initialize or modify the status properties of a CXPLogon
//      object. This function allocates an array with NUM_STATUS_ROW_PROPS
//      properties and initializes them.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::InitializeStatusRow (ULONG ulFlags)
{
    #define NUM_STATUS_ROW_PROPS    10
    SPropValue spvStatusRow[NUM_STATUS_ROW_PROPS] = { 0 };
    ULONG i = 0;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_PROVIDER_DISPLAY property: The transport readable name
    spvStatusRow[i].ulPropTag = PR_PROVIDER_DISPLAY;
    spvStatusRow[i++].Value.LPSZ = TRANSPORT_DISPLAY_NAME_STRING;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_RESOURCE_METHODS property. These are the methods implemented
    // in the our IMAPIStatus implementation (CMAPIStatus class.)
    spvStatusRow[i].ulPropTag = PR_RESOURCE_METHODS;
    // we support ALL the methods in our implementation of IMAPIStatus interface (except the WRITABLE ones)
    spvStatusRow[i++].Value.l = STATUS_SETTINGS_DIALOG |
                                STATUS_FLUSH_QUEUES |
                                STATUS_VALIDATE_STATE |
                                STATUS_CHANGE_PASSWORD;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_STATUS_CODE property.
    spvStatusRow[i].ulPropTag = PR_STATUS_CODE;
    spvStatusRow[i++].Value.l = GetTransportStatusCode();

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_STATUS_STRING property
    TCHAR szStatus[64];
    LoadStatusString (szStatus, sizeof(szStatus));
    spvStatusRow[i].ulPropTag = PR_STATUS_STRING;
    spvStatusRow[i++].Value.LPSZ = szStatus;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_DISPLAY_NAME property
    TCHAR szDisplayName[64];
    wsprintf (szDisplayName, TEXT("%s (%s)"), TRANSPORT_DISPLAY_NAME_STRING, m_szServer);
    spvStatusRow[i].ulPropTag = PR_DISPLAY_NAME;
    spvStatusRow[i++].Value.LPSZ = szDisplayName;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_IDENTITY_ENTRYID property
    spvStatusRow[i].ulPropTag = PR_IDENTITY_ENTRYID;
    spvStatusRow[i++].Value = m_pIdentityProps[XPID_EID].Value;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_IDENTITY_DISPLAY property
    spvStatusRow[i].ulPropTag = PR_IDENTITY_DISPLAY;
    spvStatusRow[i++].Value.LPSZ = m_pIdentityProps[XPID_NAME].Value.LPSZ;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_IDENTITY_SEARCH_KEY property
    spvStatusRow[i].ulPropTag = PR_IDENTITY_SEARCH_KEY;
    spvStatusRow[i++].Value = m_pIdentityProps[XPID_SEARCH_KEY].Value;

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_REMOTE_PROGRESS property
    spvStatusRow[i].ulPropTag = PR_REMOTE_PROGRESS;
    spvStatusRow[i++].Value.l = -1; // Not initialized

    ///////////////////////////////////////////////////////////////////////////
    // Set the PR_REMOTE_VALIDATE_OK property
    spvStatusRow[i].ulPropTag = PR_REMOTE_VALIDATE_OK;
    spvStatusRow[i++].Value.b = TRUE;
    ASSERT (NUM_STATUS_ROW_PROPS == i);

    // Write the entries on the provider's session status row
    HRESULT hResult = m_pSupObj->ModifyStatusRow (i, spvStatusRow, ulFlags);
    TraceResult ("CXPLogon::InitializeStatusRow: Failed to modify the status row", hResult);
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::CheckForUnfinishedDownloads()
//
//    Parameters
//      None.
//
//    Purpose
//      This function checks to see if we have files where downloaded messages
//      were lefted from a previous session or from a previous failed download
//      sequence. The message files, if any, should be in the data directory of
//      this service. If any files are found, the message queue is loaded and
//      the during out inbound logic initialization in
//      IXPLogon::TransportNotify(), we check the queue. If the queue is not
//      empty, we tell the transport to flush our inbound flush.
//
//    Return Value
//      None.
//
void WINAPI CXPLogon::CheckForUnfinishedDownloads()
{
    WIN32_FIND_DATA wfdFile = { 0 };
    TCHAR szTmpDir[_MAX_PATH], szDownloadDir[_MAX_PATH], szSearchMask[512];
    GetTempPath (_MAX_PATH, szTmpDir);
    lstrcat (szTmpDir, WINDS_DATA_DIRECTORY);
    wsprintf (szDownloadDir, WINDS_DOWNLOAD_DIR_NAME_FORMAT, szTmpDir, m_UserInfo.szMailboxName);
    wsprintf (szSearchMask, TEXT("%s\\%s*.%s"), szDownloadDir, XP_MSG_FILE_PREFIX, XP_MSG_FILE_SUFFIX);
    HANDLE hSearch = FindFirstFile (szSearchMask, &wfdFile);
    if (hSearch == INVALID_HANDLE_VALUE)
    {
        return;
    }
    BOOL fFound = TRUE;
    while (fFound)
    {
        wsprintf (szTmpDir, TEXT("%s\\%s"), szDownloadDir, wfdFile.cFileName);
        // If the file size of 0, then is probably some garbage file. Get rid of it.
        // A zero-sized file does not contains a message.
        if (0 == wfdFile.nFileSizeHigh && 0 == wfdFile.nFileSizeLow)
        {
            DeleteFile (szTmpDir);
        }
        else
        {
            m_List.QueuePendingMsgFile (szTmpDir);
        }
        fFound = FindNextFile (hSearch, &wfdFile);
    }
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::DownloadMessageHeaders()
//
//    Parameters
//      None
//
//    Purpose
//      This function downloads the message headers for the user's mailbox and
//      is a remote folder is available, re-load the contents table of the
//      folder with the new message headers information.
//
//    Return Value
//      An HRESULT
//
STDMETHODIMP CXPLogon::DownloadMessageHeaders()
{
    // Guard against re-entrancy from the timer call back which happens on a separate thread
    UpdateProgress (0, REMOTE_ACTION_HEADER_REFRESH);     // Start the progress bar
    HRESULT hResult = GetHeadersFromServer (m_szServer,
                                            m_UserInfo.szMailboxName,
                                            m_szHeaders);
    UpdateProgress (50, REMOTE_ACTION_HEADER_REFRESH);    // Half way through
    if (!hResult && m_pStatusObj && m_pStatusObj->m_pHeaderFolder)
    {
        hResult = m_pStatusObj->m_pHeaderFolder->FillContentsTable (m_szHeaders);
    }
    UpdateProgress (100, REMOTE_ACTION_HEADER_REFRESH);   // Finish
    TraceResult ("CXPLogon::DownloadMessageHeaders", hResult);
    return hResult;
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::EmptyInboundQueue()
//
//    Parameters
//      None
//
//    Purpose
//      Deletes all the node in the queue of downloaded messages, deleting
//      the used memory and closing the handle to the local temporary
//      message file.
//
//    Return Value
//      None
//
void WINAPI CXPLogon::EmptyInboundQueue()
{
    // If we have nodes at this point, is because the transport could not
    // process them at this time. They will be retrieved in the next time this
    // transport comes on line on the same profile or on a profile that has
    // the same user identity.
    PLIST_NODE pNode = m_List.GetDownloadNode();
    while (pNode)
    {
        CloseHandle (pNode->hFile);
        delete pNode;
        // If the list is empty, pNode will be NULL.
        // CList::GetDownloadNode() returns NULL for an empty list.
        pNode = m_List.GetDownloadNode();
    }
}

///////////////////////////////////////////////////////////////////////////////
//    TimerWndProc()
//
//    Parameters
//      { Refer to Win32 documentation }
//
//    Purpose
//      Stub window procedure for the hidden timer window class.
//
//    Return Value
//      Default value return by the default window procedure
//
LRESULT CALLBACK TimerWndProc (HWND      hWnd,
                               UINT      message,
                               WPARAM    wParam,
                               LPARAM    lParam)
{
    return DefWindowProc(hWnd, message, wParam, lParam);
}


///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::InitializeTimer()
//
//    Parameters
//      None.
//
//    Purpose
//      Initialize the hidden window for the upload timer.
//
//    Return Value
//      None.
//
void WINAPI CXPLogon::InitializeTimer()
{
    WNDCLASS wc = { 0 };
    // Register the class for this application
    wc.lpfnWndProc      = TimerWndProc;
    wc.hInstance        = m_hInstance;
    wc.lpszClassName    = TIMER_WND_CLASS;
    if (!RegisterClass (&wc))
    {
        TraceResult ("InitializeTimer: Failed to register the timer window class", GetLastError());
        return;
    }
    m_hTimerWnd = CreateWindow (TIMER_WND_CLASS,
                                NULL,
                                WS_OVERLAPPEDWINDOW,
                                0, 0, 0, 0,
                                NULL,
                                NULL,
                                m_hInstance,
                                NULL);
    if (NULL == m_hTimerWnd)
    {
        TraceResult ("InitializeTimer: Failed to create timer window", GetLastError());
        return;
    }
    SetWindowLong (m_hTimerWnd, GWL_USERDATA, (LONG)this);
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::StartUploadTimer()
//
//    Parameters
//      None.
//
//    Purpose
//      This function sets a timer with the operating system. When
//      the specified period elapses, we will get called in the procedure
//      specified and we will then flush the incoming and outgoing queues.
//      Note that we round the delivery time to the HOUR
//
//    Return Value
//      None.
//
void WINAPI CXPLogon::StartUploadTimer()
{
    SYSTEMTIME stNow = { 0 };
    GetLocalTime (&stNow);
    WORD wUploadHour = m_stDelivTime.wHour;
    // If the time is 0:00, this is 12:00 AM midnight
    if (!wUploadHour)
    {
        wUploadHour = 24;
    }
    UINT uDelay = 0;
    // How many hours before the next upload?
    int nHours = wUploadHour - stNow.wHour;
    if (nHours <= 0)
    {
        // If the hours is 0 and the time hasn't arrived with in this hour,
        // set the upload timer for THIS hour.
        if (0 == nHours && stNow.wMinute < m_stDelivTime.wMinute)
        {
            nHours = -24;
            uDelay += (UINT)(m_stDelivTime.wMinute - stNow.wMinute) * 60 * 1000;
        }
        nHours += 24;
    }
    uDelay += (UINT)nHours * 60 * 60 * 1000; // Number of milliseconds in the hours
    m_uTimerID = SetTimer (m_hTimerWnd, 0, uDelay, UploadTimerProc);
    if (0 == m_uTimerID)
    {
        TraceResult ("CXPLogon::StartUploadTimer: Failed to set the timer", GetLastError());
    }
}

///////////////////////////////////////////////////////////////////////////////
//    CXPLogon::StopUploadTimer()
//
//    Parameters
//      None.
//
//    Purpose
//      Terminates the timer used for the upload time.
//
//    Return Value
//      None
//
void WINAPI CXPLogon::StopUploadTimer()
{
    // If we have a timer around, terminate it and all its associated resources
    if (m_uTimerID)
    {
        KillTimer (m_hTimerWnd, m_uTimerID);
        DestroyWindow (m_hTimerWnd);
        UnregisterClass (TIMER_WND_CLASS, m_hInstance);
        m_hTimerWnd = NULL;
        m_uTimerID = 0;
    }
}

///////////////////////////////////////////////////////////////////////////////
//    UploadTimerProc()
//
//    Parameters
//      { Refer to the Win32 TIMERPROC callback parameters }
//
//    Purpose
//      This function executes when the timer delay has expired.
//      Now we ask the spooler to send us the deferred messages, and we set
//      the transport state ready to receive updated headers.
//
//    Return Value
//      None
//
void CALLBACK UploadTimerProc (HWND    hTimerWnd,
                               UINT    Message,
                               UINT    idEvent,
                               DWORD   dwTime)
{
    KillTimer (hTimerWnd, idEvent);
    // We asked to get the CXPLogon object who set the timer. We now
    // check and see if the object is valid before we attempt to use it.
    CXPLogon * pLogon = (CXPLogon *)GetWindowLong (hTimerWnd, GWL_USERDATA);
    if (!pLogon ||
        IsBadWritePtr (pLogon, sizeof(CXPLogon)) ||
        IsBadReadPtr (pLogon, sizeof(CXPLogon)))
    {
        TraceMessage ("UploadTimerProc: We got a bogus logon object");
        return;
    }
    pLogon->m_uTimerID = 0;

    // If the transport's outgoing logic has been activated in this session,
    // send all the deferred messages, by flushing the transport.
    if (pLogon->GetTransportStatusCode() & STATUS_OUTBOUND_ENABLED)
    {
        pLogon->AddStatusBits (UPLOADING_MESSAGES);
    }
    // If the transport's incoming logic has been activated in this session,
    // get any pending messages that need to be placed in the default inbox,
    // and set the transport state, ready to get the headers from the server..
    if (pLogon->GetTransportStatusCode() & STATUS_INBOUND_ENABLED)
    {
        pLogon->AddStatusBits (DOWNLOADING_MESSAGES);
        pLogon->SetTransportState (PROCESSING_TIMER_EVENT);
    }
    // Modify the status row now
    pLogon->UpdateStatus();
    // Reset the time for the next upload. Uploading time is a recurring event.
    pLogon->StartUploadTimer();
}

// End of file for XPLOGON.CPP