Adding MAPI DLL code to the tree - NOT PART OF THE BUILD

mailnews/mapi/hook/makefile.win

@@ -0,0 +1,49 @@
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+DEPTH=..\..\..
+MODULE=mapiguts
+
+################################################################################
+## exports
+
+#EXPORTS =
+
+
+################################################################################
+## library
+
+LIBNAME = .\$(OBJDIR)\mapiguts
+DLL = $(LIBNAME).dll
+DEFINES= -NS_DEBUG
+
+OBJS=										\
+    .\$(OBJDIR)\mapihook.obj  \
+    .\$(OBJDIR)\mapimail.obj  \
+		$(NULL)
+
+LLIBS=										\
+			$(LLIBS)						\
+			$(LIBNSPR)						\
+			$(DIST)\lib\xppref32.lib		\
+			$(DIST)\lib\xpcom.lib       	\
+			$(DIST)\lib\mapiutils_s.lib  \
+			$(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(DLL)
+	$(MAKE_INSTALL)  $(LIBNAME).$(DLL_SUFFIX) $(DIST)\bin\components

mailnews/mapi/hook/mapihook.h

@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef _MAPI_HOOK_H_
+#define _MAPI_HOOK_H_
+
+#include <structs.h>    // for MWContext
+
+//
+// This is the entry point to the MAPI session manager that lives
+// inside of Communicator.
+// 
+LONG ProcessNetscapeMAPIHook(WPARAM wParam, LPARAM lParam);
+
+#endif // _MAPI_HOOK_H_

mailnews/mapi/hook/mapimail.cpp

@@ -0,0 +1,834 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  More MAPI Hooks for Communicator
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include "windows.h"
+#include "template.h"
+#include "msgcom.h"
+#include "wfemsg.h"
+#include "compstd.h"
+#include "compbar.h"
+#include "compmisc.h"
+#include "compfrm.h"
+#include "prefapi.h"
+#include "intl_csi.h"
+#include "dlghtmrp.h"
+#include "dlghtmmq.h"
+
+// rhp - was breaking the optimized build!
+//#include "edt.h"
+//#include "edview.h"
+//#include "postal.h"
+//#include "apiaddr.h"
+//#include "mailmisc.h"
+
+extern "C" {
+#include "xpgetstr.h"
+extern int MK_MSG_MSG_COMPOSITION;
+};
+
+#include "mapimail.h"
+#include "nscpmapi.h"
+#include "mailpriv.h"
+#include "nsstrseq.h"
+
+MWContext             
+*GetUsableContext(void)
+{
+  CGenericFrame     *pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
+
+  ASSERT(pFrame != NULL);
+  if (pFrame == NULL)
+  {
+    return(NULL);
+  }
+
+  // Now return the context...
+  return((MWContext *) pFrame->GetMainContext());
+}
+
+//
+// This function will create a composition window and either do
+// a blind send or pop up the compose window for the user to 
+// complete the operation
+//
+// Return: appropriate MAPI return code...
+//
+// 
+extern "C" LONG
+DoFullMAPIMailOperation(MAPISendMailType      *sendMailPtr,
+											  const char            *pInitialText,
+                        BOOL                  winShowFlag)
+{   
+CGenericDoc             *pDocument;
+LPSTR                   subject;
+NSstringSeq             mailInfoSeq;
+DWORD                   stringCount = 6;
+DWORD                   i;
+CString                 csDefault;
+
+  // Get a context to use for this call...
+  MWContext *pOldContext = GetUsableContext();
+  if (!pOldContext)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  // Don't allow a compose window to be created if the user hasn't 
+  // specified an email address
+  const char *real_addr = FE_UsersMailAddress();
+  if (MISC_ValidateReturnAddress(pOldContext, real_addr) < 0)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  //
+  // Now, we must build the fields object...
+  //
+  mailInfoSeq = (NSstringSeq) &(sendMailPtr->dataBuf[0]);
+  subject = NSStrSeqGet(mailInfoSeq, 0);
+
+  // We should give it a subject to preven the prompt from coming
+  // up...
+  if ((!subject) || !(*subject))
+  {
+    csDefault.LoadString(IDS_COMPOSE_DEFAULTNOSUBJECT);
+    subject = csDefault.GetBuffer(2);
+  }
+
+  TRACE("MAPI: ProcessMAPISendMail() Subject   = [%s]\n", subject);
+  TRACE("MAPI: ProcessMAPISendMail() Text Size = [%d]\n", strlen((const char *)pInitialText));
+  TRACE("MAPI: ProcessMAPISendMail() # of Recipients  = [%d]\n", sendMailPtr->MSG_nRecipCount);
+
+
+  char  toString[1024] = "";
+  char  ccString[1024] = "";
+  char  bccString[1024] = "";
+
+  for (i=0; i<sendMailPtr->MSG_nRecipCount; i++)
+  {
+    LPSTR   ptr;
+    UCHAR   tempString[256];
+
+    ULONG addrType = atoi(NSStrSeqGet(mailInfoSeq, stringCount++));
+
+    // figure which type of address this is?
+    if (addrType == MAPI_CC)
+      ptr = ccString;
+    else if (addrType == MAPI_BCC)
+      ptr = bccString;
+    else
+      ptr = toString;
+      
+    LPSTR namePtr = (LPSTR) NSStrSeqGet(mailInfoSeq, stringCount++);
+    LPSTR emailPtr = (LPSTR) NSStrSeqGet(mailInfoSeq, stringCount++);
+    if ( (lstrlen(emailPtr) > 5) && (*(emailPtr + 4) == ':') )
+    {
+      emailPtr += 5;
+    }
+
+    // Now build the temp string to tack on in the format
+    // "Rich Pizzarro" <rhp@netscape.com>
+    wsprintf((LPSTR) tempString, "\"%s\" <%s>", namePtr, emailPtr);
+
+    // add a comma if not the first one
+    if (ptr[0] != '\0')
+      lstrcat(ptr, ",");
+
+    // tack on string!
+    lstrcat(ptr, (LPSTR) tempString);
+  }
+
+  BOOL    bEncrypt = FALSE;
+  BOOL    bSign    = FALSE;
+
+  PREF_GetBoolPref("mail.crypto_sign_outgoing_mail", &bSign);
+  PREF_GetBoolPref("mail.encrypt_outgoing_mail", &bEncrypt);
+  MSG_CompositionFields *fields =
+      MSG_CreateCompositionFields(real_addr, real_addr, 
+                  toString, 
+                  ccString, 
+                  bccString,
+									"", "", "",
+									"", subject, "",
+									"", "", "",
+									"", 
+                  bEncrypt,
+                  bSign);
+  if (!fields)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  // RICHIE
+  // INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(pOldContext);
+  // int16 win_csid = INTL_GetCSIWinCSID(csi);
+  
+  pDocument = (CGenericDoc*)theApp.m_TextComposeTemplate->OpenDocumentFile(NULL, NULL, /*win_csid RICHIE*/ winShowFlag);
+  if ( !pDocument )
+  {
+    return(MAPI_E_FAILURE);
+  }
+  
+  CWinCX * pContext = (CWinCX*) pDocument->GetContext();
+  if ( !pContext ) 
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  MSG_CompositionPaneCallbacks Callbacks;
+  Callbacks.CreateRecipientsDialog = CreateRecipientsDialog;
+  Callbacks.CreateAskHTMLDialog = CreateAskHTMLDialog;
+
+  int16 doccsid;
+  MWContext *context = pContext->GetContext();
+  CComposeFrame *pCompose = (CComposeFrame *) pContext->GetFrame()->GetFrameWnd();
+
+  pCompose->SetComposeStuff(context, fields); // squirl away stuff for post-create
+
+  // This needs to be set TRUE if using the old non-HTML text frame
+  // to prevent dropping dragged URLs
+  pContext->m_bDragging = !pCompose->UseHtml();
+  if (!pCompose->UseHtml()) 
+  {
+    pCompose->SetMsgPane(
+      MSG_CreateCompositionPane(pContext->GetContext(), 
+                                context, 
+                                g_MsgPrefs.m_pMsgPrefs, 
+                                fields,
+                                WFE_MSGGetMaster())
+                        );
+  }
+
+  ASSERT(pCompose->GetMsgPane());
+  MSG_SetFEData(pCompose->GetMsgPane(),(void *)pCompose);  
+  pCompose->UpdateAttachmentInfo();
+
+  // Pass doccsid info to new context for MailToWin conversion
+  doccsid = INTL_GetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context));
+  INTL_SetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context), 
+    (doccsid ? doccsid : INTL_DefaultDocCharSetID(context)));
+
+  pCompose->DisplayHeaders(NULL);
+
+  CComposeBar * pBar = pCompose->GetComposeBar();
+  ASSERT(pBar);
+  LPADDRESSCONTROL pIAddressList = pBar->GetAddressWidgetInterface();
+
+  if (!pIAddressList->IsCreated()) 
+  {
+    pBar->CreateAddressingBlock();
+  }
+
+  // rhp - Deal with addressing the brute force way! This is a 
+  // "fix" for bad behavior when creating these windows and not
+  // showing them on the desktop.
+  if (!winShowFlag)      // Hack to fix the window not being mapped
+  {
+    pCompose->AppendAddress(MSG_TO_HEADER_MASK, "");
+    pCompose->AppendAddress(MSG_CC_HEADER_MASK, "");
+    pCompose->AppendAddress(MSG_BCC_HEADER_MASK, "");
+  }
+
+  // Always do plain text composition!
+  pCompose->CompleteComposeInitialization();
+
+  // Do this so we don't get popups on "empty" messages
+  if ( (!pInitialText) || (!(*pInitialText)) )
+    pInitialText = " ";
+
+  const char * pBody = pInitialText ? pInitialText : MSG_GetCompBody(pCompose->GetMsgPane());
+  if (pBody)
+  {
+    FE_InsertMessageCompositionText(context,pBody,TRUE);
+  }
+
+  // 
+  // Now set the message as being edited!    
+  //
+  pCompose->SetModified(TRUE);
+
+  //
+  // Finally deal with the attachments...
+  //
+  if (sendMailPtr->MSG_nFileCount > 0)
+  {
+    // Send this puppy when done with the attachments...
+    if (!winShowFlag)
+    {
+      pCompose->SetMAPISendMode(MAPI_SEND);
+    }
+
+    MSG_AttachmentData *pAttach = (MSG_AttachmentData *)
+                  XP_CALLOC((sendMailPtr->MSG_nFileCount + 1),
+                  sizeof(MSG_AttachmentData));
+    if (!pAttach)
+    {
+      return(MAPI_E_INSUFFICIENT_MEMORY);
+    }
+
+    memset(pAttach, 0, (sendMailPtr->MSG_nFileCount + 1) * 
+                                sizeof(MSG_AttachmentData));
+    for (i=0; i<sendMailPtr->MSG_nFileCount; i++)
+    {
+      CString cs;
+      // Create URL from filename...
+      WFE_ConvertFile2Url(cs, 
+          (const char *)NSStrSeqGet(mailInfoSeq, stringCount++));
+      pAttach[i].url = XP_STRDUP(cs);
+
+      // Now also include the "display" name...
+      StrAllocCopy(pAttach[i].real_name, NSStrSeqGet(mailInfoSeq, stringCount++));
+    }
+
+    // Set the list!
+    MSG_SetAttachmentList(pCompose->GetMsgPane(), pAttach);
+
+    // Now free everything...
+    for (i=0; i<sendMailPtr->MSG_nFileCount; i++)
+    {
+      if (pAttach[i].url)
+        XP_FREE(pAttach[i].url);
+
+      if (pAttach[i].real_name)
+        XP_FREE(pAttach[i].real_name);
+    }
+
+    XP_FREE(pAttach);
+  }
+
+  //
+  // Now, if we were supposed to do the blind send...do it, otherwise,
+  // just popup the window...
+  //
+  if (winShowFlag)      
+  {
+    // Post message to compose window to set the initial focus.
+    pCompose->PostMessage(WM_COMP_SET_INITIAL_FOCUS);
+  }
+  else if (sendMailPtr->MSG_nFileCount <= 0)  // Send NOW if no attachments!
+  {
+    pCompose->PostMessage(WM_COMMAND, IDM_SEND);
+  }
+
+  return(SUCCESS_SUCCESS);
+}
+
+//
+// This function will create a composition window and just attach
+// the attachments of interest and pop up the window...
+//
+// Return: appropriate MAPI return code...
+//
+//
+extern "C" LONG
+DoPartialMAPIMailOperation(MAPISendDocumentsType *sendDocPtr)
+{   
+CGenericDoc             *pDocument;
+
+  // Get a context to use for this call...
+  MWContext *pOldContext = GetUsableContext();
+  if (!pOldContext)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  // Don't allow a compose window to be created if the user hasn't 
+  // specified an email address
+  const char *real_addr = FE_UsersMailAddress();
+  if (MISC_ValidateReturnAddress(pOldContext, real_addr) < 0)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  //
+  // Now, build the fields object w/o much info...
+  //
+  BOOL    bEncrypt = FALSE;
+  BOOL    bSign    = FALSE;
+
+  PREF_GetBoolPref("mail.crypto_sign_outgoing_mail", &bSign);
+  PREF_GetBoolPref("mail.encrypt_outgoing_mail", &bEncrypt);
+
+  MSG_CompositionFields *fields =
+      MSG_CreateCompositionFields(real_addr, real_addr, NULL, 
+                  "", "",
+									"", "", "",
+									"", "", "",
+									"", "", "",
+									"", 
+                  bEncrypt,
+                  bSign);
+  if (!fields)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  // RICHIE - INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(pOldContext);
+  // int16 win_csid = INTL_GetCSIWinCSID(csi);
+
+  pDocument = (CGenericDoc*)theApp.m_TextComposeTemplate->OpenDocumentFile(NULL, NULL, /*RICHIE win_csid,*/ TRUE);
+  if ( !pDocument )
+  {
+    // cleanup fields object
+    MSG_DestroyCompositionFields(fields);
+    return(MAPI_E_FAILURE);
+  }
+
+  CWinCX * pContext = (CWinCX*) pDocument->GetContext();
+  if ( !pContext ) 
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  MSG_CompositionPaneCallbacks Callbacks;
+  Callbacks.CreateRecipientsDialog = CreateRecipientsDialog;
+  Callbacks.CreateAskHTMLDialog = CreateAskHTMLDialog;
+
+  MWContext *context = pContext->GetContext();
+  CComposeFrame *pCompose = (CComposeFrame *) pContext->GetFrame()->GetFrameWnd();
+  pCompose->SetComposeStuff(context,fields); // squirl away stuff for post-create
+
+  // This needs to be set TRUE if using the old non-HTML text frame
+  // to prevent dropping dragged URLs
+  pContext->m_bDragging = !pCompose->UseHtml();
+  if (!pCompose->UseHtml()) 
+  {
+    pCompose->SetMsgPane(MSG_CreateCompositionPane(
+      pContext->GetContext(), 
+      context,
+      g_MsgPrefs.m_pMsgPrefs, fields,
+      WFE_MSGGetMaster()));
+  }
+
+  ASSERT(pCompose->GetMsgPane());
+  MSG_SetFEData(pCompose->GetMsgPane(),(void *)pCompose);
+
+  pCompose->UpdateAttachmentInfo();
+
+  // Pass doccsid info to new context for MailToWin conversion
+  /***
+  doccsid = INTL_GetCSIDocCSID(LO_GetDocumentCharacterSetInfo(pOldContext));
+
+  INTL_SetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context), 
+    (doccsid ? doccsid : INTL_DefaultDocCharSetID(pOldContext)));
+  ****/
+
+  pCompose->DisplayHeaders(NULL);
+
+  CComposeBar * pBar = pCompose->GetComposeBar();
+  ASSERT(pBar);
+  LPADDRESSCONTROL pIAddressList = pBar->GetAddressWidgetInterface();
+
+  if (!pIAddressList->IsCreated()) 
+  {
+    pBar->CreateAddressingBlock();
+  }
+
+  // Always do plain text composition!
+  pCompose->CompleteComposeInitialization();
+
+  //
+  // Finally deal with the attachments...
+  //
+  NSstringSeq     mailInfoSeq = (NSstringSeq) &(sendDocPtr->dataBuf[0]);
+  DWORD           stringCount = 0;
+  DWORD           i;
+
+  TRACE("MAPI: ProcessMAPISendDocuments() # of Attachments = [%d]\n", sendDocPtr->nFileCount);
+
+  if (sendDocPtr->nFileCount > 0)
+  {
+      MSG_AttachmentData *pAttach = (MSG_AttachmentData *)
+                    XP_CALLOC((sendDocPtr->nFileCount + 1),
+                    sizeof(MSG_AttachmentData));
+      if (!pAttach)
+      {
+        return(MAPI_E_INSUFFICIENT_MEMORY);
+      }
+
+      memset(pAttach, 0, (sendDocPtr->nFileCount + 1) * 
+                                  sizeof(MSG_AttachmentData));
+      for (i=0; i<sendDocPtr->nFileCount; i++)
+      {
+        CString cs;
+        // Create URL from filename...
+        WFE_ConvertFile2Url(cs, 
+            (const char *)NSStrSeqGet(mailInfoSeq, stringCount++));
+        pAttach[i].url = XP_STRDUP(cs);
+
+        // Now also include the "display" name...
+        StrAllocCopy(pAttach[i].real_name, NSStrSeqGet(mailInfoSeq, stringCount++));
+      }
+
+      // Set the list!
+      MSG_SetAttachmentList(pCompose->GetMsgPane(), pAttach);
+
+      // Now free everything...
+      for (i=0; i<sendDocPtr->nFileCount; i++)
+      {
+        if (pAttach[i].url)
+          XP_FREE(pAttach[i].url);
+
+        if (pAttach[i].real_name)
+          XP_FREE(pAttach[i].real_name);
+      }
+
+      XP_FREE(pAttach);
+  }
+    
+  // 
+  // Now some checking for ... well I'm not sure...
+  //
+  if (MSG_GetAttachmentList(pCompose->GetMsgPane()))
+    pCompose->SetModified(TRUE);
+  else
+    pCompose->SetModified(FALSE);
+
+  // Post message to compose window to set the initial focus.
+  pCompose->PostMessage(WM_COMP_SET_INITIAL_FOCUS);
+
+  //
+  // Now, just popup the window...
+  //
+  pCompose->ShowWindow(TRUE);
+
+  // return pCompose->GetMsgPane(); rhp - used to return the MsgPane
+  return(SUCCESS_SUCCESS);
+}
+
+static void _GetMailCallback(HWND hwnd, MSG_Pane *pane, void *closure)
+{
+   if (pane != NULL)
+   {
+     ShowWindow(hwnd, SW_HIDE);
+     MSG_Command( pane, MSG_GetNewMail, NULL, 0 );
+   }
+}
+
+static void _GetMailDoneCallback(HWND hwnd, MSG_Pane *pane, void *closure)
+{
+	for(CGenericFrame * f = theApp.m_pFrameList; f; f = f->m_pNext)
+		f->PostMessage(WM_COMMAND, (WPARAM) ID_DONEGETTINGMAIL, (LPARAM) 0);
+}
+
+//
+// This will fire off a "get mail in background operation" in an
+// async. fashion.
+//
+extern "C" void
+MAPIGetNewMessagesInBackground(void)
+{
+CGenericFrame     *pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
+
+  // rhp - we should not hit the net if we are offline!
+  if (NET_IsOffline())
+    return;
+
+  if (!pFrame)
+    return;
+
+  MWContext *pOldContext = GetUsableContext();
+  if (!pOldContext)
+    return;
+
+  TRACE("MAPI: DOWNLOAD MAIL IN BACKGROUND\n");
+  new CProgressDialog(
+                pFrame->GetFrameWnd(), 
+                NULL, 
+                _GetMailCallback, NULL, NULL, 
+                _GetMailDoneCallback);
+}
+
+//
+// This function will save a message into the Communicator "Drafts"
+// folder with no UI showing.
+//
+// Return: appropriate MAPI return code...
+//
+//
+extern "C" LONG 
+DoMAPISaveMailOperation(MAPISendMailType      *sendMailPtr,
+											  const char            *pInitialText)
+{
+CGenericDoc             *pDocument;
+LPSTR                   subject;
+NSstringSeq             mailInfoSeq;
+DWORD                   stringCount = 6;
+DWORD                   i;
+BOOL                    winShowFlag = FALSE;
+
+  // Get a context to use for this call...
+  MWContext *pOldContext = GetUsableContext();
+  if (!pOldContext)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  // Don't allow a compose window to be created if the user hasn't 
+  // specified an email address
+  const char *real_addr = FE_UsersMailAddress();
+  if (MISC_ValidateReturnAddress(pOldContext, real_addr) < 0)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  //
+  // Now, we must build the fields object...
+  //
+  mailInfoSeq = (NSstringSeq) &(sendMailPtr->dataBuf[0]);
+  subject = NSStrSeqGet(mailInfoSeq, 0);
+
+  TRACE("MAPI: ProcessMAPISendMail() Subject   = [%s]\n", subject);
+  TRACE("MAPI: ProcessMAPISendMail() Text Size = [%d]\n", strlen((const char *)pInitialText));
+  TRACE("MAPI: ProcessMAPISendMail() # of Recipients  = [%d]\n", sendMailPtr->MSG_nRecipCount);
+
+
+  char  toString[1024] = "";
+  char  ccString[1024] = "";
+  char  bccString[1024] = "";
+
+  for (i=0; i<sendMailPtr->MSG_nRecipCount; i++)
+  {
+    LPSTR   ptr;
+    UCHAR   tempString[256];
+
+    ULONG addrType = atoi(NSStrSeqGet(mailInfoSeq, stringCount++));
+
+    // figure which type of address this is?
+    if (addrType == MAPI_CC)
+      ptr = ccString;
+    else if (addrType == MAPI_BCC)
+      ptr = bccString;
+    else
+      ptr = toString;
+
+    LPSTR namePtr = (LPSTR) NSStrSeqGet(mailInfoSeq, stringCount++);
+    LPSTR emailPtr = (LPSTR) NSStrSeqGet(mailInfoSeq, stringCount++);
+
+    if ( (!emailPtr) && (!namePtr))
+    {
+      return(MAPI_E_INVALID_RECIPS);
+    }
+
+    if (!emailPtr)
+      emailPtr = namePtr;
+
+    char *tptr = strchr(emailPtr, ':');
+    if (tptr != NULL)
+    {
+      if ( (*tptr != '\0') && (*(tptr+1) != '\0') )
+      {
+        emailPtr = (tptr + 1);
+      }
+    }
+/**
+    if ( (lstrlen(emailPtr) > 5) && (*(emailPtr + 4) == ':') )
+    {
+      emailPtr += 5;
+    }
+**/
+    // Now build the temp string to tack on in the format
+    // "Rich Pizzarro" <rhp@netscape.com>
+    wsprintf((LPSTR) tempString, "\"%s\" <%s>", namePtr, emailPtr);
+
+    // add a comma if not the first one
+    if (ptr[0] != '\0')
+      lstrcat(ptr, ",");
+
+    // tack on string!
+    lstrcat(ptr, (LPSTR) tempString);
+  }
+
+  BOOL    bEncrypt = FALSE;
+  BOOL    bSign    = FALSE;
+
+  PREF_GetBoolPref("mail.crypto_sign_outgoing_mail", &bSign);
+  PREF_GetBoolPref("mail.encrypt_outgoing_mail", &bEncrypt);
+  MSG_CompositionFields *fields =
+      MSG_CreateCompositionFields(real_addr, real_addr, 
+                  toString, 
+                  ccString, 
+                  bccString,
+									"", "", "",
+									"", subject, "",
+									"", "", "",
+									"", 
+                  bEncrypt,
+                  bSign);
+  if (!fields)
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  // RICHIE
+  // INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(pOldContext);
+  // int16 win_csid = INTL_GetCSIWinCSID(csi);
+  
+  pDocument = (CGenericDoc*)theApp.m_TextComposeTemplate->OpenDocumentFile(NULL, NULL, /*win_csid RICHIE*/ winShowFlag);
+  if ( !pDocument )
+  {
+    return(MAPI_E_FAILURE);
+  }
+  
+  CWinCX * pContext = (CWinCX*) pDocument->GetContext();
+  if ( !pContext ) 
+  {
+    return(MAPI_E_FAILURE);
+  }
+
+  MSG_CompositionPaneCallbacks Callbacks;
+  Callbacks.CreateRecipientsDialog = CreateRecipientsDialog;
+  Callbacks.CreateAskHTMLDialog = CreateAskHTMLDialog;
+
+  int16 doccsid;
+  MWContext *context = pContext->GetContext();
+  CComposeFrame *pCompose = (CComposeFrame *) pContext->GetFrame()->GetFrameWnd();
+
+  pCompose->SetComposeStuff(context, fields); // squirl away stuff for post-create
+
+  // This needs to be set TRUE if using the old non-HTML text frame
+  // to prevent dropping dragged URLs
+  pContext->m_bDragging = !pCompose->UseHtml();
+  if (!pCompose->UseHtml()) 
+  {
+    pCompose->SetMsgPane(
+      MSG_CreateCompositionPane(pContext->GetContext(), 
+                                context, 
+                                g_MsgPrefs.m_pMsgPrefs, 
+                                fields,
+                                WFE_MSGGetMaster())
+                        );
+  }
+
+  ASSERT(pCompose->GetMsgPane());
+  MSG_SetFEData(pCompose->GetMsgPane(),(void *)pCompose);  
+  pCompose->UpdateAttachmentInfo();
+
+  // Pass doccsid info to new context for MailToWin conversion
+  doccsid = INTL_GetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context));
+  INTL_SetCSIDocCSID(LO_GetDocumentCharacterSetInfo(context), 
+    (doccsid ? doccsid : INTL_DefaultDocCharSetID(context)));
+
+  pCompose->DisplayHeaders(NULL);
+
+  CComposeBar * pBar = pCompose->GetComposeBar();
+  ASSERT(pBar);
+  LPADDRESSCONTROL pIAddressList = pBar->GetAddressWidgetInterface();
+
+  if (!pIAddressList->IsCreated()) 
+  {
+    pBar->CreateAddressingBlock();
+  }
+
+  // rhp - Deal with addressing the brute force way! This is a 
+  // "fix" for bad behavior when creating these windows and not
+  // showing them on the desktop.
+  if (!winShowFlag)      // Hack to fix the window not being mapped
+  {
+    pCompose->AppendAddress(MSG_TO_HEADER_MASK, "");
+    pCompose->AppendAddress(MSG_CC_HEADER_MASK, "");
+    pCompose->AppendAddress(MSG_BCC_HEADER_MASK, "");
+  }
+
+  // Always do plain text composition!
+  pCompose->CompleteComposeInitialization();
+
+  // Do this so we don't get popups on "empty" messages
+  if ( (!pInitialText) || (!(*pInitialText)) )
+    pInitialText = " ";
+
+  const char * pBody = pInitialText ? pInitialText : MSG_GetCompBody(pCompose->GetMsgPane());
+  if (pBody)
+  {
+    FE_InsertMessageCompositionText(context,pBody,TRUE);
+  }
+
+  // 
+  // Now set the message as being edited!    
+  //
+  pCompose->SetModified(TRUE);
+
+  //
+  // Finally deal with the attachments...
+  //
+  if (sendMailPtr->MSG_nFileCount > 0)
+  {
+    // Send this puppy when done with the attachments...
+    if (!winShowFlag)
+    {
+      pCompose->SetMAPISendMode(MAPI_SAVE);
+    }
+
+    MSG_AttachmentData *pAttach = (MSG_AttachmentData *)
+                  XP_CALLOC((sendMailPtr->MSG_nFileCount + 1),
+                  sizeof(MSG_AttachmentData));
+    if (!pAttach)
+    {
+      return(MAPI_E_INSUFFICIENT_MEMORY);
+    }
+
+    memset(pAttach, 0, (sendMailPtr->MSG_nFileCount + 1) * 
+                                sizeof(MSG_AttachmentData));
+    for (i=0; i<sendMailPtr->MSG_nFileCount; i++)
+    {
+      CString cs;
+      // Create URL from filename...
+      WFE_ConvertFile2Url(cs, 
+          (const char *)NSStrSeqGet(mailInfoSeq, stringCount++));
+      pAttach[i].url = XP_STRDUP(cs);
+
+      // Now also include the "display" name...
+      StrAllocCopy(pAttach[i].real_name, NSStrSeqGet(mailInfoSeq, stringCount++));
+    }
+
+    // Set the list!
+    MSG_SetAttachmentList(pCompose->GetMsgPane(), pAttach);
+
+    // Now free everything...
+    for (i=0; i<sendMailPtr->MSG_nFileCount; i++)
+    {
+      if (pAttach[i].url)
+        XP_FREE(pAttach[i].url);
+
+      if (pAttach[i].real_name)
+        XP_FREE(pAttach[i].real_name);
+    }
+
+    XP_FREE(pAttach);
+  }
+
+  //
+  // Now, if we were supposed to do the blind send...do it, otherwise,
+  // just popup the window...
+  //
+  if (winShowFlag)      
+  {
+    // Post message to compose window to set the initial focus.
+    pCompose->PostMessage(WM_COMP_SET_INITIAL_FOCUS);
+  }
+  else if (sendMailPtr->MSG_nFileCount <= 0)  // Send NOW if no attachments!
+  {
+    pCompose->PostMessage(WM_COMMAND, IDM_SAVEASDRAFT);
+  }
+
+  return(SUCCESS_SUCCESS);
+}

