windows-xp/Source/XPSP1/NT/shell/ext/webcheck/mailagnt.cpp

//
// WebCheck Mail Agent
//
// A user specifies that they are to be notified via email when a web checked
// object (usually a page) changes.
//
// When the subscription is the delivery agent will call the mail agent upon completion
//  with a temporary ISubscriptionItem
// 
// Julian Jiggins (julianj), January 8, 1997
//

#include "private.h"
#include "mapi.h"
#include "smtp.h"
#include "mlang.h"

#include <mluisupp.h>

#undef TF_THISMODULE
#define TF_THISMODULE   TF_MAILAGENT

//
// Global strings
// REVIEW move to a better place
//
#define MAIL_HANDLER    TEXT("Software\\Clients\\Mail")
#define MAIL_ATHENA     TEXT("Internet Mail and News")
#define SUBJECT_LINE TEXT("Subscription delivered")
#define MESSAGE_PREFIX TEXT(" \r\nThe website you requested ")
#define MESSAGE_SUFFIX TEXT(" has been delivered")

#define ATHENA_SMTP_SERVER \
    TEXT("Software\\Microsoft\\Internet Mail and News\\Mail\\SMTP")
#define NETSCAPE_SMTP_SERVER \
    TEXT("Software\\Netscape\\netscape Navigator\\Services\\SMTP_Server")
#define EUDORA_COMMANDLINE TEXT("Software\\Qualcomm\\Eudora\\CommandLine")

#define NOTE_TEXT_LENGTH 4096

#define ENCODING_STRLEN 32

//////////////////////////////////////////////////////////////////////////
//
// Email helper functions
//
//////////////////////////////////////////////////////////////////////////

//
// Returns a MemAlloc'd string with HTMLBreak inserted in place of '\d'.
//
void AddHTMLBreakText(LPSTR szText, LPSTR szHTMLBreak, LPSTR *lpHTMLText)
{
    ASSERT(szText);
    ASSERT(szHTMLBreak);
    ASSERT(!*lpHTMLText);

    LPSTR lpTmp = NULL, lpTmp2 = NULL, lpHTMLAbstract = NULL;
    int cbCRs = 0;
    int cbLFs = 0;
    DWORD dwExtra = 0;
    
    //
    // Count number of carriage returns
    //
    for (lpTmp = szText; *lpTmp; lpTmp++)
    {
        if (*lpTmp == 0x0d)
            cbCRs++;
        if (*lpTmp == 0x0a)
            cbLFs++;
    }
    
    dwExtra = lstrlenA(szText) - cbCRs - cbLFs + cbCRs * lstrlenA(szHTMLBreak) + 1;

    //
    // Allocate appropriate size string
    //
    *lpHTMLText = lpHTMLAbstract = (LPSTR)MemAlloc(LPTR, dwExtra);
    if (!lpHTMLAbstract)
        return;

    // 
    // Create new HTML abstract string.
    //
    for (lpTmp = szText; *lpTmp; lpTmp++)
    {
        if (*lpTmp == 0x0d)
        {
            for (lpTmp2 = szHTMLBreak; *lpTmp2; lpTmp2++, lpHTMLAbstract++)
                *lpHTMLAbstract = *lpTmp2;
        }
        else if (*lpTmp != 0x0a)
        {
            *lpHTMLAbstract = *lpTmp;
            lpHTMLAbstract++;
        }
    }

    *lpHTMLAbstract = '\0';

}

#ifdef DEBUG
void DBG_OUTPUT_MAPI_ERROR(ULONG ul)
{
    switch(ul)
    {
    case MAPI_E_LOGON_FAILURE: 
        DBG("MailAgent: MAPI LOGON FAILURE"); break;
    case MAPI_E_FAILURE:
        DBG("MailAgent: MAPI_E_FAILURE"); break;
    default: 
        DBG("MailAgent: Failed to send mail message"); break;
    }
}
#else
#define DBG_OUTPUT_MAPI_ERROR(ul)
#endif

