gecko-dev/mailnews/mapi/mapi32/mapiutl.cpp

/* -*- 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;
}