mailnews/mapi/hook/mapimail.h

@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef _MAPI_MAIL_H_
+#define _MAPI_MAIL_H_
+
+#include "nscpmapi.h"
+#include <structs.h>    // for MWContext
+
+//extern "C" {
+
+//
+// This function will create a composition window and either do
+// a blind send or pop up the compose window for the user to 
+// complete the operation
+//
+// Return: appropriate MAPI return code...
+//
+//
+extern "C" LONG
+DoFullMAPIMailOperation(MAPISendMailType      *sendMailPtr,
+											  const char            *pInitialText,
+                        BOOL                  winShowFlag);
+
+//
+// This function will create a composition window and just attach
+// the attachments of interest and pop up the window...
+//
+// Return: appropriate MAPI return code...
+//
+//
+extern "C" LONG
+DoPartialMAPIMailOperation(MAPISendDocumentsType *sendDocPtr);
+
+//
+// This function will save a message into the Communicator "Drafts"
+// folder with no UI showing.
+//
+// Return: appropriate MAPI return code...
+//
+//
+extern "C" LONG 
+DoMAPISaveMailOperation(MAPISendMailType      *sendMailPtr,
+											  const char            *pInitialText);
+
+//
+// This will fire off a "get mail in background operation" in an
+// async. fashion.
+//
+extern "C" void
+MAPIGetNewMessagesInBackground(void);
+
+
+// } // extern "C"
+
+#endif // _MAPI_MAIL_H_

mailnews/mapi/lib/Makefile.win