//
// Build an HTML message containing a frameset that effectively inlines
// the requested URL
//
BOOL BuildHTMLMessage(LPSTR szEmailAddress, LPSTR szName, LPSTR szURL, 
                      CHAR **ppHTMLMessage,  LPSTR szTitle, LPSTR szAbstract,
                      LPSTR szSrcCharset)
{
    *ppHTMLMessage = NULL; // clear out parameter
    
    CHAR * lpBuffer = NULL;

    CHAR szWrapper[NOTE_TEXT_LENGTH];
    CHAR szMessageFormat[NOTE_TEXT_LENGTH];
    CHAR szMessageFormat2[NOTE_TEXT_LENGTH];
    CHAR szMessageText[NOTE_TEXT_LENGTH];
    CHAR szMessageHTML[NOTE_TEXT_LENGTH];
    CHAR szTextBreak[10];
    CHAR szHTMLBreak[10];

    //
    // Load the wrapper for the HTML message. This is the header stuff 
    // and multipart MIME and HTML goop
    //
    int iRet = MLLoadStringA(IDS_AGNT_HTMLMESSAGEWRAPPER, szWrapper, NOTE_TEXT_LENGTH);
    ASSERT(iRet > 0);

    if (szTitle != NULL) {

        // NOTE: Size is probably slightly larger than necessary due to %1's.

        LPSTR lpHTMLAbstract = NULL, lpNewAbstract = NULL;
        DWORD dwTotalSize = 0;
        //
        // load string for single HTML line break as well as tag on for custom email
        //

        MLLoadStringA(IDS_AGNT_EMAILMESSAGE, szMessageText, ARRAYSIZE(szMessageText));

        MLLoadStringA(IDS_AGNT_HTMLBREAKSINGLE, szHTMLBreak, ARRAYSIZE(szHTMLBreak));

        // 
        // Create new abstract string (szAbstract + email tagger)
        //
        dwTotalSize = lstrlenA(szAbstract) + lstrlenA(szMessageText) + 1;

        LPSTR szNewAbstract = (LPSTR)MemAlloc(LPTR, dwTotalSize * sizeof(CHAR));
        if (!szNewAbstract)
            return FALSE;

        lstrcpyA(szNewAbstract, szAbstract);
        StrCatA(szNewAbstract, szMessageText);
        
        AddHTMLBreakText(szNewAbstract, szHTMLBreak, &lpHTMLAbstract);
        if (!lpHTMLAbstract) 
        {
            MemFree(szNewAbstract);
            return FALSE;
        }
            
        dwTotalSize = lstrlenA(szWrapper) + lstrlenA(szEmailAddress) + 
                            2*lstrlenA(szTitle) + lstrlenA(szNewAbstract) + lstrlenA(szSrcCharset) +
                            lstrlenA(lpHTMLAbstract) + lstrlenA(szURL) + 1;

        lpBuffer = (CHAR *)MemAlloc(LPTR, dwTotalSize * sizeof(CHAR));
        if (!lpBuffer)
            return FALSE;

        LPSTR lpArguments[6];
        lpArguments[0] = szEmailAddress;
        lpArguments[1] = szTitle;
        lpArguments[2] = szNewAbstract;
        lpArguments[3] = szSrcCharset;    // the charset of the HTML page
        lpArguments[4] = szURL;
        lpArguments[5] = lpHTMLAbstract;

        //
        // Reason for FormatMessage is that wsprintf is limited up to 1024 bytes
        //

        FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                szWrapper, 0, 0, lpBuffer, dwTotalSize, (va_list *)&lpArguments[0]);

        MemFree(szNewAbstract);
        MemFree(lpHTMLAbstract);

    } else {

        //
        // Load line breaks for the plaintext and html messages
        //
        iRet = MLLoadStringA(IDS_AGNT_TEXTBREAK, szTextBreak, ARRAYSIZE(szTextBreak));
        ASSERT(iRet > 0);
        iRet = MLLoadStringA(IDS_AGNT_HTMLBREAK, szHTMLBreak, ARRAYSIZE(szHTMLBreak));
        ASSERT(iRet > 0);

        //
        // Load the actual text message to put sent
        //
        iRet = MLLoadStringA(IDS_AGNT_HTMLMESSAGETEXT, szMessageFormat, NOTE_TEXT_LENGTH);
        ASSERT(iRet > 0);

        iRet = MLLoadStringA(IDS_AGNT_HTMLMESSAGETEXT2, szMessageFormat2, NOTE_TEXT_LENGTH);
        ASSERT(iRet > 0);

        //
        // Insert the text messages into the wrapper. Note two message get
        // Once in the mime section for text/ascii and once in the 
        // noframes section of the text/html frameset. This is a work around
        // for clients (like Outlook) that think they can render HTML
        // but cannot really. 
        // The second message IDS_AGNT_HTMLMESSAGETEXT2 should NOT be localized
        // this is only going to be seen by Exchange users. In the future exchange
        // will handle html mail correct, so it acceptable that for example
        // Japanese Exchange users see english in this message. Most Japanese
        // users will user Outlook Express and so will just see the html message
        //

        // First we format 2 text messages, one for text and one for HTML,
        // since message itself is relatively small we know its < 1024 bytes

        iRet = wnsprintfA(szMessageText, ARRAYSIZE(szMessageText), szMessageFormat, 
                         szName, szTextBreak, szURL, szTextBreak);
        ASSERT(iRet > lstrlenA(szMessageFormat));

        iRet = wnsprintfA(szMessageHTML, ARRAYSIZE(szMessageHTML), szMessageFormat2, 
                         szName, szHTMLBreak, szURL, szHTMLBreak);
        ASSERT(iRet > lstrlenA(szMessageFormat2));

        DWORD dwTotalSize = lstrlenA(szWrapper) + lstrlenA(szEmailAddress) +
                            lstrlenA(szName) + lstrlenA(szMessageText) + lstrlenA(szSrcCharset) +
                            lstrlenA(szMessageHTML) + lstrlenA(szURL) + 1;

        lpBuffer = (CHAR *)MemAlloc(LPTR, dwTotalSize * sizeof(CHAR));
        if (!lpBuffer)
            return FALSE;

        LPSTR lpArguments[6];
        lpArguments[0] = szEmailAddress;  // target email address
        lpArguments[1] = szName;          // the name of the page that goes in the subject line  
        lpArguments[2] = szMessageText;   // the plain text message
        lpArguments[3] = szSrcCharset;    // the charset of the HTML page
        lpArguments[4] = szURL;           // the href of the page that goes in the frame set
        lpArguments[5] = szMessageHTML;   // the plain text message that goes in the 
                                          // noframes part of the frameset

        DWORD dwRet;
        dwRet = FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
            szWrapper, 0, 0, lpBuffer, dwTotalSize, (va_list *)&lpArguments[0]);
        ASSERT(dwRet);            
    }

    *ppHTMLMessage = lpBuffer;

    return TRUE;
}

//
// Build the actual text of the message to be sent via SMTP,
// load format string from resource and insert URL and URL's friently name.
//
void BuildSMTPMessage(LPSTR szName, LPSTR szURL, LPSTR *szMessage,
                      LPSTR szTitle, LPSTR szAbstract)
{
    CHAR szFormatText[NOTE_TEXT_LENGTH];
    int i;
    ASSERT(szMessage);
    
    if (!szMessage)
        return;


    *szMessage = NULL;

    if (szTitle != NULL) {
        i = MLLoadStringA(IDS_AGNT_SMTPMESSAGE_OTHER, szFormatText, NOTE_TEXT_LENGTH);
        ASSERT(i != 0);
        
        DWORD dwLen = lstrlenA(szFormatText) + lstrlenA(szTitle) + lstrlenA(szAbstract) + 1;

        *szMessage = (LPSTR) MemAlloc(LPTR, dwLen * sizeof(CHAR));
        if (!*szMessage)
            return;

        LPSTR lpArgs[2];
        lpArgs[0] = szTitle;
        lpArgs[1] = szAbstract;

        FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                szFormatText, 0, 0, *szMessage, dwLen, (va_list *)&lpArgs[0]);

    } else {
        i = MLLoadStringA(IDS_AGNT_SMTPMESSAGE, szFormatText, NOTE_TEXT_LENGTH);
        ASSERT(i != 0);
        
        DWORD dwLen = lstrlenA(szFormatText) + 2*lstrlenA(szName) + lstrlenA(szURL) + 1;

        *szMessage = (LPSTR) MemAlloc(LPTR, dwLen * sizeof(CHAR));
        if (!*szMessage)
            return;

        LPSTR lpArgs[3];
        lpArgs[0] = lpArgs[1] = szName;
        lpArgs[2] = szURL;

        FormatMessageA(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                szFormatText, 0, 0, *szMessage, dwLen, (va_list *)&lpArgs[0]);
    }

}