@@ -0,0 +1,46 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..\..
+MODULE=mapiutils
+
+include <$(DEPTH)\config\config.mak>
+
+################################################################################
+## exports
+
+EXPORTS=	mapismem.h	\
+    		nsstrseq.h	\
+			$(NULL)
+
+################################################################################
+## library
+
+LIBRARY_NAME=mapiutils_s
+
+
+CPP_OBJS=   .\$(OBJDIR)\mapismem.obj		\
+			.\$(OBJDIR)\nsstrseq.obj		\
+			$(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+
+libs:: $(LIBRARY)
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
+clobber::
+	rm -f $(DIST)\lib\$(LIBRARY_NAME).lib

mailnews/mapi/lib/mapismem.cpp

@@ -0,0 +1,154 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  smem.cpp - This deals with all shared memory functions needed for 
+//  the MAPI component of Communicator
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include <windows.h>
+#include <windowsx.h>
+
+#include "mapismem.h"
+
+
+#ifndef ZeroMemory
+#include <memory.h>
+#define ZeroMemory(PTR, SIZE) memset(PTR, 0, SIZE)
+#endif // ZeroMemory
+
+// 
+// *create new* shared memory chunk 
+// once this is created, use the pointer
+// to the segment to to store data 
+// e.g.: 
+//     lpString = "string for communicator"; 
+//     lstrcpy((LPSTR)pData->m_buf[0], lpString); 
+//  
+CSharedMem *
+NSCreateSharedMemory(DWORD memSize, LPCTSTR memName, HANDLE *hSharedMemory)
+{
+#ifdef WIN32
+
+  BOOL bExistedBefore;
+  CSharedMem *pData;
+
+  LPCTSTR szObjectName = memName; 
+  DWORD dwSize = sizeof(CSharedMem) + memSize; 
+  *hSharedMemory = CreateFileMapping( 
+    (HANDLE)0xFFFFFFFF,0,PAGE_READWRITE,0,dwSize,szObjectName); 
+  if(*hSharedMemory == 0) 
+  { 
+    return NULL; 
+  } 
+  bExistedBefore = (GetLastError() == ERROR_ALREADY_EXISTS); 
+  if(bExistedBefore) 
+  { 
+  	return NULL;
+  } 
+
+  pData = (CSharedMem *)MapViewOfFile( 
+            *hSharedMemory, FILE_MAP_ALL_ACCESS, 0, 0, 0); 
+  if(pData == NULL) 
+  { 
+    return NULL; 
+  } 
+
+  ZeroMemory(pData, dwSize); 
+  pData->m_dwSize = memSize; 
+
+  return pData;
+#else
+  CSharedMem 	*sMemChunk = NULL;
+  DWORD dwSize = memSize = (sizeof(CSharedMem) + memSize); 
+
+  if (sMemChunk != NULL)
+	  return(sMemChunk);
+
+  sMemChunk = (CSharedMem *) GlobalAllocPtr(GMEM_MOVEABLE, dwSize);
+  ZeroMemory(sMemChunk, (size_t) dwSize);
+  sMemChunk->m_dwSize = dwSize;   // Missing in Communicator code!
+  return(sMemChunk);
+
+#endif // WIN32
+}
+
+// 
+// *open existing* shared memory chunk 
+// once you have the pointer to the new segment 
+// use this pointer to access data, e.g.: 
+// 
+CSharedMem *
+NSOpenExistingSharedMemory(LPCTSTR memName, HANDLE *hSharedMemory)
+{
+#ifdef WIN32
+  CSharedMem *pData;
+  DWORD dwSize;
+
+  LPCTSTR szObjectName = memName; 
+  *hSharedMemory = OpenFileMapping( 
+    FILE_MAP_WRITE,FALSE,szObjectName); 
+  if(*hSharedMemory == 0) 
+  { 
+    return NULL; 
+  } 
+
+  pData = (CSharedMem *)MapViewOfFile( 
+              *hSharedMemory,FILE_MAP_ALL_ACCESS,0,0,0); 
+  if(pData == NULL) 
+  { 
+    return NULL; 
+  } 
+  
+  dwSize = pData->m_dwSize; 
+  return pData;
+#else
+
+  return(NULL);   // In Win16, this is really meaningless...
+
+#endif
+}  
+
+// 
+// to close shared memory segment
+// 
+void
+NSCloseSharedMemory(CSharedMem *pData, HANDLE hSharedMemory)
+{
+#ifdef WIN32
+  if(pData != 0) 
+  { 
+    UnmapViewOfFile(pData); 
+    pData = 0; 
+  } 
+
+  if(hSharedMemory != 0) 
+  { 
+    CloseHandle(hSharedMemory); 
+    hSharedMemory = 0; 
+  } 
+#else
+
+	if (pData != NULL)
+	{
+		GlobalFreePtr(pData);
+		pData = NULL;
+	}
+
+#endif // WIN32
+}

mailnews/mapi/lib/mapismem.h

@@ -0,0 +1,97 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef __SMEM_HPP__
+#define __SMEM_HPP__
+
+//
+// Need this for Win16 since it is an undocumented message
+//
+#ifndef WIN32
+
+#define WM_COPYDATA                     0x004A
+
+/*
+ * lParam of WM_COPYDATA message points to...
+ */
+typedef struct tagCOPYDATASTRUCT {
+    DWORD         dwData;
+    DWORD         cbData;
+    LPVOID        lpData;
+} COPYDATASTRUCT, *PCOPYDATASTRUCT;
+
+# ifndef LPCTSTR
+#   define LPCTSTR LPCSTR
+# endif
+
+
+#endif // ifndef WIN32
+
+// The following structure will be stored in the shared memory 
+// and will be used to pass data back and forth 
+
+#pragma pack(4) 
+
+typedef struct  
+{ 
+  DWORD m_dwSize;       // size of the shared memory block 
+  BYTE  m_buf[1];       // this is the buffer of memory to be used
+} CSharedMem; 
+
+#pragma pack(4) 
+
+// ******************************************************
+// Public routines...
+// ******************************************************
+// 
+// 
+// *create new* shared memory chunk 
+// once this is created, use the pointer
+// to the segment to to store data 
+// e.g.: 
+//     lpString = "string for communicator"; 
+//     lstrcpy((LPSTR)pData->m_buf[0], lpString); 
+//     pData->m_dwBytesUsed = lstrlen(lpString) + 1; // count '\0' 
+//  
+CSharedMem *
+NSCreateSharedMemory(DWORD memSize, LPCTSTR memName, HANDLE *hSharedMemory);
+
+// 
+// *open existing* shared memory chunk 
+// once you have the pointer to the new segment 
+// use this pointer to access data, e.g.: 
+//
+// This will return the pointer to the memory chunk as well as
+// fill out the hSharedMemory argument that is needed for subsequent
+// operations.
+// 
+//  if(pData->m_dwBytesUsed > 0) 
+//  { 
+//    // use pData->m_buf here 
+//  } 
+//
+CSharedMem *
+NSOpenExistingSharedMemory(LPCTSTR memName, HANDLE *hSharedMemory);
+
+//
+// You must pass in the pointer to the memory chunk as well as
+// the hSharedMemory HANDLE to close shared memory segment
+// 
+void
+NSCloseSharedMemory(CSharedMem *pData, HANDLE hSharedMemory);
+
+#endif  // __SMEM_HPP__

mailnews/mapi/lib/nsstrseq.cpp

@@ -0,0 +1,211 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  This is a string sequence handling routine to take complex
+//  structures and merge them into a chunk of memory.
+//
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include <string.h>
+#include <stdlib.h>
+#include <windows.h>
+#include <windowsx.h>
+
+#include "nsstrseq.h"
+
+#ifndef NULL
+#define NULL '\0'
+#endif
+
+#define MARKER '\377'
+
+//
+// Delete an existing string sequence
+//
+void NSStrSeqDelete(NSstringSeq seq)
+{
+  if (seq != NULL)
+    free(seq);
+  
+  seq = NULL;
+}
+
+//
+// Allocate a new sequence, copying the given strings into it. 
+//
+NSstringSeq NSStrSeqNew(LPSTR strings[])
+{
+  int size;
+  if (!strings)
+  {
+    return NULL;
+  }
+  
+  {
+    int i;
+    for (i=0,size=0; strings[i]; i++)
+    {
+      size+=strlen(strings[i])+1;
+      switch (strings[i][0])
+      {
+        // Need to pad "" or anything starting with 255 
+        // to allow for multiple blank strings in a row
+      case 0:
+      case MARKER:
+        size++;
+        break;
+        
+      default:
+        break;
+      }
+    }
+  }
+  
+  {
+    NSstringSeq s=(NSstringSeq)malloc(size+1);
+    if (!s)
+    {	return NULL;}
+    
+    {
+      int i,offset;
+      for (i=0,offset=0; strings[i]; i++)
+      {
+        switch (strings[i][0])
+        {
+          // Need to pad "" or anything starting with 255
+        case 0:
+        case MARKER:
+          s[offset++]=MARKER;
+          break;
+          
+        default:
+          break;
+        }
+        strcpy(s+offset,strings[i]);
+        offset+=strlen(strings[i])+1;
+      }
+      s[offset]=0;
+    }
+    
+    return s;
+  }
+}
+
+//
+// Get the # of bytes required for the sequence 
+//
+LONG NSStrSeqSize(NSstringSeq seq)
+{
+  const char* s;
+  if (!seq)
+    {
+      return -1;
+    }
+
+  for (s=seq+1; ((*s) || (*(s-1))); s++)
+    ;
+
+  // At this point, s points to the second 0 
+  // of the double 0 at the end 
+  return (s-seq)+1;
+}
+
+//
+// Get the # of strings in the sequence 
+//
+LONG NSStrSeqNumStrs(NSstringSeq seq)
+{
+  const char* s;
+  int N;
+  if (!seq)
+  {
+    return -1;
+  }
+  
+  for (s=seq+1,N=0; ((*s) || (*(s-1))); s++)
+  {
+    if (!(*s))
+      N++;
+  }
+  
+  return N;
+}
+
+static LPSTR correct(LPSTR s)
+{
+  if (s[0]==MARKER)
+    return s+1;
+  else  // Anup , 4/96
+    return s;
+}
+
+//
+// Extract the index'th string in the sequence
+//
+LPSTR NSStrSeqGet(NSstringSeq seq, LONG index)
+{
+  char* s;
+  int N;
+
+  if (!seq)
+  {
+    return NULL;
+  }
+  
+  if (index<0)
+  {
+    return NULL;
+  }
+  
+  if (!index)
+    return correct(seq);
+  
+  for (s=seq+1,N=0; ((*s) || (*(s-1))) && (N<index); s++)
+  {
+    if (!(*s))
+      N++;
+  }
+  
+  if (N==index)
+    return correct(s);
+  
+  return NULL;
+}
+
+LPSTR * NSStrSeqGetAll(NSstringSeq seq)
+{
+  LONG N=NSStrSeqNumStrs(seq);
+  if (N<0)
+    return NULL;
+  
+  {
+    char** res=(char**)malloc( (size_t) ((N+1)*sizeof(char*)) );
+    int i;
+    
+    if (!res)
+    {
+      return NULL;
+    }
+    for (i=0; i<N; i++)
+      res[i]=NSStrSeqGet(seq,i);
+    res[N]=NULL;
+    
+    return res;
+  }
+}

mailnews/mapi/lib/nsstrseq.h

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef __SEQUENCES_OF_STRINGS_H_
+#define __SEQUENCES_OF_STRINGS_H	
+
+
+typedef LPSTR NSstringSeq;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+void NSStrSeqDelete(NSstringSeq seq);
+NSstringSeq NSStrSeqNew(LPSTR strings[]);
+
+// Get the # of bytes required for the sequence 
+LONG NSStrSeqSize(NSstringSeq seq);
+
+// Get the # of strings in the sequence
+LONG NSStrSeqNumStrs(NSstringSeq seq);
+
+// Extract the index'th string in the sequence
+LPSTR NSStrSeqGet(NSstringSeq seq, LONG index);
+
+// Build an array of all the strings in the sequence
+LPSTR *NSStrSeqGetAll(NSstringSeq seq);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // __sequences_of_strings_h_

mailnews/mapi/makefile.win

@@ -0,0 +1,22 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..
+
+DIRS=public lib mapi32 tests hook
+
+include <$(DEPTH)\config\rules.mak>

mailnews/mapi/mapi32/maindll.cpp

@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  DLLMain to get a handle on an hInstance 
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+#include <windows.h>
+
+//  
+// global variables
+//
+HINSTANCE hInstance;
+
+//
+// DLL entry
+//  
+#ifdef WIN32
+/****************************************************************************
+   FUNCTION: DllMain(HANDLE, DWORD, LPVOID)
+
+   PURPOSE:  DllMain is called by Windows when
+             the DLL is initialized, Thread Attached, and other times.
+             Refer to SDK documentation, as to the different ways this
+             may be called.
+             
+             The DllMain function should perform additional initialization
+             tasks required by the DLL.  In this example, no initialization
+             tasks are required.  DllMain should return a value of 1 if
+             the initialization is successful.
+           
+*******************************************************************************/
+BOOL APIENTRY DllMain(HANDLE hInstLocal, DWORD ul_reason_being_called, LPVOID lpReserved) 
+{
+  hInstance = (HINSTANCE)hInstLocal;
+
+  if (hInstance != NULL) 
+	  return 1;
+  else  
+	  return 0;
+}
+
+#else  // WIN16
+
+
+//--------------------------------------------------------------------
+// LibMain( hInstance, wDataSegment, wHeapSize, lpszCmdLine ) : WORD
+//
+//    hInstance      library instance handle
+//    wDataSegment   library data segment
+//    wHeapSize      default heap size
+//    lpszCmdLine    command line arguments
+//
+//--------------------------------------------------------------------
+
+int CALLBACK LibMain(HINSTANCE hInstLocal, WORD wDataSegment, WORD wHeapSize, LPSTR lpszCmdLine) 
+{
+  hInstance = hInstLocal;
+  /* return result 1 = success; 0 = fail */
+  if (hInstance != NULL) 
+	  return 1;
+  else
+	  return 0;
+}
+
+#endif // WIN16
+

mailnews/mapi/mapi32/makefile.win

@@ -0,0 +1,56 @@
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+DEPTH=..\..\..
+MODULE=mapi32
+
+################################################################################
+## exports
+
+#EXPORTS =
+
+
+################################################################################
+## library
+
+LIBNAME = .\$(OBJDIR)\mapi32
+DLL = $(LIBNAME).dll
+DEFINES= -NS_DEBUG
+DEFFILE=MAPI32.def
+
+OBJS=										\
+    .\$(OBJDIR)\maindll.obj  \
+    .\$(OBJDIR)\mapi32.obj  \
+    .\$(OBJDIR)\mapiipc.obj  \
+    .\$(OBJDIR)\mapimem.obj  \
+    .\$(OBJDIR)\mapiutl.obj  \
+    .\$(OBJDIR)\smem.obj  \
+    .\$(OBJDIR)\trace.obj  \
+    .\$(OBJDIR)\xpapi.obj  \
+		$(NULL)
+
+LLIBS=										\
+			$(LLIBS)						\
+			$(LIBNSPR)						\
+			$(DIST)\lib\xppref32.lib		\
+			$(DIST)\lib\xpcom.lib       	\
+			$(DIST)\lib\mapiutils_s.lib  \
+			$(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(DLL)
+	$(MAKE_INSTALL)  $(LIBNAME).$(DLL_SUFFIX) $(DIST)\bin\components

mailnews/mapi/mapi32/mapiipc.cpp

@@ -0,0 +1,230 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  MAPI IPC Routines
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include <windows.h>
+#include <windowsx.h>
+#include <nscpmapi.h>   // Should live in Communicator
+
+#include "resource.h"
+#include "mapiipc.h"
+#include "mapismem.h"
+#include "trace.h"
+
+#ifndef WIN32
+#include <string.h>
+#endif 
+
+//
+// Necessary variables...
+//
+static LONG       instanceCount = 0;
+HWND				      hWndMAPI = NULL;
+char				      szClassName[] = "NetscapeMAPIClient";
+char              szWindowName[] = "NetscapeMAPI";
+
+//
+// External declares...
+//
+extern HINSTANCE  hInstance;
+
+void 
+ProcessCommand(HWND hWnd, int id, HWND hCtl, UINT codeNotify) 
+{ 
+	switch (id) 
+	{
+	case IDOK:   
+	case IDCANCEL:
+		{
+			ShowWindow(hWnd, SW_HIDE);
+		}
+		
+	default:
+		;
+	}
+}
+
+BOOL CALLBACK LOADDS 
+MyDlgProc(HWND hWndMain, UINT wMsg, WPARAM wParam, LPARAM lParam) 
+{
+  switch (wMsg) 
+  {
+  case WM_INITDIALOG: 
+    {
+      hWndMAPI = hWndMain;
+    }
+    break;
+    
+  case WM_CLOSE:
+//    DestroyWindow(hWndMain);
+    break;
+    
+  case WM_DESTROY:
+    hWndMain = NULL;
+    break;
+
+  case WM_COMMAND:
+	  HANDLE_WM_COMMAND(hWndMAPI, wParam, lParam, ProcessCommand);
+    break;
+
+  default:
+    return FALSE;
+  }
+
+  return TRUE;
+}
+
+BOOL 
+InitInstance(HINSTANCE hInstance)
+{
+  //
+  // Create a main window for this application instance.  
+  //
+  /* RICHIE - TRY SOME CHANGES!!!
+  hWndMAPI = CreateDialog((HINSTANCE) hInstance, 
+        MAKEINTRESOURCE(ID_DIALOG_QAHOOK),
+        (HWND) NULL, (DLGPROC) MyDlgProc);
+   ******/
+  hWndMAPI = CreateWindow(
+              szClassName,	// pointer to registered class name
+              szWindowName,	// pointer to window name
+              WS_CHILD,	    // window style
+              -10,          	// horizontal position of window
+              -10,	          // vertical position of window
+              1,	          // window width
+              1,	          // window height
+              GetDesktopWindow(),	// handle to parent or owner window
+              NULL,	        // handle to menu or child-window identifier
+              hInstance,	  // handle to application instance
+              NULL          // pointer to window-creation data
+              );
+  if (!hWndMAPI)
+    return FALSE;
+  else
+    return TRUE;
+}
+
+BOOL 
+InitApp(void)
+{
+#ifdef WIN32
+  WNDCLASS wc;
+  wc.style         = 0; 
+  wc.lpfnWndProc   = DefDlgProc; 
+  wc.cbClsExtra    = 0; 
+  wc.cbWndExtra    = DLGWINDOWEXTRA; 
+  wc.hInstance     = hInstance; 
+  wc.hIcon         = LoadIcon(hInstance, MAKEINTRESOURCE(ID_ICON_APP)); 
+  wc.hCursor       = LoadCursor(0, IDC_ARROW); 
+  wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
+  wc.lpszMenuName  = NULL; 
+  wc.lpszClassName = szClassName;
+  
+  if(!RegisterClass(&wc))
+    return FALSE;
+#endif
+  
+  return TRUE;
+} // end InitApp
+
+BOOL
+InitDLL(void)
+{
+  if (hWndMAPI != NULL)
+    return TRUE;
+
+  if (!InitApp()) 
+  { 
+    return FALSE;
+  }
+  
+  if (!InitInstance(hInstance)) 
+  {    
+    return FALSE;
+  }
+  
+//  ShowWindow(hWndMAPI, SW_SHOW);    Just for jollies
+  return(TRUE);
+}
+
+//*************************************************************
+//* Calls exposed for rest of DLL...
+//*************************************************************
+//
+// Purpose: Open the API
+// Return: 1 on success
+//         0 on failure
+//
+DWORD nsMAPI_OpenAPI(void)
+{
+  if (instanceCount > 0)
+  {
+    return(1);
+  }
+
+  ++instanceCount;
+  return(1);
+}
+
+//
+// Purpose: Close the API
+//
+void nsMAPI_CloseAPI(void)
+{
+  --instanceCount;
+  if (instanceCount <= 0)
+  {
+    instanceCount = 0;
+  }
+
+  return;
+}
+
+//
+// Send the actual request to Communicator
+//
+LRESULT
+SendMAPIRequest(HWND hWnd, 
+                DWORD mapiRequestID, 
+                MAPIIPCType *ipcInfo)
+{
+LRESULT         returnVal = 0;
+COPYDATASTRUCT  cds;
+
+  if (!InitDLL())
+  {
+    return 0;
+  }
+
+  cds.dwData = mapiRequestID;
+  cds.cbData = sizeof(MAPIIPCType);
+  cds.lpData = ipcInfo;
+
+  // Make the call into Communicator
+  returnVal = SendMessage(hWnd, WM_COPYDATA, (WPARAM) hWndMAPI, (LPARAM) &cds);
+
+  // Now kill the window...
+  DestroyWindow(hWndMAPI);
+  hWndMAPI = NULL;
+  UnregisterClass(szClassName, hInstance);
+  
+  return returnVal;
+}

mailnews/mapi/mapi32/mapiipc.h

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef __MAPIIPC_HPP__
+#define __MAPIIPC_HPP__
+
+#include "port.h"
+#include <nscpmapi.h>
+
+//********************************************************
+// Open and close functions for API
+//********************************************************
+// Open the API
+// Return: 1 on success, 0 on failure
+//
+DWORD nsMAPI_OpenAPI(void);
+
+//
+// Purpose: Close the API
+//
+void  nsMAPI_CloseAPI(void);
+
+//
+// Send the actual request to Communicator
+//
+LRESULT   SendMAPIRequest(HWND hWnd, 
+                DWORD mapiRequestID, 
+                MAPIIPCType *ipcInfo);
+
+#endif // __MAPIIPC_HPP__

mailnews/mapi/mapi32/mapimem.cpp

@@ -0,0 +1,344 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  mem.cpp
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//  This implements various memory management functions for use with
+//  MAPI features of Communicator
+//
+#include <windows.h>     
+#include <memory.h> 
+#include <malloc.h>
+#include "mapimem.h"
+#include <nscpmapi.h>   // lives in communicator winfe
+#include "nsstrseq.h"
+#include "trace.h"
+#include "mapiutl.h"
+#include "xpapi.h"
+
+LPSTR
+CheckNullString(LPSTR inStr)
+{
+  static UCHAR  str[1];
+
+  str[0] = '\0';
+  if (inStr == NULL)
+    return((LPSTR)str);
+  else
+    return(inStr);
+}
+
+void
+FreeMAPIFile(lpMapiFileDesc pv)
+{
+  if (!pv)
+    return;
+
+  if (pv->lpszPathName != NULL)   
+    free(pv->lpszPathName);
+
+  if (pv->lpszFileName != NULL)   
+    free(pv->lpszFileName);
+}
+
+void
+FreeMAPIMessage(lpMapiMessage pv)
+{
+  ULONG i;
+
+  if (!pv)
+    return;
+
+  if (pv->lpszSubject != NULL)
+    free(pv->lpszSubject);
+
+  if (pv->lpszNoteText)
+      free(pv->lpszNoteText);
+  
+  if (pv->lpszMessageType)
+    free(pv->lpszMessageType);
+  
+  if (pv->lpszDateReceived)
+    free(pv->lpszDateReceived);
+  
+  if (pv->lpszConversationID)
+    free(pv->lpszConversationID);
+  
+  if (pv->lpOriginator)
+    FreeMAPIRecipient(pv->lpOriginator);
+  
+  for (i=0; i<pv->nRecipCount; i++)
+  {
+    if (&(pv->lpRecips[i]) != NULL)
+    {
+      FreeMAPIRecipient(&(pv->lpRecips[i]));
+    }
+  }
+
+  if (pv->lpRecips != NULL)
+  {
+    free(pv->lpRecips);
+  }
+
+  for (i=0; i<pv->nFileCount; i++)
+  {
+    if (&(pv->lpFiles[i]) != NULL)
+    {
+      FreeMAPIFile(&(pv->lpFiles[i]));
+    }
+  }
+
+  if (pv->lpFiles != NULL)
+  {
+    free(pv->lpFiles);
+  }
+  
+  free(pv);
+  pv = NULL;
+}
+
+void
+FreeMAPIRecipient(lpMapiRecipDesc pv)
+{
+  if (!pv)
+    return;
+
+  if (pv->lpszName != NULL)   
+    free(pv->lpszName);
+
+  if (pv->lpszAddress != NULL)
+    free(pv->lpszAddress);
+
+  if (pv->lpEntryID != NULL)
+    free(pv->lpEntryID);  
+}
+
+//
+// This routine will take an lpMapiMessage structure and "flatten" it into
+// one contiguous chunk of memory that can be easily passed around. After this
+// is done, "extract" routines will be written to get complicated string routines
+// out of the chunk of memory at the end.
+// 
+LPVOID
+FlattenMAPIMessageStructure(lpMapiMessage msg, DWORD *totalSize)
+{
+  MAPISendMailType    *mailPtr;
+  LPSTR               *strArray;
+  DWORD               strCount = 0;
+  DWORD               currentString = 0;
+  DWORD               arrayBufSize = 0;
+  DWORD               i;
+
+  *totalSize = 0;
+  if (!msg)
+    return(NULL);
+
+  //
+  // Allocate the initial structure to hold all of the mail info.
+  //
+  *totalSize = sizeof(MAPISendMailType);
+  mailPtr = (MAPISendMailType *) malloc(sizeof(MAPISendMailType));
+  if (!mailPtr)
+    return(NULL);
+  memset(mailPtr, 0, sizeof(MAPISendMailType));
+
+  //
+  // First, assign all of the easy numeric values...
+  //
+  mailPtr->MSG_flFlags = msg->flFlags;          // unread,return receipt
+  mailPtr->MSG_nRecipCount = msg->nRecipCount;  // Number of recipients
+  mailPtr->MSG_nFileCount = msg->nFileCount;    // # of file attachments
+  if (msg->lpOriginator != NULL)
+  {
+    mailPtr->MSG_ORIG_ulRecipClass = msg->lpOriginator->ulRecipClass; //  Recipient class - MAPI_TO, MAPI_CC, MAPI_BCC, MAPI_ORIG
+  }
+
+  //
+  // Now, figure out how many string pointers we need...
+  //
+  strCount = 4;     // These are the 4 KNOWN strings up front for a message
+  strCount += 2;    // This is for the originator name and address
+
+  strCount += msg->nRecipCount * 3; // Name, address & class (cc, bcc) for each recipient
+  strCount += msg->nFileCount  * 2; // filename and display name for each attachment
+
+  // 
+  // Now allocate a new string sequence...add one entry for NULL at the end
+  //  
+  arrayBufSize = sizeof(LPSTR) * (strCount + 1);
+
+#ifdef WIN16    // Check for max mem allocation...
+  if ((sizeof(MAPISendMailType) + arrayBufSize) > 64000)
+  {
+    free(mailPtr);
+    return NULL;
+  }
+#endif
+
+  //
+  // Allocate a buffer for the string pointers and if this fails, 
+  // cleanup and return.
+  // 
+  strArray = (LPSTR *)malloc( (size_t) arrayBufSize);
+  if (!strArray)
+  {
+    free(mailPtr);
+    return NULL;
+  }
+
+  memset(strArray, 0, (size_t) arrayBufSize);  // Set the array to NULL
+  strArray[currentString++] = CheckNullString(msg->lpszSubject);        // Message Subject
+  strArray[currentString++] = CheckNullString(msg->lpszNoteText);       // Message Text  
+  strArray[currentString++] = CheckNullString(msg->lpszDateReceived);   // in YYYY/MM/DD HH:MM format
+  strArray[currentString++] = CheckNullString(msg->lpszConversationID); // conversation thread ID
+
+  if (msg->lpOriginator)
+  {
+    strArray[currentString++] = CheckNullString(msg->lpOriginator[0].lpszName);
+    strArray[currentString++] = CheckNullString(msg->lpOriginator[0].lpszAddress);
+  }
+  else
+  {
+    strArray[currentString++] = CheckNullString(NULL);
+    strArray[currentString++] = CheckNullString(NULL);
+  }
+
+  //
+  // Assign pointers for the Name and address of each recipient
+  //
+  LPSTR toString  = "1";
+  LPSTR ccString  = "2";
+  LPSTR bccString = "3";
+
+  for (i=0; i<msg->nRecipCount; i++)
+  {
+    // rhp - need message class
+    if (msg->lpRecips[i].ulRecipClass == MAPI_BCC)
+      strArray[currentString++] = CheckNullString(bccString);
+    else if (msg->lpRecips[i].ulRecipClass == MAPI_CC)
+      strArray[currentString++] = CheckNullString(ccString);
+    else
+      strArray[currentString++] = CheckNullString(toString);
+
+    strArray[currentString++] = CheckNullString(msg->lpRecips[i].lpszName);
+    strArray[currentString++] = CheckNullString(msg->lpRecips[i].lpszAddress);  
+  }
+
+  BYTE    szNewFileName[_MAX_PATH];
+
+  for (i=0; i<msg->nFileCount; i++)
+  {
+    char *namePtr;
+    // have to copy/create temp files here of office won't work...
+
+    if ( 
+          (msg->lpFiles[i].lpszFileName != NULL) &&
+          (*msg->lpFiles[i].lpszFileName != '\0') 
+       )
+    {
+      namePtr = (char *)msg->lpFiles[i].lpszFileName;
+    }
+    else
+    {
+      namePtr = (char *)msg->lpFiles[i].lpszPathName;
+    }
+
+    if (GetTempMailNameWithExtension((char *)szNewFileName, namePtr) == 0)
+    {
+      free(strArray);
+      free(mailPtr);
+      return NULL;
+    }
+    
+    if (!XP_CopyFile((char *)msg->lpFiles[i].lpszPathName, (char *)szNewFileName, TRUE))
+    {
+      free(strArray);
+      free(mailPtr);
+      return NULL;
+    }
+
+    strArray[currentString++] = CheckNullString((char *)szNewFileName);
+    strArray[currentString++] = CheckNullString(msg->lpFiles[i].lpszFileName);
+
+    AddTempFile((LPSTR) szNewFileName);
+//    strArray[currentString++] = CheckNullString(msg->lpFiles[i].lpszPathName);
+//    strArray[currentString++] = CheckNullString(msg->lpFiles[i].lpszFileName);
+  }
+
+  if (currentString != strCount)
+  {
+    TRACE("MAPI PROBLEM!!!!!! FlattenMAPIMessageStructure() currentString != strCount\n");
+  }
+
+  strArray[strCount] = NULL;    // terminate at the end
+  NSstringSeq strSeq = NSStrSeqNew(strArray);
+  if (!strSeq)
+  {
+    free(strArray);
+    free(mailPtr);
+    return NULL;
+  }
+  
+  //
+  // Now we need to copy the structure into a big, contiguous chunk of memory
+  //
+  LONG totalArraySize = NSStrSeqSize(strSeq);
+  LONG totalMemSize = sizeof(MAPISendMailType) + totalArraySize;
+
+#ifdef WIN16
+  if (totalMemSize > 64000)
+  {
+    free(strArray);
+    NSStrSeqDelete(strSeq);
+    free(mailPtr);
+    return NULL;
+  }
+#endif
+
+  MAPISendMailType *newMailPtr = (MAPISendMailType *)malloc((size_t)totalMemSize);
+  if (!newMailPtr)
+  {
+    free(strArray);
+    NSStrSeqDelete(strSeq);
+    free(mailPtr);
+    return NULL;
+  }
+
+  memset(newMailPtr, 0, (size_t) totalMemSize);
+  //
+  // Finally do the copy...
+  //
+  memcpy(newMailPtr, mailPtr, sizeof(MAPISendMailType));
+  memcpy(newMailPtr->dataBuf, strSeq, (size_t) totalArraySize);
+  *totalSize = totalMemSize;
+
+  //
+  // Cleanup and scram...
+  //
+  if (strArray)
+    free(strArray);
+
+  if (strSeq)
+    NSStrSeqDelete(strSeq);
+
+  if (mailPtr)
+    free(mailPtr);
+
+  return(newMailPtr);
+}

mailnews/mapi/mapi32/mapimem.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef __MY_MEM_HPP__
+#define __MY_MEM_HPP__
+
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>                                                 
+#endif
+
+//
+// Needed for turning NULL's into ""'s for string sequence routines...
+//
+LPSTR     CheckNullString(LPSTR inStr);
+
+//
+// Memory allocation functions...
+//
+
+//
+// This will free an lpMapiMessage structure allocated by this DLL
+//
+void      FreeMAPIMessage(lpMapiMessage pv);
+
+//
+// This will free an lpMapiRecipDesc structure allocated by this DLL
+//
+void      FreeMAPIRecipient(lpMapiRecipDesc pv);
+
+//
+// Frees a mapi file object...
+//
+void      FreeMAPIFile(lpMapiFileDesc pv);
+
+//
+// This routine will take an lpMapiMessage structure and "flatten" it into
+// one contiguous chunk of memory that can be easily passed around. 
+// 
+LPVOID    FlattenMAPIMessageStructure(lpMapiMessage msg, DWORD *totalSize);
+
+
+
+#endif  // __MY_MEM_HPP__

mailnews/mapi/mapi32/mapiutl.cpp

@@ -0,0 +1,880 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  Various utils needed for the MAPI functions
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include <windows.h> 
+#include <time.h> 
+#include <sys/stat.h>
+#include <io.h>
+#include "xpapi.h"
+#include "trace.h"
+#include "mapiipc.h"
+#include "mapiutl.h"
+
+//
+// Global variables
+//
+BOOL	  gLoggingEnabled = FALSE;
+
+void
+SetLoggingEnabled(BOOL val)
+{
+  gLoggingEnabled = val;
+}
+
+// Log File
+void 
+LogString(LPCSTR pStr1)
+{
+  // Off of the declaration line...
+  LPCSTR pStr2 = NULL;
+  BOOL useStr1 = TRUE;
+
+	if (gLoggingEnabled)
+	{
+		char tempPath[_MAX_PATH] = "";
+    if (getenv("TEMP"))
+    {
+      lstrcpy((LPSTR) tempPath, getenv("TEMP"));  // environmental variable
+    } 
+
+		int len = lstrlen(tempPath);
+		if ((len > 1) && tempPath[len - 1] != '\\')
+		{
+			lstrcat(tempPath, "\\");
+		}
+		lstrcat(tempPath, szMapiLog);
+		HFILE hFile = _lopen(tempPath, OF_WRITE);
+		if (hFile == HFILE_ERROR)
+		{
+			hFile = _lcreat(tempPath, 0);
+		}
+		if (hFile != HFILE_ERROR)
+		{
+			_llseek(hFile, 0, SEEK_END);		// seek to the end of the file
+			LPCSTR pTemp = useStr1 ? pStr1 : pStr2;
+			_lwrite(hFile, pTemp, lstrlen(pTemp));
+			_lclose(hFile);
+		}
+	}
+}
+
+//
+// Find Communicator and return an HWND, if not, start Communicator,
+// then find an HWND
+//
+HWND 
+GetCommunicatorIPCWindow(void)
+{
+  HWND  hWnd = NULL; 
+  DWORD timeCount = 0;
+  BOOL  launchTry = FALSE;
+
+  //
+  // This will wait for 10 seconds before giving up and failing
+  //
+  while ((hWnd == NULL) && (timeCount < 20))
+  {
+    if ((hWnd = FindWindow("AfxFrameOrView", NULL)) && !FindWindow("aHiddenFrameClass", NULL))
+      return(hWnd);
+    else if ((hWnd = FindWindow("aHiddenFrameClass", NULL)))
+      return(hWnd);
+
+    if (!launchTry)
+    {
+    char    szPath[_MAX_PATH] = "";
+		DWORD   nMAPIERROR; 
+
+      if ((nMAPIERROR = XP_GetInstallLocation(szPath, _MAX_PATH)) != SUCCESS_SUCCESS)
+      {
+        return(NULL); 
+      }
+		
+		  WORD nReturn = XP_CallProcess(szPath, " -MAPICLIENT");
+      launchTry = TRUE;
+    }
+
+    //
+    // Pause for 1/2 a second and try to connect again...
+    //
+#ifdef WIN32
+    Sleep(500);
+#else 
+    Yield();
+#endif        
+
+    timeCount++;
+  }
+
+	return(hWnd);
+}
+
+void
+BuildMemName(LPSTR name, ULONG winSeed)
+{
+  static DWORD    id = 0;
+
+  if (id == 0)
+  {
+    // Seed the random-number generator with current time so that
+    // the numbers will be different every time we run.
+    srand( (unsigned)time( NULL ) );
+    id = rand();
+  }
+
+  wsprintf(name, "MAPI_IPC_SMEM-%d", (winSeed + id++));
+  TRACE("Shared Memory Name = [%s]\n", name);
+}
+
+DWORD 
+ValidateFile(LPCSTR szFile) 
+{
+  	struct _stat buf;
+    int result;
+
+    result = _stat( szFile, &buf );
+    if (result != 0)
+      return(1);
+
+    if (!(buf.st_mode & S_IREAD))
+      return(2);
+
+    return(0);
+}
+
+//
+// return of zero is ok 
+// 1 = MAPI_E_ATTACHMENT_NOT_FOUND
+// 2 = MAPI_E_ATTACHMENT_OPEN_FAILURE
+//
+DWORD
+SanityCheckAttachmentFiles(lpMapiMessage lpMessage)
+{
+  ULONG i;
+  DWORD rc;
+
+  for (i=0; i<lpMessage->nFileCount; i++)
+  {
+    if ((rc = ValidateFile(lpMessage->lpFiles[i].lpszPathName)) != 0)
+    {
+      return(rc);
+    }
+  }
+
+  return(0);
+}
+
+DWORD 
+GetFileCount(LPSTR pFiles, LPSTR delimChar)
+{
+  DWORD   count = 1;
+	if ((!pFiles) || (!*pFiles))
+		return(0);
+
+  for (DWORD i=0; i<strlen(pFiles); i++)
+  {
+    if (pFiles[i] == delimChar[0])
+    {
+      ++count;
+    }
+  }
+
+  return(count);
+}
+
+//
+// Extract a filename from a string
+// Return TRUE if file found, else FALSE
+//
+BOOL
+ExtractFile(LPSTR pFiles, LPSTR delimChar, DWORD fIndex, LPSTR fName)
+{
+  LPSTR   ptr = pFiles;
+  DWORD   loc;
+  DWORD   count = 0;
+
+	if ((!pFiles) || (!*pFiles))
+		return(0);
+
+  // Get to the fIndex'th entry
+  for (loc=0; loc<strlen(pFiles); loc++)
+  {
+    if (count == fIndex)
+      break;
+    if (pFiles[loc] == delimChar[0])
+      count++;
+  }
+
+  if (loc >= strlen(pFiles))    // Got to the end of string!
+    return(FALSE);
+
+  lstrcpy(fName, (LPSTR)pFiles + loc);
+  //
+  // Truncate at 2nd delimiter
+  //
+  for (DWORD i=0; i<strlen(fName); i++)
+  {
+    if (fName[i] == delimChar[0])
+    {
+      fName[i] = '\0';
+      break;
+    }
+  }
+
+  return(TRUE);
+}
+
+ULONG
+GetFileSize(LPSTR fName)
+{
+  struct _stat buf;
+  int result;
+  
+  result = _stat( fName, &buf );
+  if (result != 0)
+    return(0);
+  
+  return(buf.st_size);
+}
+ 
+LPVOID
+LoadBlobToMemory(LPSTR fName)
+{
+  UCHAR     *ptr = NULL;
+  ULONG     bufSize = GetFileSize(fName);
+
+  if (bufSize == 0)
+  {
+    _unlink(fName);
+    return(NULL);
+  }
+
+  ptr = (UCHAR *)malloc( (size_t) bufSize);
+  if (!ptr)
+  {
+    _unlink(fName);
+    return(NULL);
+  }
+
+  HFILE hFile = _lopen(fName, OF_READ);
+  if (hFile == HFILE_ERROR)
+  {
+    _unlink(fName);
+    free(ptr);
+    return(NULL);
+  }
+
+  UINT numRead = _lread(hFile, ptr, (size_t) bufSize);
+  _lclose(hFile);
+
+  if (numRead != bufSize)
+  {
+    _unlink(fName);
+    free(ptr);
+    return(NULL);
+  }
+
+  _unlink(fName);
+	return(ptr);	
+}
+
+LONG
+WriteMemoryBufferToDisk(LPSTR fName, LONG bufSize, LPSTR buf)
+{
+  if (!buf)
+  {
+    return(-1);
+  }
+
+  HFILE hFile = _lcreat(fName, 0);
+  if (hFile == HFILE_ERROR)
+  {
+    return(-1);
+  }
+
+  LONG writeCount = _lwrite(hFile, buf, (size_t) bufSize);
+  _lclose(hFile);
+
+  if (writeCount != bufSize)
+  {
+    _unlink(fName);
+    return(-1);
+  }
+
+  return(0);
+}
+
+LPSTR
+GetTheTempDirectoryOnTheSystem(void)
+{
+ static UCHAR retPath[_MAX_PATH];
+  
+  if (getenv("TEMP"))
+  {
+    lstrcpy((LPSTR) retPath, getenv("TEMP"));  // environmental variable
+  } 
+  else if (getenv("TMP"))
+  {
+    lstrcpy((LPSTR) retPath, getenv("TMP"));  // How about this environmental variable?
+  }
+  else
+  {
+    GetWindowsDirectory((LPSTR) retPath, sizeof(retPath));
+  }
+
+  return((LPSTR) &(retPath[0]));
+}
+
+#ifdef WIN16
+int WINAPI EXPORT ISGetTempFileName(LPCSTR a_pDummyPath,  LPCSTR a_pPrefix, UINT a_uUnique, LPSTR a_pResultName)
+{
+#ifdef GetTempFileName	// we need the real thing comming up next...
+#undef GetTempFileName
+#endif
+	return GetTempFileName(0, a_pPrefix, a_uUnique, a_pResultName);
+}
+#endif
+
+LONG
+GetTempAttachmentName(LPSTR fName) 
+{
+  UINT        res;
+  static UINT uUnique = 1;
+
+  if (!fName)
+    return(-1);
+
+  LPSTR szTempPath = GetTheTempDirectoryOnTheSystem();
+
+TRYAGAIN:
+#ifdef WIN32
+  res = GetTempFileName(szTempPath, "MAPI", uUnique++, fName);
+#else
+  res = ISGetTempFileName(szTempPath, "MAPI", uUnique++, fName);
+#endif
+
+  if (ValidateFile(fName) != 1) 
+  {
+    if (uUnique < 32000)
+    {
+      goto TRYAGAIN;
+    }
+    else
+    {
+      return(-1);
+    }
+  }
+
+  return 0;
+}
+
+// RICHIE - strip all of the HTML stuff out of the message...
+int
+CheckForInlineHTML(char *noteBody, DWORD len, DWORD *curPos, char *newBody, DWORD *realLen)
+{
+  LPSTR   tags[] = {"&nbsp;", "&lt;", "&amp;", NULL};
+  UCHAR   tagsSubst[] = {' ', '<', '&', NULL};
+  int     x = 0;
+
+  while (tags[x])
+  {
+    // should we check for first tag
+    if ( (*curPos+strlen(tags[x])) < len)
+    {
+      if (strncmp(tags[x], noteBody, strlen(tags[x])) == 0)
+      {
+        *curPos += strlen(tags[x]) - 1;
+        newBody[*realLen] = tagsSubst[x];
+        *realLen += 1;
+        return(-1);
+      }
+    }
+
+    ++x;
+  }
+
+  return(0);
+}
+
+//
+// RICHIE - This is also temporary fix for now...
+//
+LPSTR
+StripSignedMessage(LPSTR noteText, DWORD totalCR) 
+{
+char    *newBuf;
+LPSTR   startTag = "<HTML>";
+LPSTR   endTag = "/HTML>";
+DWORD   i;
+DWORD   realLen = 0;
+DWORD   startPos = 0;
+DWORD   len = strlen(noteText);;
+
+  // create a new buffer...
+  newBuf = (char *) malloc((size_t)(len + totalCR));
+  if (!newBuf)
+    return(noteText);
+
+  newBuf[0] = '\0';
+
+  // First, find the start of the HTML for the message...
+  for (i=0; i<len; i++)
+  {
+    // should we check for first tag
+    if ( (i+strlen(startTag)) < len)
+    {
+      if (strncmp(startTag, (noteText + i), strlen(startTag)) == 0)
+      {
+        startPos = i + strlen(startTag);
+        break;
+      }
+    }
+  }
+
+  // Didn't find any HTML start tag
+  if (i == len)
+    return(noteText);
+
+  BOOL    inHTML = FALSE;
+  BOOL    firstChar = FALSE;
+
+  for (i=startPos; i<len; i++)
+  {
+    char  *ptr = (noteText + i);
+
+    if ( ((*ptr == 0x0D) || (*ptr == 0x20)) && (!firstChar) )
+      continue;
+    else
+      firstChar = TRUE;
+
+    // First, check for the end /HTML> tag
+    if ( (i+strlen(endTag)) < len)
+    {
+      if (strncmp(endTag, ptr, strlen(endTag)) == 0)
+      {
+        break;
+      }
+    }
+
+    // If we are in HTML, check for a ">"...
+    if (inHTML)
+    {
+      if (*ptr == '>')
+      {
+        inHTML = FALSE;
+      }
+      continue;
+    }
+
+    // Check for NEW HTML...
+    if (*ptr == '<')
+    {
+      inHTML = TRUE;
+      continue;
+    }
+
+    if (CheckForInlineHTML(ptr, len, &i, newBuf, &realLen))
+      continue;
+
+    newBuf[realLen++] = *ptr;
+    // Tack on a line feed if we hit a CR...
+    if ( *ptr == 0x0D )
+    {
+      newBuf[realLen++] = 0x0A;
+    }
+  }
+
+  // terminate the buffer - reallocate and move on...
+  newBuf[realLen++] = '\0';
+  newBuf = (LPSTR) realloc(newBuf, (size_t) realLen);
+
+  // check if the realloc worked and if so, free old memory and
+  // return...if not, just return the original buffer
+  if (!newBuf)
+  {
+    return(noteText);
+  }
+  else
+  {
+    free(noteText);
+    return(newBuf);
+  }
+}
+
+//
+// RICHIE - this is a temporary fix for now to get rid of
+// html stuff within the text of a message - if there was a
+// valid noteText buffer coming into this call, we need to 
+// free it on the way out.
+//
+LPSTR
+StripHTML(LPSTR noteText)
+{
+  char    *newBuf;
+  LPSTR   signTag = "This is a cryptographically signed message in MIME format.";
+  LPSTR   mimeTag = "This is a multi-part message in MIME format.";
+
+  DWORD   i;
+  DWORD   realLen = 0;
+  DWORD   totalCR = 0;
+
+  // do sanity checking...
+  if ((!noteText) || (!(*noteText)))
+    return(noteText);
+
+  // more sanity checking...
+  DWORD len = strlen(noteText) + 1;
+  if (len <= 0) 
+    return(noteText);
+
+  // Get the number of CR's in this message and add room for
+  // the LF's
+  for (i=0; i<len; i++)
+  {
+    if ( (*(noteText + i)) == 0x0D )
+      ++totalCR;
+  }
+
+  // This is a check for a signed message in the start of a message
+  // check for sign line...    
+  if ( strlen(signTag) < len)
+  {
+    if ( 
+        (strncmp(signTag, noteText, strlen(signTag)) == 0) ||
+        (strncmp(mimeTag, noteText, strlen(mimeTag)) == 0) 
+       )
+    {
+      return( StripSignedMessage(noteText, totalCR) );
+    }
+  }
+
+  // create a new buffer...
+  newBuf = (char *) malloc((size_t)(len + totalCR));
+  if (!newBuf)
+    return(noteText);
+
+  newBuf[0] = '\0';
+
+  BOOL    firstChar = FALSE;
+
+  // Now do the translation for the body of the note...
+  for (i=0; i<len; i++)
+  {
+    char  *ptr = (noteText + i);
+    
+    if ( ((*ptr == 0x0D) || (*ptr == 0x20)) && (!firstChar) )
+      continue;
+    else
+      firstChar = TRUE;
+
+    if (CheckForInlineHTML(ptr, len, &i, newBuf, &realLen))
+      continue;
+
+    newBuf[realLen++] = *ptr;
+    if ( *ptr == 0x0D )
+    {
+      newBuf[realLen++] = 0x0A;
+    }
+  }
+
+  // terminate the buffer - reallocate and move on...
+  newBuf[realLen++] = '\0';
+  newBuf = (LPSTR) realloc(newBuf, (size_t) realLen);
+
+  // check if the realloc worked and if so, free old memory and
+  // return...if not, just return the original buffer
+  if (!newBuf)
+  {
+    return(noteText);
+  }
+  else
+  {
+    free(noteText);
+    return(newBuf);
+  }
+}
+
+#ifdef WIN16
+
+void
+GetWin16TempName(LPSTR realFileName, LPSTR tempPath, 
+				 LPSTR szTempFileName, UINT uUnique)
+{
+  char	 *dotPtr = strrchr(realFileName, '.');
+  if (dotPtr != NULL)
+  {
+    *dotPtr = '\0';
+  }                
+  
+  int nameLen = lstrlen(realFileName); 
+  if (dotPtr != NULL)
+  {
+    *dotPtr = '.';
+  }
+  
+  if (nameLen <= 7)
+  {
+ 	wsprintf(szTempFileName, "%s\\%d%s", tempPath, uUnique, realFileName);
+  }
+  else
+  {
+  	wsprintf(szTempFileName, "%s\\%d%s", tempPath, uUnique, (realFileName + 1));
+  }
+}
+
+#endif
+
+#define MAXTRY  9999  // How many times do we try..
+
+UINT
+GetTempMailNameWithExtension(LPSTR szTempFileName, 
+                             LPSTR origName)
+{
+  UINT        res = 1;
+  UINT        uUnique = 0;
+  char        *szTempPath = GetTheTempDirectoryOnTheSystem();
+  char        *tmpPtr;
+  char        *realFileName = NULL;
+
+  if ( (origName != NULL) && (*origName != '\0') )
+  {
+    tmpPtr = origName;
+  }
+  else
+  {
+    tmpPtr = szTempFileName;
+  }
+
+  realFileName = strrchr(tmpPtr, '\\');
+  if (!realFileName)
+    realFileName = tmpPtr;
+  else
+    realFileName++;
+
+TRYAGAIN:
+
+#ifdef WIN32
+  if (uUnique == 0)
+  {
+    wsprintf(szTempFileName, "%s\\%s", szTempPath, realFileName);
+  }
+  else
+  {
+    wsprintf(szTempFileName, "%s\\%d_%s", 
+                szTempPath, uUnique, realFileName);
+  }
+#else // WIN16
+  if ( (uUnique == 0) && (strlen(realFileName) <= 12) )
+  {
+    wsprintf(szTempFileName, "%s\\%s", szTempPath, realFileName);
+  }
+  else
+  {              
+    if (uUnique < 10)
+    {
+      GetWin16TempName(realFileName, szTempPath, szTempFileName, uUnique);
+    }
+    else 
+    { 
+      res = ISGetTempFileName(szTempPath, "ns", uUnique++, szTempFileName);    
+    }
+
+    // Now add the correct extension...
+    char *origExt = strrchr(realFileName, '.');
+    if (origExt != NULL)
+    {
+      char *tmpExt = strrchr(szTempFileName, '.');
+      if (tmpExt != NULL)
+      {
+        origExt++;
+        tmpExt++;
+
+        while ( ((tmpExt) && (origExt)) && (*origExt != '\0') )
+        {
+          *tmpExt = *origExt;
+          tmpExt++;
+          origExt++;
+        }
+
+        *tmpExt = '\0';
+      }
+    }
+  }
+#endif
+
+  if ( (ValidateFile(szTempFileName) != 1) && (uUnique < MAXTRY) )
+  {
+    uUnique++;
+    if (uUnique >= MAXTRY)
+      return(1);
+    goto TRYAGAIN;
+  }
+
+  return res;
+}
+
+#define kMaxTempFiles   10
+#define kMaxListLength  (10 * _MAX_PATH)
+
+void GetTempFiles(LPSTR pBuf, int lenBuf)
+{
+  if (!GetConfigInfoStr(szMapiSection, szTempFiles, pBuf, lenBuf, HKEY_ROOT))
+  {
+    *pBuf = 0;
+  }
+}
+
+void WriteTempFiles(LPSTR pBuf)
+{
+  SetConfigInfoStr(szMapiSection, szTempFiles, pBuf, HKEY_ROOT);
+}
+
+void  AddTempFile(LPCSTR pFileName)
+{
+  if ( (!pFileName) || (pFileName[0] == '\0') )
+    return;
+
+  char *files = (char *)malloc(kMaxListLength);
+
+  if (!files)
+    return;
+
+  GetTempFiles(files, kMaxListLength);
+  if ((lstrlen(files) + lstrlen(pFileName) + 2) >= kMaxListLength)
+  {
+    free(files);
+    return;
+  }
+
+  if (lstrlen(files) != 0)
+  {
+          lstrcat(files, ";");
+  }
+
+  lstrcat(files, pFileName);
+  WriteTempFiles(files);
+  free(files);
+}
+
+void DeleteFirstTempFile(LPSTR pFiles)
+{
+  if (!*pFiles)
+    return;
+  LPSTR pTemp = strchr(pFiles, ';');
+  if (pTemp)
+  {
+    *pTemp = 0;
+  }
+ 
+//#ifndef _DEBUG  
+  _unlink(pFiles);
+//#endif
+
+  if (pTemp)
+  {
+    memmove(pFiles, pTemp + 1, lstrlen(pTemp + 1) + 1);
+  }
+  else
+  {
+    *pFiles = 0;
+  }
+}
+
+void 
+RemoveAllTempFiles(void)
+{
+  char *files = (char *)malloc(kMaxListLength);
+
+  if (!files)
+    return;
+
+  GetTempFiles(files, kMaxListLength);
+
+  while (*files)
+  {
+    DeleteFirstTempFile(files);
+  }
+
+  WriteTempFiles(files);
+  free(files);
+}
+
+void CheckAgeTempFiles(void)
+{
+  char *files = (char *)malloc(kMaxListLength);
+
+  if (!files)
+    return;
+
+  GetTempFiles(files, kMaxListLength);
+  int i = 0;
+  LPSTR pTemp = files;
+  while (TRUE)
+  {
+    pTemp = strchr(pTemp, ';');
+    if (!pTemp)
+      break;
+    ++pTemp;
+    ++i;
+  }
+
+  if (i >= 10)
+  {
+    DeleteFirstTempFile(files);
+    WriteTempFiles(files);
+  }
+
+  free(files);
+}
+
+void 
+CleanupMAPITempFiles(void)
+{
+  if (Is_16_OR_32_BIT_CommunitorRunning() == 0)
+  {
+    RemoveAllTempFiles();           // if Communicator not running, clean up all the temp files
+  }
+  else
+  {
+    CheckAgeTempFiles();
+  }
+}
+
+void *
+CleanMalloc(size_t mallocSize)
+{
+  void *ptr = malloc(mallocSize);
+  if (!ptr)
+    return(NULL);
+
+  memset(ptr, 0, mallocSize);
+  return(ptr);
+}
+
+void
+SafeFree(void *ptr)
+{
+  if (!ptr)
+    return;
+
+  free(ptr);
+  ptr = NULL;
+}

mailnews/mapi/mapi32/mapiutl.h

@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#ifndef __UTILS_
+#define __UTILS_
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>
+#endif
+
+//
+// Utility functions...
+//
+void    SetLoggingEnabled(BOOL val);    // Set a logging enabled flag
+void    LogString(LPCSTR pStr1);        // Log a string to a file...
+void    BuildMemName(LPSTR name, ULONG winSeed);  // Shared memory name
+HWND    GetCommunicatorIPCWindow(void);    // Get the IPC window we will use...
+DWORD   SanityCheckAttachmentFiles(lpMapiMessage lpMessage); // Check attachments
+DWORD   ValidateFile(LPCSTR szFile);       // Is this a valid file - 0=Yes 1 = NOT_FOUND 2 = OPEN_FAILURE
+
+DWORD   GetFileCount(LPSTR pFiles, LPSTR delimChar); // Get File count from string of file1;file2, etc..
+BOOL    ExtractFile(LPSTR pFiles, LPSTR delimChar, DWORD fIndex, LPSTR fName); // Extract a filename from a string
+
+LPVOID  LoadBlobToMemory(LPSTR fName);  // Load the blob into memory!
+LONG    GetTempAttachmentName(LPSTR fName); // Get a temp file name and put it in fName
+
+UINT    GetTempMailNameWithExtension(LPSTR szTempFileName, LPSTR origName);
+void    CleanupMAPITempFiles(void);
+void  AddTempFile(LPCSTR pFileName);
+
+void    *CleanMalloc(size_t mallocSize);
+void    SafeFree(void *ptr);
+
+//
+// RICHIE - this is a temporary fix for now to get rid of
+// html stuff within the text of a message - if there was a
+// valid noteText buffer coming into this call, we need to 
+// free it on the way out.
+//
+LPSTR   StripHTML(LPSTR noteText);
+
+//
+// Write a buffer to disk
+// Return 0 on success -1 on failure
+//
+LONG    WriteMemoryBufferToDisk(LPSTR fName, LONG bufSize, LPSTR buf); 
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __UTILS_

mailnews/mapi/mapi32/port.h

@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+
+#ifndef PORT_H
+#define PORT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*****************************************************************\
+ *                                                               *
+ *  PORT.H                                                       *
+ *                                                               *
+ *  Win16/Win32 portability stuff                                *
+ *                                                               *
+ *  A.Sokolsky                                                   *
+ *      3.10.94 distilled into this header                       *
+ *                                                               *
+\*****************************************************************/
+
+/*
+ * calling conventions
+ */
+#include <assert.h>
+                                                      
+                                                      
+#ifndef CDECL
+#define CDECL __cdecl
+#endif  // CDECL
+
+#ifndef PASCAL
+#define PASCAL __pascal
+#endif  // PASCAL
+
+#ifdef FASTCALL
+#error FASTCALL defined
+#endif // FASTCALL
+
+
+#ifdef NDEBUG
+#define FASTCALL __fastcall
+#else
+#define FASTCALL PASCAL
+#endif // NDEBUG   
+
+
+
+#ifndef HWND2DWORD
+#  ifdef WIN32
+#    define HWND2DWORD(X_hWnd) ( (DWORD)(X_hWnd) )
+#  else // WIN16
+#    define HWND2DWORD(X_hWnd) ( (DWORD)MAKELONG(((WORD)(X_hWnd)), 0) )
+#  endif
+#endif // HWND2DWORD
+
+
+/*
+ * WIN16 - WIN32 compatibility stuff
+ */
+
+#ifdef WIN32
+
+# define DLLEXPORT    __declspec( dllexport )
+# define EXPORT
+# define LOADDS
+# define HUGE
+# ifndef FAR
+#  define FAR
+# endif // FAR
+# ifndef NEAR
+#  define NEAR
+# endif // NEAR 
+# ifdef UNICODE
+#  define SIZEOF(x)   (sizeof(x)/sizeof(WCHAR))
+# else
+#  define SIZEOF(x)   sizeof(x)
+# endif
+
+#else  // !WIN32 == WIN16
+
+# define DLLEXPORT    
+# define EXPORT       __export
+# define LOADDS       __loadds
+# define HUGE         __huge
+# ifndef FAR
+#   define FAR        __far
+#   define NEAR       __near
+# endif  // FAR
+# define CONST const
+# define SIZEOF(x)    sizeof(x)
+# define CHAR char
+# define TCHAR char
+# define WCHAR char
+# ifndef LPTSTR
+#   define LPTSTR LPSTR
+# endif
+# ifndef LPCTSTR 
+#   define LPCTSTR LPCSTR
+# endif
+# define UNREFERENCED_PARAMETER(x) x;
+# ifndef TEXT
+#   define TEXT(x) x
+# endif
+# define GetWindowTextW GetWindowText
+# define lstrcpyW lstrcpy   
+
+# define BN_DBLCLK BN_DOUBLECLICKED // ~~MRJ needed for custom control.
+// ~~MRJ begin Win95 backward compat section
+# define LPWSTR LPSTR
+# define LPCWSTR LPCSTR
+
+// button check state for WIN16
+#ifndef BST_UNCHECKED
+#define BST_UNCHECKED      0x0000
+#endif
+
+#ifndef BST_CHECKED
+#define BST_CHECKED        0x0001
+#endif
+
+
+#ifndef WIN95_COMPAT
+#  define WIN95_COMPAT
+#endif
+
+// ~~MRJ end Win95 compat section.
+
+// critical section API stubs
+typedef DWORD CRITICAL_SECTION;
+typedef CRITICAL_SECTION FAR * LPCRITICAL_SECTION; 
+#ifdef __cplusplus
+inline void InitializeCriticalSection(LPCRITICAL_SECTION lpSection) {}
+inline void DeleteCriticalSection(LPCRITICAL_SECTION lpSection) {}
+inline void EnterCriticalSection(LPCRITICAL_SECTION lpSection) {}
+inline void LeaveCriticalSection(LPCRITICAL_SECTION lpSection) {} 
+#endif // __cplusplus 
+
+// Added for nssock16 ---Neeti
+#ifndef ZeroMemory
+#include <memory.h>
+#define ZeroMemory(PTR, SIZE) memset(PTR, 0, SIZE)
+#endif // ZeroMemory
+
+#endif // WIN16
+
+/*
+ * unix - windows compatibility stuff
+ */
+typedef DWORD u_int32;
+typedef WORD  u_int16;
+typedef BYTE  u_int8;
+#ifdef WIN32
+typedef short int Bool16;
+#else  // WIN16
+typedef BOOL  Bool16;
+#endif // WIN16
+
+/*
+ * Cross Platform Compatibility
+ */
+#ifndef UNALIGNED
+# ifdef _M_ALPHA
+#  define UNALIGNED __unaligned
+# else  // !_M_ALPHA
+#  define UNALIGNED
+# endif // !_M_ALPHA
+#endif  // UNALIGNED
+
+//
+// RICHIE - for the Alpha port
+//
+#ifdef _M_ALPHA
+# undef pascal
+# undef PASCAL
+# if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+#  define pascal __stdcall
+#  define PASCAL __stdcall
+# else
+#  define PASCAL
+# endif
+#endif
+
+
+/*
+ * Useful Types
+ */
+typedef char HUGE *HPSTR;
+typedef const char HUGE *HPCSTR;
+typedef unsigned char HUGE *HPBYTE;
+typedef WORD HUGE *HPWORD;
+typedef UINT FAR *LPUINT;
+typedef BOOL (CALLBACK *USERABORTPROC)();
+typedef BOOL (CALLBACK *PROGRESSPROC)(UINT uPos, UINT uRange);
+typedef int INT;   // ~~MRJ a function needed this defined.
+typedef MINMAXINFO FAR *LPMINMAXINFO; // ~~MRJ 
+
+//
+// stuff missing from windows.h
+//
+#ifndef MAKEWORD
+#define MAKEWORD(low, high)    ((WORD)(((BYTE)(low)) | (((WORD)((BYTE)(high))) << 8)))
+#endif // MAKEWORD
+
+#ifdef WIN32
+# ifndef hmemcpy
+#  define hmemcpy memcpy
+# endif // !defined(hmemcpy)
+# define _fmemset memset
+
+# include <malloc.h>
+
+#ifdef __cplusplus
+
+inline BOOL IsGDIObject(HGDIOBJ hObj) { return (hObj != 0); }
+inline void *_halloc(long num, unsigned int size) { return malloc(num * size); }
+inline void _hfree( void *memblock ) { free(memblock); } 
+/*
+inline BOOL IsInstance(HINSTANCE hInst) {
+# ifdef WIN32
+    return (hInst != 0);
+# else // WIN16
+    return (hInst > HINSTANCE_ERROR);
+# endif  
+}  
+*/
+
+#endif // __cplusplus
+
+  WINUSERAPI HANDLE WINAPI LoadImageA(HINSTANCE, LPCSTR, UINT, int, int, UINT);
+
+#endif // WIN32
+
+#ifdef __cplusplus 
+inline BOOL IsInstance(HINSTANCE hInst) {
+# ifdef WIN32
+    return (hInst != 0);
+# else // WIN16
+    return (hInst > HINSTANCE_ERROR);
+# endif  
+} 
+inline void SetWindowSmallIcon(HINSTANCE hInst, HWND hWnd, UINT uIconResourceId) {
+#ifdef WIN32
+# ifndef WM_SETICON
+#   define WM_SETICON 0x0080
+# endif  // WM_SETICON
+# ifndef IMAGE_ICON
+#   define IMAGE_ICON 1
+# endif
+  assert(IsWindow(hWnd));
+  HICON hIcon = (HICON)LoadImageA(hInst, MAKEINTRESOURCE(uIconResourceId), IMAGE_ICON,
+    16, 16, 0);
+  if(NULL != hIcon) {
+    SendMessage(hWnd, WM_SETICON, FALSE, (LPARAM)hIcon);
+  } else {
+    HICON hIcon = LoadIcon(hInst, MAKEINTRESOURCE(uIconResourceId));
+    assert(hIcon != 0);
+    SendMessage(hWnd, WM_SETICON, FALSE, (LPARAM)hIcon);
+  }
+#endif // WIN32
+}
+#endif // __cplusplus
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* PORT_H */

mailnews/mapi/mapi32/resource.h

@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by mapi32.rc
+//
+#define ID_DIALOG_QAHOOK                101
+#define ID_DIALOG_MAPI                  101
+#define ID_ICON_APP                     102
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        103
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

mailnews/mapi/mapi32/smem.cpp

@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  smem.cpp - This deals with all shared memory functions needed for 
+//  the MAPI component of Communicator
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include <windows.h>
+#include <windowsx.h>
+
+#include "mapismem.h"
+
+#ifndef ZeroMemory
+#include <memory.h>
+#define ZeroMemory(PTR, SIZE) memset(PTR, 0, SIZE)
+#endif // ZeroMemory
+
+// 
+// *create new* shared memory chunk 
+// once this is created, use the pointer
+// to the segment to to store data 
+// e.g.: 
+//     lpString = "string for communicator"; 
+//     lstrcpy((LPSTR)pData->m_buf[0], lpString); 
+//  
+CSharedMem *
+NSCreateSharedMemory(DWORD memSize, LPCTSTR memName, HANDLE *hSharedMemory)
+{
+#ifdef WIN32
+
+  BOOL bExistedBefore;
+  CSharedMem *pData;
+
+  LPCTSTR szObjectName = memName; 
+  DWORD dwSize = sizeof(CSharedMem) + memSize; 
+  *hSharedMemory = CreateFileMapping( 
+    (HANDLE)0xFFFFFFFF,0,PAGE_READWRITE,0,dwSize,szObjectName); 
+  if(*hSharedMemory == 0) 
+  { 
+    return NULL; 
+  } 
+  bExistedBefore = (GetLastError() == ERROR_ALREADY_EXISTS); 
+  if(bExistedBefore) 
+  { 
+  	return NULL;
+  } 
+
+  pData = (CSharedMem *)MapViewOfFile( 
+            *hSharedMemory, FILE_MAP_ALL_ACCESS, 0, 0, 0); 
+  if(pData == NULL) 
+  { 
+    return NULL; 
+  } 
+
+  ZeroMemory(pData, dwSize); 
+  pData->m_dwSize = memSize; 
+
+  return pData;
+#else
+  CSharedMem 	*sMemChunk = NULL;
+  DWORD dwSize = memSize = (sizeof(CSharedMem) + memSize); 
+
+  if (sMemChunk != NULL)
+	  return(sMemChunk);
+
+  sMemChunk = (CSharedMem *) GlobalAllocPtr(GMEM_MOVEABLE, dwSize);
+  ZeroMemory(sMemChunk, (size_t) dwSize);
+  sMemChunk->m_dwSize = dwSize;   // Missing in Communicator code!
+  return(sMemChunk);
+
+#endif // WIN32
+}
+
+// 
+// *open existing* shared memory chunk 
+// once you have the pointer to the new segment 
+// use this pointer to access data, e.g.: 
+// 
+CSharedMem *
+NSOpenExistingSharedMemory(LPCTSTR memName, HANDLE *hSharedMemory)
+{
+#ifdef WIN32
+  CSharedMem *pData;
+  DWORD dwSize;
+
+  LPCTSTR szObjectName = memName; 
+  *hSharedMemory = OpenFileMapping( 
+    PAGE_READWRITE,FALSE,szObjectName); 
+  if(*hSharedMemory == 0) 
+  { 
+    return NULL; 
+  } 
+
+  pData = (CSharedMem *)MapViewOfFile( 
+              *hSharedMemory,FILE_MAP_ALL_ACCESS,0,0,0); 
+  if(pData == NULL) 
+  { 
+    return NULL; 
+  } 
+  
+  dwSize = pData->m_dwSize; 
+  return pData;
+#else
+
+  return(NULL);   // In Win16, this is really meaningless...
+
+#endif
+}  
+
+// 
+// to close shared memory segment
+// 
+void
+NSCloseSharedMemory(CSharedMem *pData, HANDLE hSharedMemory)
+{
+#ifdef WIN32
+  if(pData != 0) 
+  { 
+    UnmapViewOfFile(pData); 
+    pData = 0; 
+  } 
+
+  if(hSharedMemory != 0) 
+  { 
+    CloseHandle(hSharedMemory); 
+    hSharedMemory = 0; 
+  } 
+#else
+
+	if (pData != NULL)
+	{
+		GlobalFreePtr(pData);
+		pData = NULL;
+	}
+
+#endif // WIN32
+}

mailnews/mapi/mapi32/trace.cpp

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#include <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <tchar.h>
+#include "trace.h"
+
+#ifdef _DEBUG 
+
+#ifndef WIN16
+void CDECL AfxTrace(LPCTSTR lpszFormat, ...)
+#else                                       
+void CDECL AfxTrace(LPCSTR lpszFormat, ...)
+#endif
+{
+  va_list args;
+	va_start(args, lpszFormat);
+
+	int nBuf;
+	TCHAR szBuffer[512];
+
+	nBuf = _vstprintf(szBuffer, lpszFormat, args);
+	va_end(args);
+  OutputDebugString(szBuffer); 
+  return;
+}
+
+BOOL AfxAssertFailedLine(LPCSTR lpszFileName, int nLine)
+{    
+	return TRUE;
+}
+
+#endif

mailnews/mapi/mapi32/trace.h

@@ -0,0 +1,62 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#include <windows.h>
+
+#ifdef _DEBUG
+BOOL AfxAssertFailedLine(LPCSTR lpszFileName, int nLine);
+
+#ifndef WIN16
+void CDECL AfxTrace(LPCTSTR lpszFormat, ...);
+#else
+void CDECL AfxTrace(LPCSTR lpszFormat, ...);
+#endif
+
+#define TRACE              ::AfxTrace
+#define THIS_FILE          __FILE__
+#define ASSERT(f) \
+	do \
+	{ \
+	if (!(f) && AfxAssertFailedLine(THIS_FILE, __LINE__)) \
+		AfxDebugBreak(); \
+	} while (0) \
+
+#define VERIFY(f)          ASSERT(f)
+#define TRACE_FN(name) LogFn __logFn(name)
+class LogFn
+{
+public:
+	LogFn(LPCSTR pFnName) {m_pFnName = pFnName; TRACE("--%s: In--\n", pFnName);}
+	~LogFn() {TRACE("--%s: Out--\n", m_pFnName);}
+private:
+	LPCSTR m_pFnName;
+};
+#else
+// NDEBUG
+#define ASSERT(f)          ((void)0)
+#define VERIFY(f)          ((void)(f))
+#define ASSERT_VALID(pOb)  ((void)0)
+#define DEBUG_ONLY(f)      ((void)0)   
+#ifdef WIN32
+inline void CDECL AfxTrace(LPCTSTR, ...) { }
+#else
+inline void CDECL AfxTrace(LPCSTR, ...) { }
+#endif
+#define TRACE              1 ? (void)0 : ::AfxTrace
+#define TRACE_FN(name)
+#endif // _DEBUG
+

mailnews/mapi/mapi32/xpapi.cpp

@@ -0,0 +1,328 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  XPAPI.CPP
+//  API implementation file for mapi16.dll and mapi32.dll
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#include <windows.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include "xpapi.h"
+#include "mapiutl.h"
+
+WORD LOAD_DS XP_CallProcess(LPCSTR pPath, LPCSTR pCmdLine)
+{            
+	WORD wReturn = 0;
+#ifndef WIN16
+	STARTUPINFO startupInfo;
+	PROCESS_INFORMATION processInfo;
+
+	memset(&startupInfo, 0, sizeof(startupInfo));
+	startupInfo.cb = sizeof(startupInfo);
+	if (wReturn = CreateProcess(pPath, (LPTSTR)pCmdLine, NULL, NULL, FALSE, CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_PROCESS_GROUP, NULL, NULL, &startupInfo, &processInfo))
+	{
+		WaitForInputIdle(processInfo.hProcess, 120000);
+	}
+#else       
+	// char szMsg[80];	
+	char szExecute[512];
+	lstrcpy(szExecute, pPath);
+	lstrcat(szExecute, " ");
+	lstrcat(szExecute, pCmdLine);
+	wReturn = WinExec(szExecute,SW_SHOW);
+	
+	if (wReturn < 32) 
+	{
+	    wReturn = 0;
+	}
+#endif
+	return wReturn;
+}
+
+HKEY LOAD_DS RegOpenParent(LPCSTR pSection, HKEY hRootKey, REGSAM access)
+{
+	HKEY hKey;
+#ifndef WIN16
+	if (RegOpenKeyEx(hRootKey, pSection, 0, access, &hKey) != ERROR_SUCCESS)
+	{
+		return(NULL);
+	}        
+#else
+    if (RegOpenKey(hRootKey, pSection, &hKey) != ERROR_SUCCESS)
+    {
+    	return(NULL);
+    }
+#endif
+	return(hKey);
+}
+
+HKEY LOAD_DS RegCreateParent(LPCSTR pSection, HKEY hMasterKey)
+{
+	HKEY hKey;
+	if (RegCreateKey(hMasterKey, pSection, &hKey) != ERROR_SUCCESS)
+	{
+		return(NULL);
+	}        
+	return(hKey);
+}
+
+BOOL LOAD_DS GetConfigInfoStr(LPCSTR pSection, LPCSTR pKey, LPSTR pBuf, int lenBuf, HKEY hMasterKey)
+{
+	HKEY hKey;
+	hKey = RegOpenParent(pSection, hMasterKey, KEY_QUERY_VALUE);
+	if (!hKey)
+	{
+		return(FALSE);
+	}
+
+	DWORD len = (DWORD)lenBuf;
+#ifndef WIN16
+	BOOL retVal = (RegQueryValueEx(hKey, pKey, NULL, NULL, (LPBYTE)pBuf, &len) == ERROR_SUCCESS);
+#else
+	BOOL retVal = (RegQueryValue(hKey, pKey, pBuf, (long far*)&len) == ERROR_SUCCESS);
+#endif
+	RegCloseKey(hKey);
+	return(retVal);
+}
+
+BOOL LOAD_DS GetConfigInfoNum(LPCSTR pSection, LPCSTR pKey, DWORD* pVal, HKEY hMasterKey)
+{
+	HKEY hKey;
+	hKey = RegOpenParent(pSection, hMasterKey, KEY_QUERY_VALUE);
+	if (!hKey)
+	{
+		return(FALSE);
+	}
+
+	DWORD len = sizeof(DWORD);
+#ifndef WIN16
+	BOOL retVal = (RegQueryValueEx(hKey, pKey, NULL, NULL, (LPBYTE)pVal, &len) == ERROR_SUCCESS);
+#else
+	BOOL retVal = (RegQueryValue(hKey, pKey, (char far*)pVal, (long far*)&len) == ERROR_SUCCESS);
+#endif
+	RegCloseKey(hKey);
+	return(retVal);
+}
+
+BOOL LOAD_DS SetConfigInfoStr(LPCSTR pSection, LPCSTR pKey, LPSTR pStr, HKEY hMasterKey)
+{
+	HKEY hKey;
+	hKey = RegCreateParent(pSection, hMasterKey);
+	if (!hKey)
+	{
+		return(FALSE);
+	}
+#ifndef WIN16
+	BOOL retVal = (RegSetValueEx(hKey, pKey, 0, REG_SZ, (LPBYTE)pStr, lstrlen(pStr) + 1) == ERROR_SUCCESS);
+#else
+	BOOL retVal = (RegSetValue(hKey, pKey, REG_SZ, pStr, lstrlen(pStr) + 1) == ERROR_SUCCESS);
+#endif
+	RegCloseKey(hKey);
+	return(retVal);
+}
+
+
+BOOL LOAD_DS XP_GetInstallDirectory(LPCSTR pcurVersionSection, LPCSTR pInstallDirKey, LPSTR path, UINT nSize, HKEY hKey)
+{   
+#ifdef WIN32   
+	if (!GetConfigInfoStr(pcurVersionSection, pInstallDirKey, path, nSize, hKey))
+	{  
+		return FALSE;
+	}
+	else
+	{
+		return TRUE;
+	}       
+#else
+	if ( 0 < GetPrivateProfileString(pcurVersionSection, pInstallDirKey,"ERROR", path, nSize, szNetscapeINI))
+	{
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+#endif
+}
+
+
+BOOL LOAD_DS XP_GetVersionInfoString(LPCSTR pNavigatorSection, LPCSTR pCurrentVersionKey, LPSTR pcurVersionStr, UINT nSize, HKEY hKey)
+{ 
+#ifdef WIN32
+	if (!GetConfigInfoStr(pNavigatorSection, pCurrentVersionKey, pcurVersionStr, nSize, HKEY_LOCAL_MACHINE))
+	{
+		return FALSE;
+	}               
+	else
+	{
+		return TRUE;
+	}
+#else 
+	if ( 0 < GetPrivateProfileString(pNavigatorSection, pCurrentVersionKey,"ERROR", pcurVersionStr, nSize, szNetscapeINI))
+	{
+		return TRUE;
+	}
+	else
+	{
+		return FALSE;
+	}
+#endif
+
+}   
+
+DWORD LOAD_DS XP_GetInstallLocation(LPSTR pPath, UINT nSize)
+{           
+char curVersionStr[256]; 
+char curVersionSection[256];
+
+  if (!pPath) 
+    return  MAPI_E_LOGON_FAILURE;
+  
+#ifdef WIN32
+  if (!XP_GetVersionInfoString(szNavigatorSection, szCurrentVersionKey, curVersionStr, 
+    sizeof(curVersionStr), HKEY_LOCAL_MACHINE))
+  {
+    return (MAPI_E_LOGON_FAILURE);
+  }
+  
+  wsprintf(curVersionSection, szNavigatorCurVersionSection, curVersionStr);
+		
+  if (!XP_GetInstallDirectory(curVersionSection, szInstallDirKey, pPath, 
+    nSize, HKEY_LOCAL_MACHINE))
+  {
+    return (MAPI_E_ACCESS_DENIED);
+    
+  }
+  
+  lstrcat(pPath, "\\");
+  lstrcat(pPath, "Program\\netscape.exe");
+  
+  return SUCCESS_SUCCESS;
+#else
+  if (32 == Is_16_OR_32_BIT_CommunitorRunning())
+  {   
+    if (!GetConfigInfoStr("snews\\shell\\open", "command", curVersionStr, sizeof(curVersionStr), HKEY_CLASSES_ROOT))
+    {
+      return (MAPI_E_ACCESS_DENIED);
+    }
+    else
+    {	
+      char *pFind = strstr(curVersionStr,"-h");
+      
+      if (pFind)
+      {
+        *pFind=0;
+        lstrcpy(pPath,curVersionStr);
+      }
+      else
+      {
+        return (MAPI_E_ACCESS_DENIED);
+      }
+    }
+    
+    return SUCCESS_SUCCESS;
+  }
+  else //setup up to start navstart since we are a sixteen bit DLL.
+  {
+    if (!XP_GetVersionInfoString(szNavigatorSection, szCurrentVersionKey, curVersionStr, sizeof(curVersionStr), HKEY_LOCAL_MACHINE))
+    {
+      return (MAPI_E_LOGON_FAILURE);
+    }
+    
+    wsprintf(curVersionSection, szNavigatorCurVersionSection, curVersionStr);
+    
+    if (!XP_GetInstallDirectory(curVersionSection, szInstallDirKey, pPath,nSize, HKEY_LOCAL_MACHINE))
+    {
+      return (MAPI_E_ACCESS_DENIED);		
+    }
+    
+    lstrcat(pPath, "\\");
+    lstrcat(pPath, "NAVSTART.EXE");
+    return SUCCESS_SUCCESS;	
+  }
+#endif
+}
+
+int LOAD_DS Is_16_OR_32_BIT_CommunitorRunning()
+{
+  if (FindWindow("AfxFrameOrView", NULL) && !FindWindow("aHiddenFrameClass", NULL))
+		return(16);
+	else if (FindWindow("aHiddenFrameClass", NULL))
+		return(32);
+	else 
+		return 0;
+}
+
+// size of buffer to use for copying files.
+#define COPYBUFSIZE 1024
+
+#ifdef WIN16
+     
+BOOL Win16CopyFile(LPCSTR a_Src, LPCSTR a_Dest, BOOL a_bOverwrite)
+{
+	OFSTRUCT ofSrc, ofDest;
+	HFILE hSrc, hDest;
+	BOOL bResult;
+	
+	ofDest.cBytes = ofSrc.cBytes = sizeof(OFSTRUCT);
+	hDest = OpenFile(a_Dest, &ofDest, OF_EXIST);
+	if (hDest != HFILE_ERROR && !a_bOverwrite)
+		bResult = FALSE;	// file exists but caller doesn't want file overwritten
+	else { // file either doesn't exist, or caller wants it overwritten.
+		hSrc = OpenFile(a_Src, &ofSrc, OF_READ);
+		hDest = OpenFile(a_Dest, &ofDest, OF_WRITE | OF_CREATE);
+		if (hSrc != HFILE_ERROR && hDest != HFILE_ERROR) {
+			unsigned char buf[COPYBUFSIZE];
+			UINT bufsize =  COPYBUFSIZE;
+			UINT bytesread;
+			
+			bResult = TRUE;			
+			while (0 != (bytesread = _lread(hSrc, (LPVOID)buf, bufsize))) {
+				if ((bytesread == HFILE_ERROR) || 	// check for read error...
+											// and write error
+					(bytesread != _lwrite(hDest, (LPVOID)buf, bytesread))) {
+					bResult = FALSE; // could be out of diskspace
+					break;
+				}
+			}
+		}
+		else
+			bResult = FALSE;
+
+		if (hSrc != HFILE_ERROR)
+			_lclose(hSrc);
+		if (hDest != HFILE_ERROR)
+			_lclose(hDest);
+	}
+			
+	return bResult;
+}
+
+#endif  // WIN16
+
+BOOL LOAD_DS 
+XP_CopyFile(LPCSTR lpExistingFile, LPCSTR lpNewFile, BOOL bFailifExist)
+{                                                  
+#ifdef WIN32
+  return	CopyFile(lpExistingFile, lpNewFile, bFailifExist);
+#else                                                             
+  return    Win16CopyFile(lpExistingFile, lpNewFile, TRUE);
+#endif
+}    

mailnews/mapi/mapi32/xpapi.h

@@ -0,0 +1,119 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+//  Various routines for MAPI functions.
+//  Written by: Rich Pizzarro (rhp@netscape.com)
+//  November 1997
+//
+#ifndef __XPAPI_H
+#define __XPAPI_H
+
+#ifdef WIN16
+
+#include <string.h>
+#include <direct.h>
+#include <shellapi.h>
+#include <stdlib.h>
+#else
+#include <winreg.h>
+#endif 
+ 
+#ifdef WIN16
+extern "C" {
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>
+#endif 
+}           
+#else
+//#include <mapi.h>
+#endif
+
+
+#ifdef WIN32
+#define MAPI_IMPLEMENT(param) param PASCAL 
+#define LOAD_DS
+#else        
+#define LOAD_DS 	__loadds
+#define MAPI_IMPLEMENT(param) extern "C" param FAR PASCAL
+ 
+#endif   
+
+#ifdef WIN16
+#define _MAX_PATH 				260  /* max. length of full pathname*/
+#define MAPI_E_LOGON_FAILURE  	3 
+#define MAPI_E_ACCESS_DENIED	6  
+#define INVALID_HANDLE_VALUE 	(HANDLE)-1  
+#define KEY_QUERY_VALUE 		0x0001  
+#define HKEY_LOCAL_MACHINE 		((HKEY)0x80000002)
+#define HKEY_ROOT				HKEY_CLASSES_ROOT
+#else 
+#define HKEY_ROOT				((HKEY)0x80000002)
+#endif
+
+//
+// registry keys
+//
+#ifdef WIN32
+static char szNavigatorSection[] = "Software\\Netscape\\Netscape Navigator";
+static char szNavigatorCurVersionSection[] = "Software\\Netscape\\Netscape Navigator\\%s\\Main";
+static char szCurrentVersionKey[] = "CurrentVersion";
+static char szInstallDirKey[] = "Install Directory";
+static char szMapiSection[] = "Software\\Netscape\\Netscape Navigator\\MAPI";
+static char szTempFiles[] = "TempFiles";  
+static char szMapiLog[] = "NSMAPI32.LOG";
+#else 
+//32 bit key strings for trying to read the 32bit registry
+static char szNavigatorSection32[] = "Software\\Netscape\\Netscape Navigator";
+static char szNavigatorCurVersionSection32[] = "Software\\Netscape\\Netscape Navigator\\%s\\Main";
+static char szMapiSection32[] = "Software\\Netscape\\Netscape Navigator\\MAPI";
+
+// ini section and key strings 
+static char szNetscapeINI[] = "nscp.ini";
+static char szNavigatorSection[] = "Netscape Navigator";
+static char szNavigatorCurVersionSection[] = "Netscape Navigator-%s";
+static char szCurrentVersionKey[] = "CurrentVersion";
+static char szInstallDirKey[] = "Install Directory";
+static char szMapiSection[] = "MAPI";
+static char szTempFiles[] = "TempFiles";
+static char szExeName[] = "NAVSTART.EXE";
+static char szMapiLog[] = "NSMAPI16.LOG";
+#endif                                   
+
+//Since REGSAM is just an ACCESS_MASK which is just a DWORD and it's not 
+//declared in win16 we'll make one hear for the purpose of keeping parameters
+//the same even though the access rights don't get used for win16.
+
+typedef DWORD REGSAM;
+
+
+// XP declarations
+
+int 	LOAD_DS Is_16_OR_32_BIT_CommunitorRunning();
+WORD 	LOAD_DS XP_CallProcess(LPCSTR pPath, LPCSTR pCmdLine);
+HKEY LOAD_DS RegOpenParent(LPCSTR pSection, HKEY hRootKey, REGSAM access);
+HKEY LOAD_DS RegCreateParent(LPCSTR pSection, HKEY hMasterKey);
+BOOL LOAD_DS GetConfigInfoStr(LPCSTR pSection, LPCSTR pKey, LPSTR pBuf, int lenBuf, HKEY hMasterKey);
+BOOL LOAD_DS GetConfigInfoNum(LPCSTR pSection, LPCSTR pKey, DWORD* pVal, HKEY hMasterKey);
+BOOL LOAD_DS SetConfigInfoStr(LPCSTR pSection, LPCSTR pKey, LPSTR pStr, HKEY hMasterKey); 
+
+BOOL  LOAD_DS XP_GetInstallDirectory(LPCSTR pcurVersionSection, LPCSTR pInstallDirKey, LPSTR path, UINT nSize, HKEY hKey); 
+BOOL  LOAD_DS XP_GetVersionInfoString(LPCSTR pNavigatorSection, LPCSTR pCurrentVersionKey, LPSTR pcurVersionStr, UINT nSize, HKEY hKey);
+DWORD LOAD_DS XP_GetInstallLocation(LPSTR pPath, UINT nSize);
+BOOL LOAD_DS  XP_CopyFile(LPCSTR lpExistingFile, LPCSTR lpNewFile, BOOL bFailifExist);
+
+#endif    // __XPAPI_H

mailnews/mapi/public/makefile.win

@@ -0,0 +1,27 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..\..
+MODULE=mime
+
+EXPORTS =							\
+	nscpmapi.h		\
+    $(NULL)
+
+
+include <$(DEPTH)\config\rules.mak>
+

mailnews/mapi/public/nscpmapi.h

@@ -0,0 +1,332 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+// This is a header file for the MAPI support within 
+// Communicator. 
+//
+// Written by: Rich Pizzarro (rhp@netscape.com)
+//
+#ifndef _NSCPMAPI
+#define _NSCPMAPI
+
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>     // for MAPI specific types...        
+#endif 
+
+#ifdef WIN16
+typedef unsigned char	UCHAR;
+#endif 
+
+
+#define           MAX_NAME_LEN    256
+#define           MAX_PW_LEN      256
+#define           MAX_MSGINFO_LEN 512
+#define           MAX_CON         4     // Maximum MAPI session supported
+#define           MAX_POINTERS    32
+
+//
+// The MAPI class that will act as the internal mechanism for 
+// Communicator to control multiple MAPI sessions.
+//
+class CMAPIConnection 
+{
+protected:
+  LONG        m_ID;
+  BOOL        m_defaultConnection;  
+  LONG        m_sessionCount;
+  LONG        m_messageIndex;
+  LPVOID      m_cookie;
+  UCHAR       m_messageFindInfo[MAX_MSGINFO_LEN];
+  UCHAR       m_profileName[MAX_NAME_LEN];
+  UCHAR       m_password[MAX_PW_LEN];
+
+  // Methods
+
+public:
+  CMAPIConnection  ( LONG, LPSTR, LPSTR );
+  ~CMAPIConnection ( );
+
+  // ID related methods
+  LONG   GetID( ) { return m_ID; } ;
+
+  // Dealing with the default session...
+  BOOL    IsDefault( ) { return m_defaultConnection; } ;
+  void    SetDefault( BOOL flag ) { m_defaultConnection = flag; } ;
+
+  // For handling multiple sessions on a profile name...
+  LONG    GetSessionCount( ) { return m_sessionCount; } ;
+  void    IncrementSessionCount() { ++m_sessionCount; } ;
+  void    DecrementSessionCount() { --m_sessionCount; } ;
+
+  // Information retrieval stuff...
+  LPSTR   GetProfileName( ) { return (LPSTR) m_profileName; };
+  LPSTR   GetPassword( ) { return (LPSTR) m_password; };
+
+  // Dealing with message information...
+  void    SetMessageIndex( LONG mIndex ) { m_messageIndex = mIndex; } ;
+  LONG    GetMessageIndex( ) { return m_messageIndex; };
+
+  void    SetMessageFindInfo( LPSTR info ) { lstrcpy((LPSTR)m_messageFindInfo, info); } ;
+  LPSTR   GetMessageFindInfo( ) { return (LPSTR) m_messageFindInfo; };
+
+  // For enumerating Messages...
+  void    SetMapiListContext( LPVOID cookie) { m_cookie = cookie; } ;
+  LPVOID  GetMapiListContext( ) { return m_cookie; };
+};
+
+//
+// Defines needed for requests being made with the WM_COPYDATA call...
+//
+typedef enum {
+    NSCP_MAPIStartRequestID = 0,
+    NSCP_MAPILogon,
+    NSCP_MAPILogoff,
+    NSCP_MAPIFree,
+    NSCP_MAPISendMail,
+    NSCP_MAPISendDocuments, 
+    NSCP_MAPIFindNext,
+    NSCP_MAPIReadMail,
+    NSCP_MAPISaveMail,
+    NSCP_MAPIDeleteMail,
+    NSCP_MAPIAddress,
+    NSCP_MAPIDetails,
+    NSCP_MAPIResolveName,
+    NSCP_MAPIEndRequestID       // Note: this is a marker for MAPI IPC requests
+} NSCP_IPC_REQUEST;
+
+//
+// This is to keep track of the pointers allocated in the MAPI DLL
+// and deal with them correctly.
+//
+#define   MAPI_MESSAGE_TYPE     0
+#define   MAPI_RECIPIENT_TYPE   1
+ 
+typedef struct {
+  LPVOID    lpMem;
+  UCHAR     memType;
+} memTrackerType;
+
+//
+// This is the generic message that WM_COPYDATA will send to the
+// Communicator product to allow it to attach to shared memory.
+// NOTE: On Win16, this will simply reference a pointer.
+//
+typedef struct {
+  UCHAR   smemName[64]; // Name of shared memory
+  DWORD   smemSize;     // Size of shared memory
+  LPVOID  lpsmem;       // Will be really used in Win16 only
+} MAPIIPCType;
+
+//
+// These are message specific structures that will be used for 
+// the various MAPI operations.
+//
+typedef struct {
+  ULONG     ulUIParam;
+  FLAGS     flFlags;
+  LHANDLE   lhSession;
+  DWORD     ipcWorked;      // Necessary for IPC check with Communicator
+// LPSTR     strSequence,  // LPSTR lpszProfileName, LPSTR lpszPassword
+// This is here to document the fact there will be a string sequence at 
+// this location
+} MAPILogonType;
+
+typedef struct {
+  LHANDLE   lhSession;
+  ULONG     ulUIParam;
+  FLAGS     flFlags;
+  DWORD     ipcWorked;      // Necessary for IPC check with Communicator
+} MAPILogoffType;
+
+typedef struct {
+  LHANDLE   lhSession;
+  ULONG     ulUIParam;
+  FLAGS     flFlags;
+  DWORD     ipcWorked;      // Necessary for IPC check with Communicator
+  // The following is the "FLAT" representation of the (lpMapiMessage lpMessage) 
+  // argument of this structure 
+  FLAGS     MSG_flFlags;          // unread,return receipt                  
+  ULONG     MSG_nRecipCount;      // Number of recipients                   
+  ULONG     MSG_nFileCount;       // # of file attachments                  
+  ULONG     MSG_ORIG_ulRecipClass; //  Recipient class - MAPI_TO, MAPI_CC, MAPI_BCC, MAPI_ORIG
+  BYTE      dataBuf[1];           // For easy referencing
+  //
+  // This is where it gets CONFUSING...the following buffer of memory is a
+  // contiguous chunk of memory for various strings that are part of this
+  // multilevel structure. For any of the following structure, any numbers
+  // are represented by strings that will have to be converted back to numeric
+  // values with atoi() calls.
+
+  // String 0: LPSTR lpszSubject;            // Message Subject
+  // String 1: LPSTR lpszNoteText FILE NAME; // Message Text will be
+  //           stored into a temp file and this will be the pointer to that file.
+  // String 2: LPSTR lpszDateReceived;       // in YYYY/MM/DD HH:MM format
+  // String 3: LPSTR lpszConversationID;     // conversation thread ID
+  //
+  // The following are for the originator of the message. Only ONE of these.
+  //
+  // String 4: LPSTR lpszName;             // Originator name                           
+  // String 5: LPSTR lpszAddress;          // Originator address (optional)             
+  //
+  // The following strings are for the recipients for this message. There are
+  // MSG_nRecipCount of these in a row:
+  //
+  // for (i=0; i<MSG_nRecipCount; i++)
+  //      String x: LPSTR lpszRecipClass (ULONG) // Recipient class - MAPI_TO, MAPI_CC, MAPI_BCC, MAPI_ORIG        
+  //      String x: LPSTR lpszName;     // Recipient N name                           
+  //      String x: LPSTR lpszAddress;  // Recipient N address (optional)             
+  //
+  // Now, finally, add the attachments for this beast. There are MSG_nFileCount
+  // attachments so it would look like the following:
+  //
+  // for (i=0; i<MSG_nFileCount; i++)
+  //
+  //      String x: LPSTR lpszPathName // Fully qualified path of the attached file. 
+  //                                   // This path should include the disk drive letter and directory name.
+  //      String x: LPSTR lpszFileName // The display name for the attached file
+  //
+} MAPISendMailType;
+
+typedef struct {
+    ULONG     ulUIParam;
+    ULONG     nFileCount;
+    DWORD     ipcWorked;      // Necessary for IPC check with Communicator
+    BYTE      dataBuf[1];     // For easy referencing
+    //
+    // The sequence of strings to follow are groups of PathName/FileName couples.
+    // The strings will be parsed in MAPI[32].DLL and then put into this format:
+    //
+    // for (i=0; i<nFileCount; i++)
+    //
+    //      String x: LPSTR lpszPathName // Fully qualified path of the attached file. 
+    //                                   // This path should include the disk drive letter and directory name.
+    //      String x: LPSTR lpszFileName // The display name for the attached file
+} MAPISendDocumentsType;
+
+typedef struct {
+  LHANDLE     lhSession;
+  ULONG       ulUIParam;
+  FLAGS       flFlags;
+  DWORD       ipcWorked;      // Necessary for IPC check with Communicator
+  UCHAR       lpszSeedMessageID[MAX_MSGINFO_LEN];
+  UCHAR       lpszMessageID[MAX_MSGINFO_LEN];
+} MAPIFindNextType;
+
+typedef struct {
+  LHANDLE     lhSession;
+  ULONG       ulUIParam;
+  DWORD       ipcWorked;      // Necessary for IPC check with Communicator
+  UCHAR       lpszMessageID[MAX_MSGINFO_LEN];
+} MAPIDeleteMailType;
+
+typedef struct {
+  LHANDLE     lhSession;
+  ULONG       ulUIParam;
+  FLAGS       flFlags;
+  DWORD       ipcWorked;      // Necessary for IPC check with Communicator
+  UCHAR       lpszName[MAX_NAME_LEN];
+  // These are returned by Communicator
+  UCHAR       lpszABookID[MAX_NAME_LEN];         
+  UCHAR       lpszABookName[MAX_NAME_LEN];            
+  UCHAR       lpszABookAddress[MAX_NAME_LEN];         
+} MAPIResolveNameType;
+
+typedef struct {
+  LHANDLE     lhSession;
+  ULONG       ulUIParam;
+  FLAGS       flFlags;
+  DWORD       ipcWorked;      // Necessary for IPC check with Communicator
+  UCHAR       lpszABookID[MAX_NAME_LEN];
+} MAPIDetailsType;
+
+typedef struct {
+  LHANDLE     lhSession;
+  ULONG       ulUIParam;
+  FLAGS       flFlags;
+  DWORD       ipcWorked;      // Necessary for IPC check with Communicator
+  UCHAR       lpszMessageID[MAX_MSGINFO_LEN];
+  //
+  // The following is the "FLAT" representation of the (lpMapiMessage lpMessage) 
+  // argument of this structure 
+  //
+  FLAGS     MSG_flFlags;          // unread, return or receipt                  
+  ULONG     MSG_nRecipCount;      // Number of recipients                   
+  ULONG     MSG_nFileCount;       // # of file attachments                  
+  ULONG     MSG_ORIG_ulRecipClass; //  Recipient class - MAPI_TO, MAPI_CC, MAPI_BCC, MAPI_ORIG
+  //
+  // Output parameter for blob of information that will live on disk. 
+  //
+  UCHAR       lpszBlob[MAX_MSGINFO_LEN];    // file name on disk
+  //
+  // The format of this blob of information will be:
+  //
+  // String 0: LPSTR lpszSubject;            // Message Subject
+  // String 1: LPSTR lpszNoteText FILE NAME; // Message Text will be
+  //           stored into a temp file and this will be the pointer to that file.
+  // String 2: LPSTR lpszDateReceived;       // in YYYY/MM/DD HH:MM format
+  // String 3: LPSTR lpszConversationID;     // conversation thread ID
+  //
+  // The following are for the originator of the message. Only ONE of these.
+  //
+  // String 4: LPSTR lpszName;             // Originator name                           
+  // String 5: LPSTR lpszAddress;          // Originator address (optional)             
+  //
+  // The following strings are for the recipients for this message. There are
+  // MSG_nRecipCount of these in a row:
+  //
+  // for (i=0; i<MSG_nRecipCount; i++)
+  //      String x: LPSTR lpszName;             // Recipient N name                           
+  //      String x: LPSTR lpszAddress;          // Recipient N address (optional)             
+  //      String x: LPSTR lpszRecipClass        // recipient class - sprintf of ULONG
+  //
+  // Now, finally, add the attachments for this beast. There are MSG_nFileCount
+  // attachments so it would look like the following:
+  //
+  // for (i=0; i<MSG_nFileCount; i++)
+  //
+  //      String x: LPSTR lpszPathName // Fully qualified path of the attached file. 
+  //                                   // This path should include the disk drive letter and directory name.
+  //      String x: LPSTR lpszFileName // The display name for the attached file
+  //
+} MAPIReadMailType;
+
+typedef struct {
+  LHANDLE   lhSession;
+  ULONG     ulUIParam;
+  FLAGS     flFlags;
+  UCHAR     lpszCaption[MAX_MSGINFO_LEN];
+  DWORD     ipcWorked;      // Necessary for IPC check with Communicator
+  // The following is the "FLAT" representation of the (lpMapiRecipDesc lpRecips) 
+  // argument of this structure 
+  ULONG     nRecips;              // number of recips to start with...
+  ULONG     nNewRecips;           // number of recips returned...
+  UCHAR     lpszBlob[MAX_MSGINFO_LEN];    // file name for blob of information 
+                                          // that will live on disk. 
+  BYTE      dataBuf[1];           // For easy referencing
+  //
+  // The following contiguous chunk of memory is the buffer that holds 
+  // the recipients to load into the address picker...
+  //
+  // for (i=0; i<MSG_nRecipCount; i++)
+  //      String x: LPSTR lpszRecipClass (ULONG) // Recipient class - MAPI_TO, MAPI_CC, MAPI_BCC, MAPI_ORIG        
+  //      String x: LPSTR lpszName;     // Recipient N name                           
+  //      String x: LPSTR lpszAddress;  // Recipient N address (optional)             
+  //
+} MAPIAddressType;
+
+#endif    // _NSCPMAPI

mailnews/mapi/tests/makefile.win

@@ -0,0 +1,23 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..\..
+IGNORE_MANIFEST=1
+
+DIRS=mapitest
+
+include <$(DEPTH)\config\rules.mak>

mailnews/mapi/tests/mapitest/main.cpp

@@ -0,0 +1,220 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+#include <windows.h>
+#include <windowsx.h>
+#include <string.h>
+#include <stdlib.h>
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>
+#endif
+
+#include "port.h"
+#include "resource.h"
+
+#ifndef WM_PAINTICON
+#define WM_PAINTICON              0x26
+#endif // WM_PAINTICON
+
+/* 
+ * Forward Declarations...
+ */
+BOOL      InitInstance(HINSTANCE hInstance, int nCmdShow);
+BOOL CALLBACK LOADDS MyDlgProc(HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam);
+extern void ProcessCommand(HWND hWnd, int id, HWND hCtl, UINT codeNotify);
+BOOL      OpenMAPI(void);
+void      CloseMAPI(void);
+
+/*  
+ * Global variables
+ */
+HINSTANCE   hInst;
+HWND      hWnd;    
+
+#ifdef WIN16
+HICON	hIconApp;
+#endif
+
+char NEAR szAppName[] = "Netscape QA Helper";
+char NEAR szShortAppName[] = "QAHelper";
+char szClassName[] = "Netscape_QAHelper_Class_Name";
+
+void
+AppCleanup(void)
+{
+  extern void    DoMAPILogoff(HWND hWnd);
+  static BOOL isDone = FALSE;
+
+  if (isDone)
+    return;
+
+  extern LHANDLE    mapiSession;
+
+  if (mapiSession != 0)
+  {
+    DoMAPILogoff(hWnd);
+  }
+
+  CloseMAPI();
+  isDone = TRUE;
+}
+
+BOOL 
+InitInstance(HINSTANCE hInstance, int nCmdShow)
+{
+  /* Create a main window for this application instance.  */
+  hWnd = CreateDialog((HINSTANCE) hInstance, 
+            MAKEINTRESOURCE(ID_DIALOG),
+            (HWND) NULL, (DLGPROC) MyDlgProc);
+  
+  if (!hWnd)
+    return FALSE;
+  else
+    return TRUE;
+}
+
+BOOL InitApp(void)
+{
+#ifndef WIN16
+  WNDCLASS wc;
+  wc.style         = 0; 
+  wc.lpfnWndProc   = DefDlgProc; 
+  wc.cbClsExtra    = 0; 
+  wc.cbWndExtra    = DLGWINDOWEXTRA; 
+  wc.hInstance     = hInst; 
+  wc.hIcon         = LoadIcon(hInst, MAKEINTRESOURCE(ID_ICON_APP)); 
+  wc.hCursor       = LoadCursor(0, IDC_ARROW); 
+  wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
+  wc.lpszMenuName  = NULL; 
+  wc.lpszClassName = szClassName;
+  
+  if(!RegisterClass(&wc))
+    return FALSE;
+
+#else                
+  hIconApp = LoadIcon(hInst, MAKEINTRESOURCE(ID_ICON_APP));
+#endif
+  
+  return TRUE;
+} // end InitApp
+
+// Win Main 
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
+{
+  MSG     msg;
+  
+  hInst = hInstance;
+  
+  if (!InitApp()) 
+  { 
+    return FALSE;
+  }
+  
+  if (!InitInstance(hInstance, nCmdShow)) 
+  {    
+    return FALSE;
+  }
+
+  if (!OpenMAPI()) 
+  {    
+    return FALSE;
+  }
+
+  ShowWindow(hWnd, SW_SHOW);
+  
+  // Start the application
+  while ((GetMessage(&msg, (HWND) NULL, (UINT) NULL, (UINT) NULL)))
+  {
+    if(IsDialogMessage(hWnd, &msg))
+      continue;
+    
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+
+  return(msg.wParam);
+}
+
+BOOL CALLBACK LOADDS 
+MyDlgProc(HWND hWndMain, UINT wMsg, WPARAM wParam, LPARAM lParam) 
+{
+  switch (wMsg) 
+  {
+  case WM_INITDIALOG: 
+    {
+      hWnd = hWndMain;
+	    SetDlgItemText(hWnd, ID_EDIT_ROW, "0");
+    }
+    break;
+    
+  case WM_CLOSE:
+    {
+      DestroyWindow(hWnd);
+      break;
+    }
+
+  case WM_DESTROY:
+    {
+      AppCleanup();
+
+#ifndef WIN16
+      UnregisterClass(szClassName, hInst);
+#else              
+      // Destroy the 16 bit windows icon
+      if(hIconApp != 0)
+        DestroyIcon(hIconApp);
+#endif
+      
+      PostQuitMessage(0);
+      break;
+    }
+  case WM_COMMAND:
+    HANDLE_WM_COMMAND(hWnd, wParam, lParam, ProcessCommand);
+    break;
+    
+  case WM_QUERYDRAGICON:     
+#ifdef WIN16
+    return (BOOL)hIconApp;
+#endif
+    
+  case WM_PAINTICON:
+#ifdef WIN16    
+    SetClassWord(hWnd, GCW_HICON, 0);
+    
+    // fall trough
+  case WM_PAINT: 
+    {
+      if(!IsIconic(hWnd))
+        return FALSE;
+      PAINTSTRUCT ps;
+      HDC hDC = BeginPaint(hWnd, &ps);
+      SetMapMode(hDC, MM_TEXT);
+      DrawIcon(hDC, 2, 2, hIconApp);
+      EndPaint(hWnd, &ps);
+      break;
+    } 
+#endif //WIN16
+    break;    // RICHIE - if this is not here NT 3.51 Pukes!!!!  
+
+  default:
+    return FALSE;
+  }
+  
+  //~~av  return (DefWindowProc(hWnd, wMsg, wParam, lParam));
+  return TRUE;
+}

mailnews/mapi/tests/mapitest/mapimail.cpp

@@ -0,0 +1,753 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+#include <windows.h>
+#include <windowsx.h>   
+#include <string.h>
+#include <mapi.h>         
+#include <stdlib.h>
+
+#include "port.h"
+#include "resource.h"
+
+//
+// Variables...
+// 
+extern HINSTANCE   m_hInstMapi;
+extern LHANDLE     mapiSession;
+
+// 
+// Forward declarations...
+//
+void          DoMAPIFreeBuffer(HWND hWnd, LPVOID buf, BOOL alert);
+extern void   ShowMessage(HWND hWnd, LPSTR msg);
+void          DoMAPISendMail(HWND hWnd);
+void          DoMAPISendDocuments(HWND hWnd);
+void          DoMAPISaveMail(HWND hWnd);
+void          DoMAPIAddress(HWND hWnd);
+extern void   SetFooter(LPSTR msg);
+extern LPSTR  GetMAPIError(LONG errorCode);
+
+void 
+ProcessMailCommand(HWND hWnd, int id, HWND hCtl, UINT codeNotify) 
+{ 
+  switch (id) 
+  {
+  case IDCANCEL:
+    EndDialog(hWnd, 0);
+    break;
+
+  case ID_BUTTON_MAPISENDMAIL:
+    DoMAPISendMail(hWnd);
+    break;
+
+  case ID_BUTTON_MAPISENDDOCUMENTS:
+    DoMAPISendDocuments(hWnd);
+    break;
+
+  case ID_BUTTON_MAPISAVEMAIL:
+    DoMAPISaveMail(hWnd);
+    break;
+
+  case ID_BUTTON_MAPIADDRESS:
+    DoMAPIAddress(hWnd);
+    break;
+
+  default:
+    break;
+  }
+}
+
+BOOL CALLBACK LOADDS 
+MailDlgProc(HWND hWndMain, UINT wMsg, WPARAM wParam, LPARAM lParam) 
+{
+  switch (wMsg) 
+  {
+  case WM_INITDIALOG: 
+    break;
+
+  case WM_COMMAND:
+    HANDLE_WM_COMMAND(hWndMain, wParam, lParam, ProcessMailCommand);
+    break;
+
+  default:
+    return FALSE;
+  }
+  
+  return TRUE;
+}
+
+static LPSTR lpszDelimChar = ";";
+
+void
+TackItOn(LPSTR fileBuf, LPSTR nameBuf, LPSTR addOn)
+{
+  if (addOn[0] != '\0')
+  {
+    lstrcat(fileBuf, addOn);
+    lstrcat(fileBuf, lpszDelimChar);
+
+    lstrcat(nameBuf, "NAMEOF.FILE");
+    lstrcat(nameBuf, lpszDelimChar);
+  }
+}
+
+void
+DoMAPISendDocuments(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPISendDocuments) (ULONG ulUIParam, 
+          LPTSTR lpszDelimChar, LPTSTR lpszFullPaths, 
+          LPTSTR lpszFileNames, ULONG ulReserved);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPISendDocuments = GetProcAddress(m_hInstMapi, "MAPISENDDOCUMENTS"); 
+#else
+  (FARPROC&) lpfnMAPISendDocuments = GetProcAddress(m_hInstMapi, "MAPISendDocuments"); 
+#endif
+  
+  if (!lpfnMAPISendDocuments)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  char  msg[1024];
+  char  tempFileName[_MAX_PATH] = "";
+  char  lpszFullPaths[(_MAX_PATH + 1) * 4] = "";
+  char  lpszFileNames[(_MAX_PATH + 1) * 4] = "";
+
+  // Now get the names of the files to attach...
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH1, tempFileName, sizeof(tempFileName));
+  TackItOn(lpszFullPaths, lpszFileNames, tempFileName); 
+
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH2, tempFileName, sizeof(tempFileName));
+  TackItOn(lpszFullPaths, lpszFileNames, tempFileName); 
+
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH3, tempFileName, sizeof(tempFileName));
+  TackItOn(lpszFullPaths, lpszFileNames, tempFileName); 
+
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH4, tempFileName, sizeof(tempFileName));
+  TackItOn(lpszFullPaths, lpszFileNames, tempFileName); 
+
+  LONG  rc = (*lpfnMAPISendDocuments)
+        ( (ULONG) hWnd,        
+          lpszDelimChar, 
+          lpszFullPaths, 
+          lpszFileNames, 
+          0);
+
+  if (rc == SUCCESS_SUCCESS)
+  {
+    ShowMessage(hWnd, "Success with MAPISendDocuments");
+    SetFooter("MAPISendDocuments success");
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPISendDocuments\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPISendDocuments failed");
+  }
+}
+
+void
+FreeMAPIFile(lpMapiFileDesc pv)
+{
+  if (!pv)
+    return;
+
+  if (pv->lpszPathName != NULL)   
+    free(pv->lpszPathName);
+
+  if (pv->lpszFileName != NULL)   
+    free(pv->lpszFileName);
+}
+
+void
+FreeMAPIRecipient(lpMapiRecipDesc pv)
+{
+  if (!pv)
+    return;
+
+  if (pv->lpszName != NULL)   
+    free(pv->lpszName);
+
+  if (pv->lpszAddress != NULL)
+    free(pv->lpszAddress);
+
+  if (pv->lpEntryID != NULL)
+    free(pv->lpEntryID);  
+}
+
+void
+FreeMAPIMessage(lpMapiMessage pv)
+{
+  ULONG i;
+
+  if (!pv)
+    return;
+
+  if (pv->lpszSubject != NULL)
+    free(pv->lpszSubject);
+
+  if (pv->lpszNoteText)
+      free(pv->lpszNoteText);
+  
+  if (pv->lpszMessageType)
+    free(pv->lpszMessageType);
+  
+  if (pv->lpszDateReceived)
+    free(pv->lpszDateReceived);
+  
+  if (pv->lpszConversationID)
+    free(pv->lpszConversationID);
+  
+  if (pv->lpOriginator)
+    FreeMAPIRecipient(pv->lpOriginator);
+  
+  for (i=0; i<pv->nRecipCount; i++)
+  {
+    if (&(pv->lpRecips[i]) != NULL)
+    {
+      FreeMAPIRecipient(&(pv->lpRecips[i]));
+    }
+  }
+
+  if (pv->lpRecips != NULL)
+  {
+    free(pv->lpRecips);
+  }
+
+  for (i=0; i<pv->nFileCount; i++)
+  {
+    if (&(pv->lpFiles[i]) != NULL)
+    {
+      FreeMAPIFile(&(pv->lpFiles[i]));
+    }
+  }
+
+  if (pv->lpFiles != NULL)
+  {
+    free(pv->lpFiles);
+  }
+  
+  free(pv);
+  pv = NULL;
+}
+
+void
+DoMAPISendMail(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPISendMail) (LHANDLE lhSession, ULONG ulUIParam, 
+                  lpMapiMessage lpMessage, FLAGS flFlags, ULONG ulReserved);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPISendMail = GetProcAddress(m_hInstMapi, "MAPISENDMAIL"); 
+#else
+  (FARPROC&) lpfnMAPISendMail = GetProcAddress(m_hInstMapi, "MAPISendMail"); 
+#endif
+  
+  if (!lpfnMAPISendMail)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }          
+
+  FLAGS   flFlags = 0;
+  char    msg[512];
+  char    file1[_MAX_PATH] = "";
+  char    file2[_MAX_PATH] = "";
+  char    file3[_MAX_PATH] = "";
+  char    file4[_MAX_PATH] = "";
+  char    toAddr[128];
+  char    ccAddr[128];
+  char    bccAddr[128];
+  char    subject[128];
+  char    noteText[4096];
+  char    dateReceived[128] = "N/A";
+  char    threadID[128] = "N/A";;
+  char    origName[128] = "N/A";;
+  char    origAddress[128] = "N/A";;
+
+  GetDlgItemText(hWnd, ID_EDIT_TOADDRESS, toAddr, sizeof(toAddr));
+  GetDlgItemText(hWnd, ID_EDIT_CCADDRESS, ccAddr, sizeof(ccAddr));
+  GetDlgItemText(hWnd, ID_EDIT_BCCADDRESS, bccAddr, sizeof(bccAddr));
+  GetDlgItemText(hWnd, ID_EDIT_SUBJECT, subject, sizeof(subject));
+  GetDlgItemText(hWnd, ID_EDIT_NOTETEXT, noteText, sizeof(noteText));
+
+  // Do the one flag we support for this call...
+  if (BST_CHECKED == Button_GetCheck(GetDlgItem(hWnd, ID_CHECK_SHOWDIALOG)))
+  {
+    flFlags |= MAPI_DIALOG;
+  }
+
+  // Build the message to send off...
+  lpMapiMessage  msgPtr = (MapiMessage *)malloc(sizeof(MapiMessage));
+  if (msgPtr == NULL)
+  {
+    return;
+  }
+  
+  memset(msgPtr, 0, sizeof(MapiMessage)); 
+
+  //
+  // At this point, we need to populate the structure of information
+  // we are passing in via the *lppMessage
+  //
+
+  // Set all of the general information first!
+  msgPtr->lpszSubject = strdup(subject);
+  msgPtr->lpszNoteText = strdup(noteText);
+  msgPtr->lpszDateReceived = strdup(dateReceived);
+  msgPtr->lpszConversationID = strdup(threadID);
+  msgPtr->flFlags = flFlags;
+
+  // Now deal with the recipients of this message
+  DWORD       realRecips = 0;
+  if (toAddr[0] != '\0')    ++realRecips;
+  if (ccAddr[0] != '\0')    ++realRecips;
+  if (bccAddr[0] != '\0')   ++realRecips;
+
+  msgPtr->lpRecips = (lpMapiRecipDesc) malloc((size_t) (sizeof(MapiRecipDesc) * realRecips));
+  if (!msgPtr->lpRecips)
+  {
+    FreeMAPIMessage(msgPtr);
+    return;
+  }
+
+  msgPtr->nRecipCount = realRecips;
+  memset(msgPtr->lpRecips, 0, (size_t) (sizeof(MapiRecipDesc) * msgPtr->nRecipCount));
+
+  DWORD       rCount = 0;
+  if (toAddr[0] != '\0')
+  {
+    msgPtr->lpRecips[rCount].lpszName = strdup(toAddr);
+    msgPtr->lpRecips[rCount].lpszAddress = strdup(toAddr);
+    msgPtr->lpRecips[rCount].ulRecipClass = MAPI_TO;
+    rCount++;
+  }
+
+  if (ccAddr[0] != '\0')
+  {
+    msgPtr->lpRecips[rCount].lpszName = strdup(ccAddr);
+    msgPtr->lpRecips[rCount].lpszAddress = strdup(ccAddr);
+    msgPtr->lpRecips[rCount].ulRecipClass = MAPI_CC;    
+    rCount++;
+  }
+
+  if (bccAddr[0] != '\0')
+  {
+    msgPtr->lpRecips[rCount].lpszName = strdup(bccAddr);
+    msgPtr->lpRecips[rCount].lpszAddress = strdup(bccAddr);
+    msgPtr->lpRecips[rCount].ulRecipClass = MAPI_BCC;
+    rCount++;
+  }
+
+  // Now get the names of the files to attach...
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH1, file1, sizeof(file1));
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH2, file2, sizeof(file2));
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH3, file3, sizeof(file3));
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH4, file4, sizeof(file4));
+
+  DWORD       realFiles = 0;
+  if (file1[0] != '\0')    ++realFiles;
+  if (file2[0] != '\0')    ++realFiles;
+  if (file3[0] != '\0')    ++realFiles;
+  if (file4[0] != '\0')    ++realFiles;
+
+  // Now deal with the list of attachments! Since the nFileCount should be set
+  // correctly, this loop will automagically be correct
+  //
+  msgPtr->nFileCount = realFiles;
+  if (realFiles > 0)
+  {
+    msgPtr->lpFiles = (lpMapiFileDesc) malloc((size_t) (sizeof(MapiFileDesc) * realFiles));
+    if (!msgPtr->lpFiles)
+    {
+      FreeMAPIMessage(msgPtr);
+      return;
+    }
+
+    memset(msgPtr->lpFiles, 0, (size_t) (sizeof(MapiFileDesc) * msgPtr->nFileCount));
+  }
+
+  rCount = 0;
+  if (file1[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file1);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file1);
+    ++rCount;
+  }
+
+  if (file2[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file2);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file2);
+    ++rCount;
+  }
+
+  if (file3[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file3);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file3);
+    ++rCount;
+  }
+
+  if (file4[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file4);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file4);
+    ++rCount;
+  }
+
+  // Finally, make the call...
+  LONG  rc = (*lpfnMAPISendMail)
+           (mapiSession, 
+           (ULONG) hWnd, 
+           msgPtr, 
+           flFlags, 
+           0);
+
+  if (rc == SUCCESS_SUCCESS)
+  {
+    ShowMessage(hWnd, "Success with MAPISendMail");
+    SetFooter("MAPISendMail success");
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPISendMail\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPISendMail failed");
+  }
+
+  // Now cleanup and move on...
+  FreeMAPIMessage(msgPtr);
+}
+
+void
+DoMAPISaveMail(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPISaveMail) (LHANDLE lhSession, ULONG ulUIParam, 
+                  lpMapiMessage lpMessage, FLAGS flFlags, ULONG ulReserved,
+                  LPTSTR lpszMessageID);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPISaveMail = GetProcAddress(m_hInstMapi, "MAPISAVEMAIL"); 
+#else
+  (FARPROC&) lpfnMAPISaveMail = GetProcAddress(m_hInstMapi, "MAPISaveMail"); 
+#endif
+  
+  if (!lpfnMAPISaveMail)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }          
+
+  FLAGS   flFlags = 0;
+  char    msg[512];
+  char    file1[_MAX_PATH] = "";
+  char    file2[_MAX_PATH] = "";
+  char    file3[_MAX_PATH] = "";
+  char    file4[_MAX_PATH] = "";
+  char    toAddr[128];
+  char    ccAddr[128];
+  char    bccAddr[128];
+  char    subject[128];
+  char    noteText[4096];
+  char    dateReceived[128] = "N/A";
+  char    threadID[128] = "N/A";;
+  char    origName[128] = "N/A";;
+  char    origAddress[128] = "N/A";;
+
+  GetDlgItemText(hWnd, ID_EDIT_TOADDRESS, toAddr, sizeof(toAddr));
+  GetDlgItemText(hWnd, ID_EDIT_CCADDRESS, ccAddr, sizeof(ccAddr));
+  GetDlgItemText(hWnd, ID_EDIT_BCCADDRESS, bccAddr, sizeof(bccAddr));
+  GetDlgItemText(hWnd, ID_EDIT_SUBJECT, subject, sizeof(subject));
+  GetDlgItemText(hWnd, ID_EDIT_NOTETEXT, noteText, sizeof(noteText));
+
+  // Build the message to send off...
+  lpMapiMessage  msgPtr = (MapiMessage *)malloc(sizeof(MapiMessage));
+  if (msgPtr == NULL)
+  {
+    return;
+  }
+  
+  memset(msgPtr, 0, sizeof(MapiMessage)); 
+
+  //
+  // At this point, we need to populate the structure of information
+  // we are passing in via the *lppMessage
+  //
+
+  // Set all of the general information first!
+  msgPtr->lpszSubject = strdup(subject);
+  msgPtr->lpszNoteText = strdup(noteText);
+  msgPtr->lpszDateReceived = strdup(dateReceived);
+  msgPtr->lpszConversationID = strdup(threadID);
+  msgPtr->flFlags = flFlags;
+
+  // Now deal with the recipients of this message
+  DWORD       realRecips = 0;
+  if (toAddr[0] != '\0')    ++realRecips;
+  if (ccAddr[0] != '\0')    ++realRecips;
+  if (bccAddr[0] != '\0')   ++realRecips;
+
+  msgPtr->lpRecips = (lpMapiRecipDesc) malloc((size_t) (sizeof(MapiRecipDesc) * realRecips));
+  if (!msgPtr->lpRecips)
+  {
+    FreeMAPIMessage(msgPtr);
+    return;
+  }
+
+  msgPtr->nRecipCount = realRecips;
+  memset(msgPtr->lpRecips, 0, (size_t) (sizeof(MapiRecipDesc) * msgPtr->nRecipCount));
+
+  DWORD       rCount = 0;
+  if (toAddr[0] != '\0')
+  {
+    msgPtr->lpRecips[rCount].lpszName = strdup(toAddr);
+    msgPtr->lpRecips[rCount].lpszAddress = strdup(toAddr);
+    msgPtr->lpRecips[rCount].ulRecipClass = MAPI_TO;
+    rCount++;
+  }
+
+  if (ccAddr[0] != '\0')
+  {
+    msgPtr->lpRecips[rCount].lpszName = strdup(ccAddr);
+    msgPtr->lpRecips[rCount].lpszAddress = strdup(ccAddr);
+    msgPtr->lpRecips[rCount].ulRecipClass = MAPI_CC;    
+    rCount++;
+  }
+
+  if (bccAddr[0] != '\0')
+  {
+    msgPtr->lpRecips[rCount].lpszName = strdup(bccAddr);
+    msgPtr->lpRecips[rCount].lpszAddress = strdup(bccAddr);
+    msgPtr->lpRecips[rCount].ulRecipClass = MAPI_BCC;
+    rCount++;
+  }
+
+  // Now get the names of the files to attach...
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH1, file1, sizeof(file1));
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH2, file2, sizeof(file2));
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH3, file3, sizeof(file3));
+  GetDlgItemText(hWnd, ID_EDIT_ATTACH4, file4, sizeof(file4));
+
+  DWORD       realFiles = 0;
+  if (file1[0] != '\0')    ++realFiles;
+  if (file2[0] != '\0')    ++realFiles;
+  if (file3[0] != '\0')    ++realFiles;
+  if (file4[0] != '\0')    ++realFiles;
+
+  // Now deal with the list of attachments! Since the nFileCount should be set
+  // correctly, this loop will automagically be correct
+  //
+  msgPtr->nFileCount = realFiles;
+  if (realFiles > 0)
+  {
+    msgPtr->lpFiles = (lpMapiFileDesc) malloc((size_t) (sizeof(MapiFileDesc) * realFiles));
+    if (!msgPtr->lpFiles)
+    {
+      FreeMAPIMessage(msgPtr);
+      return;
+    }
+
+    memset(msgPtr->lpFiles, 0, (size_t) (sizeof(MapiFileDesc) * msgPtr->nFileCount));
+  }
+
+  rCount = 0;
+  if (file1[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file1);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file1);
+    ++rCount;
+  }
+
+  if (file2[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file2);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file2);
+    ++rCount;
+  }
+
+  if (file3[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file3);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file3);
+    ++rCount;
+  }
+
+  if (file4[0] != '\0')
+  {
+    msgPtr->lpFiles[rCount].lpszPathName = strdup((LPSTR)file4);
+    msgPtr->lpFiles[rCount].lpszFileName = strdup((LPSTR)file4);
+    ++rCount;
+  }
+
+  // Finally, make the call...
+  LONG  rc = (*lpfnMAPISaveMail)
+           (mapiSession, 
+           (ULONG) hWnd, 
+           msgPtr, 
+           flFlags, 
+           0, NULL);
+
+  if (rc == SUCCESS_SUCCESS)
+  {
+    ShowMessage(hWnd, "Success with MAPISaveMail");
+    SetFooter("MAPISaveMail success");
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPISaveMail\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPISaveMail failed");
+  }
+
+  // Now cleanup and move on...
+  FreeMAPIMessage(msgPtr);
+}
+
+void          
+DoMAPIAddress(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPIAddress) 
+                            (LHANDLE lhSession,
+                            ULONG ulUIParam,
+                            LPSTR lpszCaption,
+                            ULONG nEditFields,
+                            LPSTR lpszLabels,
+                            ULONG nRecips,
+                            lpMapiRecipDesc lpRecips,
+                            FLAGS flFlags,
+                            ULONG ulReserved,
+                            LPULONG lpnNewRecips,
+                            lpMapiRecipDesc FAR *lppNewRecips);
+
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIAddress = GetProcAddress(m_hInstMapi, "MAPIADDRESS"); 
+#else
+  (FARPROC&) lpfnMAPIAddress = GetProcAddress(m_hInstMapi, "MAPIAddress"); 
+#endif
+  
+  if (!lpfnMAPIAddress)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }          
+
+  DWORD   i;
+  FLAGS   flFlags = 0;
+  DWORD   addrCount = 0;
+  char    msg[512];
+  char    toAddr[128];
+  char    ccAddr[128];
+  char    bccAddr[128];
+
+  GetDlgItemText(hWnd, ID_EDIT_TOADDRESS, toAddr, sizeof(toAddr));
+  GetDlgItemText(hWnd, ID_EDIT_CCADDRESS, ccAddr, sizeof(ccAddr));
+  GetDlgItemText(hWnd, ID_EDIT_BCCADDRESS, bccAddr, sizeof(bccAddr));
+
+  if (toAddr[0]) ++addrCount;
+  if (ccAddr[0]) ++addrCount;
+  if (bccAddr[0]) ++addrCount;
+
+  lpMapiRecipDesc lpRecips = (lpMapiRecipDesc) malloc((size_t) (sizeof(MapiRecipDesc) * addrCount));
+  if (!lpRecips)
+  {
+    return;
+  }
+
+  memset(lpRecips, 0, (size_t) (sizeof(MapiRecipDesc) * addrCount));
+
+  DWORD       rCount = 0;
+  if (toAddr[0] != '\0')
+  {
+    lpRecips[rCount].lpszName = strdup("To Address Name");
+    lpRecips[rCount].lpszAddress = strdup(toAddr);
+    lpRecips[rCount].ulRecipClass = MAPI_TO;
+    rCount++;
+  }
+
+  if (ccAddr[0] != '\0')
+  {
+    lpRecips[rCount].lpszName = strdup("CC Address Name");
+    lpRecips[rCount].lpszAddress = strdup(ccAddr);
+    lpRecips[rCount].ulRecipClass = MAPI_CC;    
+    rCount++;
+  }
+
+  if (bccAddr[0] != '\0')
+  {
+    lpRecips[rCount].lpszName = strdup("BCC Address Name");
+    lpRecips[rCount].lpszAddress = strdup(bccAddr);
+    lpRecips[rCount].ulRecipClass = MAPI_BCC;
+    rCount++;
+  }
+  
+  ULONG             newRecips;
+  lpMapiRecipDesc   lpNewRecips;
+
+  // Finally, make the call...
+  LONG  rc = (*lpfnMAPIAddress)
+                     (mapiSession,
+                      0,
+                      "MAPI Test Address Picker",
+                      0,
+                      NULL,
+                      rCount,
+                      lpRecips,
+                      0,
+                      0,
+                      &newRecips,
+                      &lpNewRecips);
+  if (rc == SUCCESS_SUCCESS)
+  {
+    for (i=0; i<newRecips; i++)
+    {
+      char  tMsg[512];
+
+      wsprintf(tMsg, "User %d\nName=[%s]\nEmail=[%s]\nType=[%d]", 
+            i, 
+            lpNewRecips[i].lpszName, 
+            lpNewRecips[i].lpszAddress, 
+            lpNewRecips[i].ulRecipClass);
+      ShowMessage(hWnd, tMsg);
+    }
+
+    SetFooter("MAPIAddress success");
+
+    DoMAPIFreeBuffer(hWnd, lpNewRecips, TRUE);
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPIAddress\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPIAddress failed");
+  }
+
+  // Now cleanup and move on...
+  for (i=0; i<rCount; i++)
+  {
+    FreeMAPIRecipient(&(lpRecips[i]));
+  }
+}