#if 0
//
// Build MAPI message structure
//

void BuildMAPIMessage(
    LPTSTR lpszName, 
    LPTSTR lpszURL, 
    LPTSTR lpszEmailAddress,
    MapiMessage   * lpMessage,
    MapiRecipDesc * lpRecipient,
    LPTSTR lpszNoteText,                    // [out]
    LPTSTR lpszSubject,                     // [out]
    LPTSTR lpszTitle,                        // [in] title, NULL if not custom
    LPTSTR lpszAbstract)                     // [in] abstract, NULL if not custom
{
    TCHAR szFmtNoteText[NOTE_TEXT_LENGTH];
    TCHAR szFmtSubject[INTERNET_MAX_URL_LENGTH];
    int i;

    //
    // zero out the passed in mapi structures
    //
    ZeroMemory(lpMessage,   sizeof(MapiMessage));
    ZeroMemory(lpRecipient, sizeof(MapiRecipDesc));
#error The wsprintf's below need to be converted to wnsprintf
    //
    // Load the strings containing the bulk of the email message
    //
    if (lpszTitle != NULL) {
        MLLoadString(IDS_AGNT_MAPIMESSAGE_OTHER, szFmtNoteText, NOTE_TEXT_LENGTH);
        MLLoadString(IDS_AGNT_MAPISUBJECT_OTHER, szFmtSubject, INTERNET_MAX_URL_LENGTH);

        i = wsprintf(lpszNoteText, szFmtNoteText, lpszAbstract);
        ASSERT(i < NOTE_TEXT_LENGTH);
        i = wsprintf(lpszSubject, szFmtSubject, lpszTitle);
        ASSERT(i < INTERNET_MAX_URL_LENGTH);

    } else {
        MLLoadString(IDS_AGNT_MAPIMESSAGE, szFmtNoteText, NOTE_TEXT_LENGTH);
        MLLoadString(IDS_AGNT_MAPISUBJECT, szFmtSubject,  INTERNET_MAX_URL_LENGTH);

        i = wsprintf(lpszNoteText, szFmtNoteText, lpszName, lpszURL);
        ASSERT(i < NOTE_TEXT_LENGTH);
        i = wsprintf(lpszSubject,  szFmtSubject, lpszName);
        ASSERT(i < INTERNET_MAX_URL_LENGTH);
    }

    //
    // Build a mapi mail recipient structure
    //
    lpRecipient->ulRecipClass = MAPI_TO;
    lpRecipient->lpszName = lpszEmailAddress;

    //
    // Fill in the message subject line, recipient and note text
    //
    lpMessage->nRecipCount = 1;
    lpMessage->lpRecips = lpRecipient;
    lpMessage->lpszNoteText = lpszNoteText;
    lpMessage->lpszSubject  = lpszSubject;
}
#endif

//
// Use the MLANG apis to translate the string
//
// Returns success if translation occurred, fails otherwise
//
// Note if lpszSrcCharSet is NULL then use CP_ACP as the codepage
//

HRESULT TranslateCharset(
    LPSTR lpszSrcString, LPSTR lpszDstString, UINT uiDstSize,
    LPSTR lpszSrcCharset, LPSTR lpszDstCharset
    )
{
    HRESULT hr = E_FAIL;

    WCHAR wszSrcCharset[ENCODING_STRLEN];
    WCHAR wszDstCharset[ENCODING_STRLEN];

    if (lpszSrcString  == NULL || lpszDstString  == NULL || 
        lpszDstCharset == NULL)
    {
        return E_INVALIDARG;
    }

    SHAnsiToUnicode(lpszDstCharset, wszDstCharset, ARRAYSIZE(wszDstCharset));
    if (lpszSrcCharset)
        SHAnsiToUnicode(lpszSrcCharset, wszSrcCharset, ARRAYSIZE(wszSrcCharset));

    LPMULTILANGUAGE2 pIML2 = NULL;

    //
    // Create the MLANG object
    //
    if (SUCCEEDED(CoCreateInstance (CLSID_CMultiLanguage, NULL,
        CLSCTX_INPROC_SERVER, IID_IMultiLanguage2, (void**)&pIML2)))
    {
        UINT srcCodePage = (UINT)-1, dstCodePage;
        MIMECSETINFO mcsi = {0};

        //
        // First get the source code page either from the passed in string
        // name of source Charset or from the default one if null if passed in
        //
        if (lpszSrcCharset == NULL)
        {
            srcCodePage = GetACP();
            hr = S_OK;
        }
        else
        {
            //
            // Use the mlang object to get the codepages
            //
            hr = pIML2->GetCharsetInfo(wszSrcCharset, &mcsi);
            if (SUCCEEDED(hr))
            {
                srcCodePage = mcsi.uiInternetEncoding;
            }
        }
        
        if (SUCCEEDED(hr))
        {
            hr = pIML2->GetCharsetInfo(wszDstCharset, &mcsi);

            if (SUCCEEDED(hr))
            {
                dstCodePage = mcsi.uiInternetEncoding;

                if (srcCodePage != dstCodePage)
                {
                    //
                    // To work around a bug in the Mlang::ConvertString api
                    // have to pass in a ptr to length of the src string
                    //
                    UINT uiSrcSize = lstrlenA(lpszSrcString) + 1;

                    DWORD dwMode = 0;
                    hr = pIML2->ConvertString(
                        &dwMode, 
                        srcCodePage, 
                        dstCodePage,
                        (LPBYTE)lpszSrcString,
                        &uiSrcSize,
                        (LPBYTE)lpszDstString,
                        &uiDstSize);
                }
                else
                {
                    lstrcpynA(lpszDstString, lpszSrcString, uiDstSize);
                }
            }
        }
        pIML2->Release();
    }
    return hr;
}



//////////////////////////////////////////////////////////////////////////
//
// Mail notification implementation
//
//////////////////////////////////////////////////////////////////////////