mailnews/mapi/tests/mapitest/mapiproc.cpp

@@ -0,0 +1,813 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+#include <windows.h>
+#include <windowsx.h>      
+#include <string.h>
+
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>
+#endif
+
+#include "port.h"
+#include "resource.h"
+
+//
+// Variables...
+// 
+extern HINSTANCE  hInst;
+HINSTANCE         m_hInstMapi;
+LHANDLE           mapiSession = 0;
+
+// 
+// Forward declarations...
+//
+void    LoadNSCPVersionFunc(HWND hWnd);
+void    DoMAPILogon(HWND hWnd);
+void    DoMAPILogoff(HWND hWnd);
+void    DoMAPIFreeBuffer(HWND hWnd, LPVOID buf, BOOL alert);
+void    DoMAPISendMail(HWND hWnd);
+void    DoMAPISendDocuments(HWND hWnd);
+void    DoMAPIFindNext(HWND hWnd);
+void    DoMAPIReadMail(HWND hWnd);
+void    DoMAPIDeleteMail(HWND hWnd);
+void    DoMAPIDetails(HWND hWnd);
+void    DoMAPIResolveName(HWND hWnd);
+void    DoMAPIResolveNameFreeBuffer(HWND hWnd);
+void    SetFooter(LPSTR msg);
+void    DoMAPI_NSCP_Sync(HWND hWnd);
+LPSTR   GetMAPIError(LONG errorCode);
+extern void DisplayMAPIReadMail(HWND hWnd, lpMapiMessage msgPtr);
+lpMapiMessage   GetMessage(HWND hWnd, LPSTR id);
+
+void
+SetFooter(LPSTR msg)
+{
+  extern HWND   hWnd;
+
+  SetDlgItemText(hWnd, ID_STATIC_RESULT, msg);
+}
+
+char FAR *
+GetMAPIError(LONG errorCode)
+{
+  static char FAR msg[128];
+
+  switch (errorCode) {                            
+  case MAPI_E_FAILURE:
+    lstrcpy(msg, "General MAPI Failure");
+    break;
+
+  case MAPI_E_INSUFFICIENT_MEMORY:
+    strcpy(msg, "Insufficient Memory");
+    break;
+
+  case MAPI_E_LOGIN_FAILURE:
+    strcpy(msg, "Login Failure");
+    break;
+
+  case MAPI_E_TOO_MANY_SESSIONS:
+    strcpy(msg, "Too many MAPI sessions");
+    break;
+
+  case MAPI_E_INVALID_SESSION:
+    strcpy(msg, "Invalid Session!");
+    break;
+
+  case MAPI_E_INVALID_MESSAGE:
+    strcpy(msg, "Message identifier was bad!");
+    break;
+
+  case MAPI_E_NO_MESSAGES:
+    strcpy(msg, "No messages were found!");
+    break;
+
+  case MAPI_E_ATTACHMENT_WRITE_FAILURE:
+    strcpy(msg, "Attachment write failure!");
+    break;
+
+  case MAPI_E_DISK_FULL:
+    strcpy(msg, "Attachment write failure! DISK FULL");
+    break;
+
+  case MAPI_E_AMBIGUOUS_RECIPIENT:
+    strcpy(msg, "Recipient requested is not a unique address list entry.");
+    break;
+
+  case MAPI_E_UNKNOWN_RECIPIENT:
+    strcpy(msg, "Recipient requested does not exist.");
+    break;
+
+  case MAPI_E_NOT_SUPPORTED:
+    strcpy(msg, "Not supported by messaging system");
+    break;
+
+  case SUCCESS_SUCCESS:
+    strcpy(msg, "Success on MAPI operation");
+    break;
+
+  case MAPI_E_INVALID_RECIPS:
+    strcpy(msg, "Recipient specified in the lpRecip parameter was\nunknown. No dialog box was displayed.");
+    break;
+
+  case MAPI_E_ATTACHMENT_OPEN_FAILURE:
+    strcpy(msg, "One or more files could not be located. No message was sent.");    
+    break;
+
+  case MAPI_E_ATTACHMENT_NOT_FOUND:
+    strcpy(msg, "The specified attachment was not found. No message was sent.");
+    break;
+
+  case MAPI_E_BAD_RECIPTYPE:
+    strcpy(msg, "The type of a recipient was not MAPI_TO, MAPI_CC, or MAPI_BCC. No message was sent.");
+    break;
+
+  default:
+    strcpy(msg, "Unknown MAPI Return Code");
+    break;
+  }
+
+  return((LPSTR) &(msg[0]));
+}
+
+void
+ShowMessage(HWND hWnd, LPSTR msg)
+{
+  MessageBox(hWnd, msg, "Info Message", MB_ICONINFORMATION);
+}
+
+BOOL
+OpenMAPI(void)
+{
+#ifdef WIN16
+	m_hInstMapi = LoadLibrary("Y:\\ns\\cmd\\winfe\\mapi\\MAPI.DLL");	
+#else
+  m_hInstMapi = LoadLibrary(".\\COMPONENTS\\MAPI32.DLL");
+#endif
+
+  if (!m_hInstMapi)
+  {
+    ShowMessage(NULL, "Error Loading the MAPI DLL...Probably not found!");
+    return(FALSE);
+  }
+
+  return(TRUE);
+}
+
+void
+CloseMAPI(void)
+{
+  if(m_hInstMapi)
+  {
+    FreeLibrary(m_hInstMapi);
+  }
+}
+
+void 
+ProcessCommand(HWND hWnd, int id, HWND hCtl, UINT codeNotify) 
+{ 
+  switch (id) 
+  {
+  case ID_BUTTON_SYNC:
+    DoMAPI_NSCP_Sync(hWnd);
+    break;
+
+  case ID_BUTTON_NSCPVERSION:
+    LoadNSCPVersionFunc(hWnd);
+    break;
+
+  case ID_BUTTON_LOGON:
+    DoMAPILogon(hWnd);
+    break;
+
+  case ID_BUTTON_LOGOFF:
+    DoMAPILogoff(hWnd);
+    break;
+
+  case ID_BUTTON_FINDNEXT:
+  case ID_MENU_MAPIFINDNEXT:
+    DoMAPIFindNext(hWnd);
+    break;
+
+  case ID_BUTTON_READMAIL:
+  case ID_MENU_MAPIREADMAIL:
+    DoMAPIReadMail(hWnd);
+    break;
+
+  case ID_BUTTON_MAIL:
+    {
+    extern CALLBACK LOADDS 
+           MailDlgProc(HWND hWndMain, UINT wMsg, WPARAM wParam, LPARAM lParam);
+
+    DialogBox(hInst, MAKEINTRESOURCE(ID_DIALOG_MAIL), hWnd, 
+      (DLGPROC)MailDlgProc);
+    }
+    break;
+
+  case ID_BUTTON_DELETEMAIL:
+  case ID_MENU_MAPIDELETEMAIL:
+    DoMAPIDeleteMail(hWnd);
+    break;
+
+  case ID_MENU_MYEXIT:
+	  DestroyWindow(hWnd);
+	  break;
+
+  case ID_BUTTON_CLEAR:
+  case ID_MENU_CLEARRESULTS:
+    ListBox_ResetContent(GetDlgItem(hWnd, ID_LIST_RESULT));      
+	  break;
+
+  case ID_BUTTON_FREEBUFFER:
+    DoMAPIResolveNameFreeBuffer(hWnd);
+    break;
+
+  case ID_BUTTON_RESOLVENAME:
+    DoMAPIResolveName(hWnd);
+    break;
+
+  case ID_BUTTON_DETAILS:
+    DoMAPIDetails(hWnd);
+    break;
+
+  case ID_MENU_MYABOUT:
+	  MessageBox(hWnd,	
+			  "Netscape MAPI Test Harness\nWritten by: Rich Pizzarro (rhp@netscape.com)",	
+			  "About",
+			  MB_ICONINFORMATION);
+	  break;
+  
+  default:
+    break;
+  }
+}
+
+void
+DoMAPILogon(HWND hWnd)
+{
+  char  msg[1024];
+  char  user[128] = "";
+  char  pw[128] = "";
+
+  // Get Address of MAPI function...
+  ULONG (FAR PASCAL *lpfnMAPILogon)(ULONG, LPSTR, LPSTR, FLAGS, ULONG, LPLHANDLE);   
+  
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPILogon = GetProcAddress(m_hInstMapi, "MAPILOGON"); 
+#else
+  (FARPROC&) lpfnMAPILogon = GetProcAddress(m_hInstMapi, "MAPILogon"); 
+#endif
+  
+  if (!lpfnMAPILogon)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  GetDlgItemText(hWnd, ID_EDIT_USERNAME, user, sizeof(user));
+  GetDlgItemText(hWnd, ID_EDIT_PW, pw, sizeof(pw));
+
+  LONG  rc = (*lpfnMAPILogon)((ULONG) hWnd, user, pw, 
+                  MAPI_FORCE_DOWNLOAD | MAPI_NEW_SESSION, 0, &mapiSession);
+  if (rc == SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "Success with session = %d", mapiSession);
+    ShowMessage(hWnd, msg);
+    SetFooter("Logon success");
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from Logon\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+    ShowMessage(hWnd, msg);
+    SetFooter("Logon failed");
+  }
+}
+
+void
+DoMAPILogoff(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPILogoff) ( LHANDLE lhSession, ULONG ulUIParam, 
+                                FLAGS flFlags, ULONG ulReserved);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPILogoff = GetProcAddress(m_hInstMapi, "MAPILOGOFF"); 
+#else
+  (FARPROC&) lpfnMAPILogoff = GetProcAddress(m_hInstMapi, "MAPILogoff"); 
+#endif
+  
+  if (!lpfnMAPILogoff)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  char  msg[1024];
+  LONG  rc = (*lpfnMAPILogoff)(mapiSession, (ULONG) hWnd, 0, 0);
+  if (rc == SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "Successful logoff");
+    ShowMessage(hWnd, msg);
+    SetFooter(msg);
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from Logoff\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    ShowMessage(hWnd, msg);
+    SetFooter("Logoff failed");
+  }
+
+  mapiSession = 0;
+}
+
+void
+DoMAPIFreeBuffer(HWND hWnd, LPVOID buf, BOOL alert)
+{
+  ULONG (FAR PASCAL *lpfnMAPIFreeBuffer) (LPVOID lpBuffer);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIFreeBuffer = GetProcAddress(m_hInstMapi, "MAPIFREEBUFFER"); 
+#else
+  (FARPROC&) lpfnMAPIFreeBuffer = GetProcAddress(m_hInstMapi, "MAPIFreeBuffer"); 
+#endif
+  
+  if (!lpfnMAPIFreeBuffer)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  char  msg[1024];
+  LONG  rc = (*lpfnMAPIFreeBuffer)(buf);
+#ifdef WIN32
+  if (rc == S_OK)
+#else
+  if (rc == SUCCESS_SUCCESS)
+#endif
+  {
+    wsprintf(msg, "Successful Free Buffer Operation");
+    if (alert)
+      ShowMessage(hWnd, msg);
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from Logoff", rc);
+    ShowMessage(hWnd, msg);
+  }
+}
+
+void
+DoMAPIFindNext(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPIFindNext) (LHANDLE lhSession, ULONG ulUIParam, 
+           LPTSTR lpszMessageType, LPTSTR lpszSeedMessageID, FLAGS flFlags, 
+           ULONG ulReserved, LPTSTR lpszMessageID);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIFindNext = GetProcAddress(m_hInstMapi, "MAPIFINDNEXT"); 
+#else
+  (FARPROC&) lpfnMAPIFindNext = GetProcAddress(m_hInstMapi, "MAPIFindNext"); 
+#endif
+
+  if (!lpfnMAPIFindNext)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  // Clear the list before we start...
+  ListBox_ResetContent(GetDlgItem(hWnd, ID_LIST_RESULT));
+
+  char  msg[1024];
+  char  messageID[512];
+  LONG  rc;                                                               
+#ifdef WIN32
+  FLAGS	flags = MAPI_GUARANTEE_FIFO | MAPI_LONG_MSGID | MAPI_UNREAD_ONLY;
+#else                                                                     	
+  FLAGS	flags = MAPI_GUARANTEE_FIFO | MAPI_UNREAD_ONLY;
+#endif
+  
+  while ( (rc = (*lpfnMAPIFindNext) (mapiSession, 
+           (ULONG) hWnd, 
+           NULL, 
+           NULL, 
+		   flags,
+           0,
+           messageID)) == SUCCESS_SUCCESS)
+  {
+      // 
+
+      lpMapiMessage mapiMsg = GetMessage(hWnd, messageID);
+      if (mapiMsg != NULL)
+      {
+        wsprintf(msg, "%s: \"%s\" Sender: %s", 
+                  messageID, 
+                  mapiMsg->lpszSubject, 
+                  mapiMsg->lpOriginator->lpszName);
+        DoMAPIFreeBuffer(hWnd, mapiMsg, FALSE);
+      }
+      else
+      {
+        lstrcpy(msg, messageID);
+      }
+
+      ListBox_InsertString(GetDlgItem(hWnd, ID_LIST_RESULT), 0, msg);
+  }
+
+  wsprintf(msg, "Enumeration ended: Return code %d from MAPIFindNext\nCondition=[%s]", 
+                    rc, GetMAPIError(rc));
+  ShowMessage(hWnd, msg);
+  SetFooter("Enumeration ended");
+}
+
+void
+DoMAPIReadMail(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPIReadMail) (LHANDLE lhSession, ULONG ulUIParam, 
+           LPTSTR lpszMessageID, FLAGS flFlags, ULONG ulReserved, 
+           lpMapiMessage FAR * lppMessage);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIReadMail = GetProcAddress(m_hInstMapi, "MAPIREADMAIL"); 
+#else
+  (FARPROC&) lpfnMAPIReadMail = GetProcAddress(m_hInstMapi, "MAPIReadMail"); 
+#endif
+  
+  if (!lpfnMAPIReadMail)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  char            msg[1024];
+  char            lpszMessageID[512];
+  lpMapiMessage   lpMessage = NULL;
+  FLAGS           flFlags = 0;
+
+  DWORD selected = ListBox_GetCurSel(GetDlgItem(hWnd, ID_LIST_RESULT));
+  if (selected == LB_ERR)
+  {
+    ShowMessage(hWnd, "You need to select a valid message. Make sure\nyou have done a MAPIFindNext and selected\none of the resulting messages.");
+    return;
+  }
+
+  ListBox_GetText(GetDlgItem(hWnd, ID_LIST_RESULT), selected, lpszMessageID);
+
+  // Do the various flags for this call...
+  if (BST_CHECKED == Button_GetCheck(GetDlgItem(hWnd, IDC_CHECK_BODYASFILE)))
+  {
+    flFlags |= MAPI_BODY_AS_FILE;
+  }
+
+  if (BST_CHECKED == Button_GetCheck(GetDlgItem(hWnd, IDC_CHECK_ENVELOPEONLY)))
+  {
+    flFlags |= MAPI_ENVELOPE_ONLY;
+  }
+
+  if (BST_CHECKED == Button_GetCheck(GetDlgItem(hWnd, IDC_CHECK_PEEK)))
+  {
+    flFlags |= MAPI_PEEK;
+  }
+  
+  if (BST_CHECKED == Button_GetCheck(GetDlgItem(hWnd, IDC_CHECK_SUPPRESSATTACH)))
+  {
+    flFlags |= MAPI_SUPPRESS_ATTACH;
+  }
+
+  char *ptr = strchr( (const char *) lpszMessageID, ':');
+  if (ptr) *ptr = '\0';
+
+  LONG  rc = (*lpfnMAPIReadMail)
+          (mapiSession, 
+          (ULONG) hWnd, 
+          lpszMessageID,
+          flFlags,
+          0, 
+          &lpMessage);
+
+  // Deal with error up front and return if need be...
+  if (rc != SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPIReadMail\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    ShowMessage(hWnd, msg);
+    SetFooter("ReadMail failed");
+    return;
+  }
+
+  // Now display the message and then return...
+  DisplayMAPIReadMail(hWnd, lpMessage);
+  DoMAPIFreeBuffer(hWnd, lpMessage, TRUE);
+}
+
+void
+DoMAPIDeleteMail(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPIDeleteMail) (LHANDLE lhSession, ULONG ulUIParam, 
+            LPTSTR lpszMessageID, FLAGS flFlags, ULONG ulReserved);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIDeleteMail = GetProcAddress(m_hInstMapi, "MAPIDELETEMAIL"); 
+#else
+  (FARPROC&) lpfnMAPIDeleteMail = GetProcAddress(m_hInstMapi, "MAPIDeleteMail"); 
+#endif
+  
+  if (!lpfnMAPIDeleteMail)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+ 
+  char            msg[1024];
+  char            lpszMessageID[512];
+  lpMapiMessage   lpMessage = NULL;
+
+  DWORD selected = ListBox_GetCurSel(GetDlgItem(hWnd, ID_LIST_RESULT));
+  if (selected == LB_ERR)
+  {
+    ShowMessage(hWnd, "You need to select a valid message. Make sure\nyou have done a MAPIFindNext and selected\none of the resulting messages.");
+    return;
+  }
+
+  ListBox_GetText(GetDlgItem(hWnd, ID_LIST_RESULT), selected, lpszMessageID);
+
+  char *ptr = strchr( (const char *) lpszMessageID, ':');
+  if (ptr) *ptr = '\0';
+
+  LONG  rc = (*lpfnMAPIDeleteMail)
+          (mapiSession, 
+          (ULONG) hWnd,
+          lpszMessageID, 
+          0,
+          0);
+  
+  // Deal with the return code...
+  if (rc == SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "Successful deletion");
+    ShowMessage(hWnd, msg);
+    SetFooter(msg);  
+
+    // If it worked, refresh the list...
+    ShowMessage(hWnd, "The message list will now be refreshed\nsince one message was deleted.");
+    DoMAPIFindNext(hWnd);
+  }
+  else
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPIDeleteMail\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    ShowMessage(hWnd, msg);
+    SetFooter("Logoff failed");
+  }
+}
+
+// This is for the name lookup stuff...
+lpMapiRecipDesc       lpRecip = NULL;
+
+void
+DoMAPIResolveName(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPIResolveName) (LHANDLE lhSession, ULONG ulUIParam, 
+            LPTSTR lpszName, FLAGS flFlags, ULONG ulReserved, 
+            lpMapiRecipDesc FAR * lppRecip); 
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIResolveName = GetProcAddress(m_hInstMapi, "MAPIRESOLVENAME"); 
+#else
+  (FARPROC&) lpfnMAPIResolveName = GetProcAddress(m_hInstMapi, "MAPIResolveName"); 
+#endif
+  
+  if (!lpfnMAPIResolveName)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  if (lpRecip != NULL)
+  {
+    ShowMessage(hWnd, "We need to free memory from a previous call...");
+    DoMAPIFreeBuffer(hWnd, lpRecip, TRUE);
+    lpRecip = NULL;
+  }
+
+  char        userName[512];
+  char        msg[1024];
+  FLAGS       flFlags = 0;    // We support none...
+
+  GetDlgItemText(hWnd, IDC_EDIT_RESOLVENAME, userName, sizeof(userName));
+  LONG  rc = (*lpfnMAPIResolveName)
+                      (mapiSession, 
+                       (ULONG) hWnd, 
+                       userName,
+                       flFlags, 
+                       0, 
+                       &lpRecip);
+
+  // Deal with error up front and return if need be...
+  if (rc != SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "FAILURE: Return code %d from DoMAPIResolveName\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    ShowMessage(hWnd, msg);
+    SetFooter("DoMAPIResolveName failed");
+    return;
+  }
+
+  // If we get here, we should probably show the information that we
+  // got back
+  wsprintf(msg, "Received information for %s\nName=[%s]\nAddress=[%s]\nID=[%s]",
+    userName, lpRecip->lpszName, lpRecip->lpszAddress, (LPSTR) lpRecip->lpEntryID);
+  ShowMessage(hWnd, msg);
+}
+
+void    
+DoMAPIResolveNameFreeBuffer(HWND hWnd)
+{
+  if (lpRecip == NULL)
+  {
+    ShowMessage(hWnd, "There is no memory allocated from MAPIResolveName()\nto be freed. Request ignored.");
+  }
+  else
+  {
+    DoMAPIFreeBuffer(hWnd, lpRecip, TRUE);
+    lpRecip = NULL;
+  }
+}
+
+void
+DoMAPIDetails(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnMAPIDetails) (LHANDLE lhSession, ULONG ulUIParam, 
+            lpMapiRecipDesc lpRecip, FLAGS flFlags, ULONG ulReserved);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIDetails = GetProcAddress(m_hInstMapi, "MAPIDetails"); 
+#else
+  (FARPROC&) lpfnMAPIDetails = GetProcAddress(m_hInstMapi, "MAPIDetails"); 
+#endif
+  
+  if (!lpfnMAPIDetails)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  char        msg[1024];
+  FLAGS       flFlags = 0;    // We really don't support these...
+
+  LONG  rc = (*lpfnMAPIDetails)
+              (mapiSession, 
+              (ULONG) hWnd,
+               lpRecip,
+               flFlags,
+               0);
+
+  if (rc == SUCCESS_SUCCESS)
+  {
+
+    wsprintf(msg, "MAPIDetails call succeeded");
+    ShowMessage(hWnd, msg);
+    SetFooter(msg);
+  }
+  else
+  {
+
+    wsprintf(msg, "FAILURE: Return code %d from MAPIDetails\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    if (lpRecip == NULL)
+    {
+      lstrcat(msg, "\nNOTE: There is no valid pointer from a MAPIResolveName()\ncall to show details about.");
+    }
+
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPIDetails failed");
+  }
+}
+
+lpMapiMessage 
+GetMessage(HWND hWnd, LPSTR id)
+{
+  ULONG (FAR PASCAL *lpfnMAPIReadMail) (LHANDLE lhSession, ULONG ulUIParam, 
+           LPTSTR lpszMessageID, FLAGS flFlags, ULONG ulReserved, 
+           lpMapiMessage FAR * lppMessage);
+
+#ifdef WIN16		
+  (FARPROC&) lpfnMAPIReadMail = GetProcAddress(m_hInstMapi, "MAPIREADMAIL"); 
+#else
+  (FARPROC&) lpfnMAPIReadMail = GetProcAddress(m_hInstMapi, "MAPIReadMail"); 
+#endif
+  
+  if (!lpfnMAPIReadMail)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return NULL;
+  }
+
+  char            msg[1024];
+  lpMapiMessage   lpMessage = NULL;
+  FLAGS           flFlags = 0;
+
+  flFlags |= MAPI_ENVELOPE_ONLY;
+  LONG  rc = (*lpfnMAPIReadMail)
+          (mapiSession, 
+          (ULONG) hWnd, 
+          id,
+          flFlags,
+          0, 
+          &lpMessage);
+
+  // Deal with error up front and return if need be...
+  if (rc != SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPIReadMail\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    ShowMessage(hWnd, msg);
+    SetFooter("ReadMail failed");
+    return NULL;
+  }
+
+  return(lpMessage);
+}
+
+void    
+LoadNSCPVersionFunc(HWND hWnd)
+{
+  ULONG (FAR PASCAL *lpfnLoadNSCPVersion) ( void );
+
+#ifdef WIN16		
+  (FARPROC&) lpfnLoadNSCPVersion = GetProcAddress(m_hInstMapi, "MAPIGETNERSCAPEVERSION"); 
+#else
+  (FARPROC&) lpfnLoadNSCPVersion = GetProcAddress(m_hInstMapi, "MAPIGetNetscapeVersion"); 
+#endif
+  
+  if (!lpfnLoadNSCPVersion)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPIGetNetscapeVersion() function.");
+  }
+  else
+  {
+    ShowMessage(hWnd, "MAPIGetNetscapeVersion() function was FOUND!");
+  }
+  return;
+}
+
+void    
+DoMAPI_NSCP_Sync(HWND hWnd)
+{
+ULONG (FAR PASCAL *lpfnNSCPSync) ( LHANDLE lhSession,
+                                          ULONG ulReserved );
+#ifdef WIN16		
+  (FARPROC&) lpfnNSCPSync = GetProcAddress(m_hInstMapi, "MAPI_NSCP_SYNCHRONIZECLIENT"); 
+#else
+  (FARPROC&) lpfnNSCPSync = GetProcAddress(m_hInstMapi, "MAPI_NSCP_SynchronizeClient"); 
+#endif
+
+  if (!lpfnNSCPSync)
+  {
+    ShowMessage(hWnd, "Unable to locate MAPI function.");
+    return;
+  }
+
+  LONG  rc = (*lpfnNSCPSync) (mapiSession, 0);
+
+  char    msg[256];
+
+  // Deal with error up front and return if need be...
+  if (rc != SUCCESS_SUCCESS)
+  {
+    wsprintf(msg, "FAILURE: Return code %d from MAPI_NSCP_SynchronizeClient\nError=[%s]", 
+                      rc, GetMAPIError(rc));
+
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPI_NSCP_SynchronizeClient failed");
+    return;
+  }
+  else
+  {
+    wsprintf(msg, "Success for MAPI_NSCP_SynchronizeClient");    
+    ShowMessage(hWnd, msg);
+    SetFooter("MAPI_NSCP_SynchronizeClient success");
+  }
+}