//
// Notify via email that the pszURL has changed
//
// There are 3 ways to send via email -
//
// Use straight MAPI (IE Exchange or Outlook)
//      Most people don't have Exchange in the real world.
//
// Use Athena's MAPI implementation
//      It's broken and doesn't handle UI'less mode
//
// Use straight SMTP,
//      Need to get the name of an SMTP server
//
HRESULT
NotifyViaEMail(
    LPSTR lpszURL,             // url that was downloaded
    LPSTR lpszEmailAddress,    // email address to send notification to
    LPSTR lpszSMTPServer,      // SMTP server to use to deliver email
    LPSTR &lpszName,           // friendly name of url (probably page title)
    LPSTR lpszTitle,           // optional: NULL if not custom message
    LPSTR lpszAbstract,        // optional: NULL if not custom message
    LPSTR lpszCharSet,         // optional: charset of html page
    BOOL  fSendHTMLEmail )     // TRUE if registry allows it and check mode
                               // supports it.
{
    BOOL b;
    
    LPSTR lpszSMTPMessage;

    //
    // lpszName comes from the title of the web page. If the charset of the page
    // is not the same as the one that this version of IE has been localized to
    // then we need to use the MLANG api's to coerce the string into the correct
    // charset
    //
    CHAR szTargetEncoding[ENCODING_STRLEN];
    MLLoadStringA(IDS_TARGET_CHARSET_EMAIL, szTargetEncoding, ARRAYSIZE(szTargetEncoding));

    //
    // Allocate buffer for new name. This is a conversion from one dbcs charset 
    // to another so size shouldn't but to be safe use *2 multiplier.
    //
    UINT uiSize = lstrlenA(lpszName) * 2;
    LPSTR lpszNewName = (LPSTR) MemAlloc(LMEM_FIXED, uiSize * sizeof(CHAR));

    if (lpszNewName)
    {
        //
        // Note check for S_OK as will return S_FALSE if there is no appropriate
        // translation installed on this machine
        //
        if (S_OK == TranslateCharset(lpszName, lpszNewName, uiSize, lpszCharSet,
                                     szTargetEncoding))
        {
            //
            // if translation occurred alias new name to old name
            //
            SAFELOCALFREE(lpszName);
            lpszName = lpszNewName;
        }
        else
        {
            SAFELOCALFREE(lpszNewName); // don't need newname after all
        }
    }
    
    //
    // If we are requested to HTML mail and we successfully built the html
    //
    if (!(fSendHTMLEmail &&
         BuildHTMLMessage(lpszEmailAddress, lpszName, lpszURL, &lpszSMTPMessage,
                          lpszTitle, lpszAbstract, lpszCharSet)))
    {
        //
        // If sending a simple notification or BuildHTMLMessage failed
        // force fSendHTMLEmail to false and build simple smtp message
        //
        fSendHTMLEmail = FALSE;
        BuildSMTPMessage(lpszName, lpszURL, &lpszSMTPMessage, lpszTitle, lpszAbstract);
    }

    //
    // Disable MAPI for now
    //
    //-----------------------------------------
    //BUG BUG: If this is enabled then wsprintf on message text should be changed to FormatMessage
    //         due to 1KB message limit.
    #if 0
    
    //
    // First try and load a full mapi implementation (exchange or outlook)
    //
    HMODULE hmodMail = LoadNormalMapi();
    if (hmodMail != NULL)
    {
        //
        // Get mapi function entry points
        //
        LPMAPISENDMAIL pfnSendMail;
        LPMAPILOGON pfnLogon;
        MapiMessage   message;
        MapiRecipDesc recipient;

        pfnSendMail = (LPMAPISENDMAIL)GetProcAddress(hmodMail, "MAPISendMail");
        pfnLogon    = (LPMAPILOGON)   GetProcAddress(hmodMail, "MAPILogon");
        if (pfnSendMail != NULL && pfnLogon != NULL)
        {
            //
            // Logon to mapi provider
            //
            LHANDLE hSession = 0;
            LPSTR lpszProfileName = NULL;  // for now logon on with NULL
            LPSTR lpszPassword = NULL;     // credentials
            ULONG ul = pfnLogon(0, lpszProfileName, lpszPassword, 0, 0, &hSession);
            if (ul != SUCCESS_SUCCESS)
            {
                DBG_OUTPUT_MAPI_ERROR(ul);
                //
                // Fall through to try other mail delivery methods
                //
            }
            else
            {
                TCHAR szSubject[INTERNET_MAX_URL_LENGTH];

                //
                // Fill in the text, subject line and recipient in mapi message
                //
                BuildMAPIMessage(lpszName, lpszURL, lpszEmailAddress, 
                                 &message, &recipient,
                                 szSubject, lpszSMTPMessage, szTitle, szAbstract);

                //
                // Actually send the message via MAPI with no UI
                //
                ul = pfnSendMail(0, 0, &message, 0, 0);
                if (ul != SUCCESS_SUCCESS)
                {
                    DBG_OUTPUT_MAPI_ERROR(ul);
                }
                else
                {
                    FreeLibrary(hmodMail);
                    return S_OK;
                }
            }
        }
        FreeLibrary(hmodMail);
    }
    #endif

    //
    // Send message to given address and from given address
    //
    if (lpszSMTPMessage)
    {
        b = SMTPSendMessage(lpszSMTPServer,  lpszEmailAddress, 
                            lpszEmailAddress, lpszSMTPMessage);

        MemFree(lpszSMTPMessage);

    }
    else
    {
        b = FALSE;
    }

    if (b)
        return S_OK;

    return E_FAIL;
}