mailnews/mapi/tests/mapitest/port.h

@@ -0,0 +1,284 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+
+#ifndef PORT_H
+#define PORT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*****************************************************************\
+ *                                                               *
+ *  PORT.H                                                       *
+ *                                                               *
+ *  Win16/Win32 portability stuff                                *
+ *                                                               *
+ *  A.Sokolsky                                                   *
+ *      3.10.94 distilled into this header                       *
+ *                                                               *
+\*****************************************************************/
+
+/*
+ * calling conventions
+ */
+#include <assert.h>
+                                                      
+                                                      
+#ifndef CDECL
+#define CDECL __cdecl
+#endif  // CDECL
+
+#ifndef PASCAL
+#define PASCAL __pascal
+#endif  // PASCAL
+
+#ifdef FASTCALL
+#error FASTCALL defined
+#endif // FASTCALL
+
+
+#ifdef NDEBUG
+#define FASTCALL __fastcall
+#else
+#define FASTCALL PASCAL
+#endif // NDEBUG   
+
+
+
+#ifndef HWND2DWORD
+#  ifdef WIN32
+#    define HWND2DWORD(X_hWnd) ( (DWORD)(X_hWnd) )
+#  else // WIN16
+#    define HWND2DWORD(X_hWnd) ( (DWORD)MAKELONG(((WORD)(X_hWnd)), 0) )
+#  endif
+#endif // HWND2DWORD
+
+
+/*
+ * WIN16 - WIN32 compatibility stuff
+ */
+
+#ifdef WIN32
+
+# define DLLEXPORT    __declspec( dllexport )
+# define EXPORT
+# define LOADDS
+# define HUGE
+# ifndef FAR
+#  define FAR
+# endif // FAR
+# ifndef NEAR
+#  define NEAR
+# endif // NEAR 
+# ifdef UNICODE
+#  define SIZEOF(x)   (sizeof(x)/sizeof(WCHAR))
+# else
+#  define SIZEOF(x)   sizeof(x)
+# endif
+
+#else  // !WIN32 == WIN16
+
+# define DLLEXPORT    
+# define EXPORT       __export
+# define LOADDS       __loadds
+# define HUGE         __huge
+# ifndef FAR
+#   define FAR        __far
+#   define NEAR       __near
+# endif  // FAR
+# define CONST const
+# define SIZEOF(x)    sizeof(x)
+# define CHAR char
+# define TCHAR char
+# define WCHAR char
+# ifndef LPTSTR
+#   define LPTSTR LPSTR
+# endif
+# ifndef LPCTSTR 
+#   define LPCTSTR LPCSTR
+# endif
+# define UNREFERENCED_PARAMETER(x) x;
+# ifndef TEXT
+#   define TEXT(x) x
+# endif
+# define GetWindowTextW GetWindowText
+# define lstrcpyW lstrcpy   
+
+# define BN_DBLCLK BN_DOUBLECLICKED // ~~MRJ needed for custom control.
+// ~~MRJ begin Win95 backward compat section
+# define LPWSTR LPSTR
+# define LPCWSTR LPCSTR
+
+// button check state for WIN16
+#ifndef BST_UNCHECKED
+#define BST_UNCHECKED      0x0000
+#endif
+
+#ifndef BST_CHECKED
+#define BST_CHECKED        0x0001
+#endif
+
+
+#ifndef WIN95_COMPAT
+#  define WIN95_COMPAT
+#endif
+
+// ~~MRJ end Win95 compat section.
+
+// critical section API stubs
+typedef DWORD CRITICAL_SECTION;
+typedef CRITICAL_SECTION FAR * LPCRITICAL_SECTION; 
+#ifdef __cplusplus
+inline void InitializeCriticalSection(LPCRITICAL_SECTION lpSection) {}
+inline void DeleteCriticalSection(LPCRITICAL_SECTION lpSection) {}
+inline void EnterCriticalSection(LPCRITICAL_SECTION lpSection) {}
+inline void LeaveCriticalSection(LPCRITICAL_SECTION lpSection) {} 
+#endif // __cplusplus 
+
+// Added for nssock16 ---Neeti
+#ifndef ZeroMemory
+#include <memory.h>
+#define ZeroMemory(PTR, SIZE) memset(PTR, 0, SIZE)
+#endif // ZeroMemory
+
+#endif // WIN16
+
+/*
+ * unix - windows compatibility stuff
+ */
+typedef DWORD u_int32;
+typedef WORD  u_int16;
+typedef BYTE  u_int8;
+#ifdef WIN32
+typedef short int Bool16;
+#else  // WIN16
+typedef BOOL  Bool16;
+#endif // WIN16
+
+/*
+ * Cross Platform Compatibility
+ */
+#ifndef UNALIGNED
+# ifdef _M_ALPHA
+#  define UNALIGNED __unaligned
+# else  // !_M_ALPHA
+#  define UNALIGNED
+# endif // !_M_ALPHA
+#endif  // UNALIGNED
+
+//
+// RICHIE - for the Alpha port
+//
+#ifdef _M_ALPHA
+# undef pascal
+# undef PASCAL
+# if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+#  define pascal __stdcall
+#  define PASCAL __stdcall
+# else
+#  define PASCAL
+# endif
+#endif
+
+
+/*
+ * Useful Types
+ */
+typedef char HUGE *HPSTR;
+typedef const char HUGE *HPCSTR;
+typedef unsigned char HUGE *HPBYTE;
+typedef WORD HUGE *HPWORD;
+typedef UINT FAR *LPUINT;
+typedef BOOL (CALLBACK *USERABORTPROC)();
+typedef BOOL (CALLBACK *PROGRESSPROC)(UINT uPos, UINT uRange);
+typedef int INT;   // ~~MRJ a function needed this defined.
+typedef MINMAXINFO FAR *LPMINMAXINFO; // ~~MRJ 
+
+//
+// stuff missing from windows.h
+//
+#ifndef MAKEWORD
+#define MAKEWORD(low, high)    ((WORD)(((BYTE)(low)) | (((WORD)((BYTE)(high))) << 8)))
+#endif // MAKEWORD
+
+#ifdef WIN32
+# ifndef hmemcpy
+#  define hmemcpy memcpy
+# endif // !defined(hmemcpy)
+# define _fmemset memset
+
+# include <malloc.h>
+
+#ifdef __cplusplus
+
+inline BOOL IsGDIObject(HGDIOBJ hObj) { return (hObj != 0); }
+inline void *_halloc(long num, unsigned int size) { return malloc(num * size); }
+inline void _hfree( void *memblock ) { free(memblock); } 
+/*
+inline BOOL IsInstance(HINSTANCE hInst) {
+# ifdef WIN32
+    return (hInst != 0);
+# else // WIN16
+    return (hInst > HINSTANCE_ERROR);
+# endif  
+}  
+*/
+
+#endif // __cplusplus
+
+  WINUSERAPI HANDLE WINAPI LoadImageA(HINSTANCE, LPCSTR, UINT, int, int, UINT);
+
+#endif // WIN32
+
+#ifdef __cplusplus 
+inline BOOL IsInstance(HINSTANCE hInst) {
+# ifdef WIN32
+    return (hInst != 0);
+# else // WIN16
+    return (hInst > HINSTANCE_ERROR);
+# endif  
+} 
+inline void SetWindowSmallIcon(HINSTANCE hInst, HWND hWnd, UINT uIconResourceId) {
+#ifdef WIN32
+# ifndef WM_SETICON
+#   define WM_SETICON 0x0080
+# endif  // WM_SETICON
+# ifndef IMAGE_ICON
+#   define IMAGE_ICON 1
+# endif
+  assert(IsWindow(hWnd));
+  HICON hIcon = (HICON)LoadImageA(hInst, MAKEINTRESOURCE(uIconResourceId), IMAGE_ICON,
+    16, 16, 0);
+  if(NULL != hIcon) {
+    SendMessage(hWnd, WM_SETICON, FALSE, (LPARAM)hIcon);
+  } else {
+    HICON hIcon = LoadIcon(hInst, MAKEINTRESOURCE(uIconResourceId));
+    assert(hIcon != 0);
+    SendMessage(hWnd, WM_SETICON, FALSE, (LPARAM)hIcon);
+  }
+#endif // WIN32
+}
+#endif // __cplusplus
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* PORT_H */