//////////////////////////////////////////////////////////////////////////
//
// Helper function to send email
//
//////////////////////////////////////////////////////////////////////////
HRESULT SendEmailFromItem(ISubscriptionItem *pItem)
{
    HRESULT hr = E_FAIL;
    LPSTR pszURL = NULL;
    LPSTR pszName = NULL;
    LPSTR pszTitle = NULL;
    LPSTR pszAbstract = NULL;
    LPSTR pszCharSet = NULL;
    
    // Get the Email URL to send.  Fall back to the download URL.
    ReadAnsiSTR(pItem, c_szPropEmailURL, &pszURL);
    if (!pszURL)
        ReadAnsiSTR(pItem, c_szPropURL, &pszURL);
    ASSERT(pszURL);

    // Get the friendly name.  Fall back to the download URL.
    ReadAnsiSTR(pItem, c_szPropName, &pszName);
    ASSERT(pszName);
    if (!pszName)
        ReadAnsiSTR(pItem, c_szPropURL, &pszName);

    // Get Email Title and Abstract if flag is set.
    DWORD dwEmailFlags = 0;
    ReadDWORD(pItem, c_szPropEmailFlags, &dwEmailFlags);
    if (dwEmailFlags & MAILAGENT_FLAG_CUSTOM_MSG)
    {
        ReadAnsiSTR(pItem, c_szPropEmailTitle, &pszTitle);
        ASSERT(pszTitle);
        ReadAnsiSTR(pItem, c_szPropEmailAbstract, &pszAbstract);
        ASSERT(pszAbstract);
    }

    //
    // Get the charset in the notification
    //
    ReadAnsiSTR(pItem, c_szPropCharSet, &pszCharSet);

    // Get Email address and SMTP server
    TCHAR tszBuf[MAX_PATH];
    CHAR szEmailAddress[MAX_PATH];
    CHAR szSMTPServer[MAX_PATH];
    
    ReadDefaultEmail(tszBuf, ARRAYSIZE(tszBuf));
    SHTCharToAnsi(tszBuf, szEmailAddress, ARRAYSIZE(szEmailAddress));
    ReadDefaultSMTPServer(tszBuf, ARRAYSIZE(tszBuf));
    SHTCharToAnsi(tszBuf, szSMTPServer, ARRAYSIZE(szSMTPServer));

    // Send the email
    if (pszURL && pszName)
    {
        //
        // Check if HTML Mail notification is enabled or disabled thru the registry
        //
        BOOL fSendHTMLEmail = FALSE;

        if (!ReadRegValue(HKEY_CURRENT_USER, c_szRegKey,
            TEXT("EnableHTMLMailNotification"),
            &fSendHTMLEmail, sizeof(DWORD)))
        {
            fSendHTMLEmail = TRUE; // default to on if not read from registry
        }

        // Now make sure our crawling mode supports HTML mail. We don't
        // want to send HTML if we're in check-for-change only.
        DWORD dwTemp = 0;
        ReadDWORD(pItem, c_szPropCrawlChangesOnly, &dwTemp);
        if (dwTemp != 0)
        {
            fSendHTMLEmail = FALSE;
        }
        // else, leave fSendHTMLEmail in its reg-based setting.

        hr = NotifyViaEMail(pszURL, szEmailAddress, szSMTPServer, 
                            pszName, pszTitle, pszAbstract, pszCharSet,
                            fSendHTMLEmail );
    }

    // Clean up.
    SAFELOCALFREE(pszURL);
    SAFELOCALFREE(pszName);
    SAFELOCALFREE(pszTitle);
    SAFELOCALFREE(pszAbstract);
    return hr;
}