mailnews/mapi/tests/mapitest/readmail.cpp

@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+//
+#include <windows.h>
+#include <windowsx.h>
+
+#ifndef MAPI_OLE	// Because MSFT doesn't do this for us :-(
+#include <mapi.h>
+#endif
+
+#include "port.h"
+#include "resource.h"
+
+//
+// Variables...
+// 
+extern HINSTANCE   hInst;
+extern HINSTANCE   m_hInstMapi;
+extern LHANDLE     mapiSession;
+
+// 
+// Forward declarations...
+//
+extern void   ShowMessage(HWND hWnd, LPSTR msg);
+extern void   SetFooter(LPSTR msg);
+extern LPSTR  GetMAPIError(LONG errorCode);
+lpMapiMessage mailPtr = NULL;
+
+void 
+ProcessReadMailCommand(HWND hWnd, int id, HWND hCtl, UINT codeNotify) 
+{ 
+  switch (id) 
+  {
+  case ID_OK:
+  case IDCANCEL:
+    EndDialog(hWnd, 0);
+    break;
+
+  default:
+    break;
+  }
+}
+
+BOOL CALLBACK LOADDS 
+ReadMailDlgProc(HWND hWndMail, UINT wMsg, WPARAM wParam, LPARAM lParam) 
+{
+  switch (wMsg) 
+  {
+  case WM_INITDIALOG: 
+    {
+      DWORD i;
+      // Do everything we need to display the message pointed to by
+      // mailPtr
+      if (!mailPtr)
+        break;
+
+      // Start with the basics...
+      SetDlgItemText(hWndMail, IDC_EDIT_SUBJECT, mailPtr->lpszSubject);
+      SetDlgItemText(hWndMail, IDC_EDIT_DATETIME, mailPtr->lpszDateReceived);
+      SetDlgItemText(hWndMail, IDC_EDIT_THREAD, mailPtr->lpszConversationID);
+      SetDlgItemText(hWndMail, IDC_EDIT_BODYTEXT, mailPtr->lpszNoteText);
+
+      char    buf[1024];
+      wsprintf(buf, "%s (%s)", mailPtr->lpOriginator->lpszName, 
+                              mailPtr->lpOriginator->lpszAddress);
+      SetDlgItemText(hWndMail, IDC_EDIT_FROM, buf);
+
+      for (i=0; i<mailPtr->nRecipCount; i++)
+      {
+          wsprintf(buf, "%s (%s)", mailPtr->lpRecips[i].lpszName, 
+                                   mailPtr->lpRecips[i].lpszAddress);
+          ListBox_InsertString(GetDlgItem(hWndMail, IDC_LIST_RECIPIENTS), 
+                  ListBox_GetCount(GetDlgItem(hWndMail, IDC_LIST_RECIPIENTS)), 
+                  buf);
+      }
+
+      for (i=0; i<mailPtr->nFileCount; i++)
+      {
+          ListBox_InsertString(GetDlgItem(hWndMail, IDC_LIST_ATTACHMENTS), 
+                ListBox_GetCount(GetDlgItem(hWndMail, IDC_LIST_ATTACHMENTS)), 
+                mailPtr->lpFiles[i].lpszPathName);
+      }
+    }
+    break;
+
+  case WM_COMMAND:
+    HANDLE_WM_COMMAND(hWndMail, wParam, lParam, ProcessReadMailCommand);
+    break;
+
+  default:
+    return FALSE;
+  }
+  
+  return TRUE;
+}
+
+void
+DisplayMAPIReadMail(HWND hWnd, lpMapiMessage msgPtr)
+{
+  mailPtr = msgPtr;
+  DialogBox(hInst, MAKEINTRESOURCE(ID_DIALOG_READMAIL), hWnd, 
+                (DLGPROC)ReadMailDlgProc);
+}

mailnews/mapi/tests/mapitest/resource.h

@@ -0,0 +1,104 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by mtest32.rc
+//
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#define ID_GUI_MESSAGE1                 1
+#define ID_BUTTON_MAPIADDRESS           3
+#define ID_DIALOG                       101
+#define ID_ICON_APP                     102
+#define ID_MENU                         104
+#define ID_DIALOG_MAIL                  105
+#define ID_DIALOG_READMAIL              106
+#define ID_SETFROMEDIT                  1000
+#define ID_SETTEXT                      1001
+#define ID_GETROWS                      1001
+#define ID_EDIT                         1002
+#define ID_EDIT_HWND                    1002
+#define ID_RESOURCETEXT                 1003
+#define ID_GETTEXT                      1003
+#define ID_STATIC_RESULT                1004
+#define ID_GETVISROWS                   1005
+#define ID_GETWINID                     1006
+#define ID_SETROWFOCUS                  1007
+#define ID_GETROWFOCUS                  1008
+#define ID_EDIT_ROW                     1009
+#define ID_LIST_RESULT                  1010
+#define ID_GETCOLCOUNT                  1011
+#define ID_BUTTON_LOGON                 1011
+#define ID_SETROWINVIEW                 1012
+#define ID_BUTTON_LOGOFF                1012
+#define ID_GETNUMCHILDREN               1013
+#define ID_EDIT_USERNAME                1013
+#define ID_CLEARRESULTS                 1014
+#define ID_EDIT_PW                      1014
+#define ID_BUTTON_FINDNEXT              1015
+#define ID_BUTTON_CLEAR                 1016
+#define ID_BUTTON_READMAIL              1017
+#define ID_BUTTON_DELETEMAIL            1018
+#define IDC_EDIT_RESOLVENAME            1019
+#define ID_BUTTON_MAPISENDMAIL          1020
+#define ID_BUTTON_NSCPVERSION           1020
+#define ID_BUTTON_RESOLVENAME           1021
+#define ID_BUTTON_MAPISENDDOCUMENTS     1021
+#define ID_EDIT_TOADDRESS               1022
+#define ID_EDIT_CCADDRESS               1023
+#define ID_BUTTON_DETAILS               1024
+#define ID_EDIT_BCCADDRESS              1024
+#define ID_EDIT_SUBJECT                 1025
+#define ID_BUTTON_MAIL                  1025
+#define ID_BUTTON_FREEBUFFER            1026
+#define ID_EDIT_NOTETEXT                1026
+#define ID_EDIT_ATTACH1                 1027
+#define ID_BUTTON_SYNC                  1027
+#define ID_EDIT_ATTACH2                 1028
+#define IDC_CHECK_BODYASFILE            1028
+#define ID_EDIT_ATTACH3                 1029
+#define IDC_CHECK_ENVELOPEONLY          1029
+#define IDC_LIST_ATTACHMENTS            1029
+#define ID_EDIT_ATTACH4                 1030
+#define IDC_CHECK_PEEK                  1030
+#define IDC_EDIT_BODYTEXT               1030
+#define IDC_CHECK_SUPPRESSATTACH        1031
+#define IDC_LIST_RECIPIENTS             1031
+#define ID_BUTTON_MAPISAVEMAIL          1031
+#define IDC_EDIT_SUBJECT                1032
+#define IDC_EDIT_DATETIME               1033
+#define ID_OK                           1034
+#define IDC_EDIT_THREAD                 1035
+#define ID_CHECK_SHOWDIALOG             1035
+#define IDC_EDIT_FROM                   1036
+#define ID_MENU_MYEXIT                  30001
+#define ID_MENU_CLEAR                   30002
+#define ID_MENU_MYABOUT                 30003
+#define ID_MENU_CLEARRESULTS            30004
+#define ID_MENU_MAPIDELETEMAIL          30005
+#define ID_MENU_MAPIFINDNEXT            30006
+#define ID_MENU_MAPIREADMAIL            30007
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        107
+#define _APS_NEXT_COMMAND_VALUE         30008
+#define _APS_NEXT_CONTROL_VALUE         1036
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif