MapiApi.h - mozsearch

comm-central/mailnews/import/src/MapiApi.h

Enable keyboard shortcuts

Source code

Go to source file

Revision control

Copy as Markdown

Other Tools

HG Web

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef MapiApi_h___

#define MapiApi_h___

#include "nscore.h"

#include "nsString.h"

#include "nsTArray.h"

#include <stdio.h>

#include <windows.h>

#include <mapi.h>

#include <mapix.h>

#include <mapidefs.h>

#include <mapicode.h>

#include <mapitags.h>

#include <mapiutil.h>

// wabutil.h expects mapiutil to define _MAPIUTIL_H but it actually

// defines _MAPIUTIL_H_

#define _MAPIUTIL_H

#ifndef PR_INTERNET_CPID

#  define PR_INTERNET_CPID (PROP_TAG(PT_LONG, 0x3FDE))

#endif

#ifndef MAPI_NATIVE_BODY

#  define MAPI_NATIVE_BODY (0x00010000)

#endif

#ifndef MAPI_NATIVE_BODY_TYPE_RTF

#  define MAPI_NATIVE_BODY_TYPE_RTF (0x00000001)

#endif

#ifndef MAPI_NATIVE_BODY_TYPE_HTML

#  define MAPI_NATIVE_BODY_TYPE_HTML (0x00000002)

#endif

#ifndef MAPI_NATIVE_BODY_TYPE_PLAINTEXT

#  define MAPI_NATIVE_BODY_TYPE_PLAINTEXT (0x00000004)

#endif

#ifndef PR_BODY_HTML_A

#  define PR_BODY_HTML_A (PROP_TAG(PT_STRING8, 0x1013))

#endif

#ifndef PR_BODY_HTML_W

#  define PR_BODY_HTML_W (PROP_TAG(PT_UNICODE, 0x1013))

#endif

#ifndef PR_BODY_HTML

#  define PR_BODY_HTML (PROP_TAG(PT_TSTRING, 0x1013))

#endif

class CMapiFolderList;

class CMsgStore;

class CMapiFolder;

class CMapiContentIter {

 public:

  virtual BOOL HandleContentItem(ULONG oType, ULONG cb, LPENTRYID pEntry) = 0;

};

class CMapiHierarchyIter {

 public:

  virtual BOOL HandleHierarchyItem(ULONG oType, ULONG cb, LPENTRYID pEntry) = 0;

};

class CMapiApi {

 public:

  CMapiApi();

  ~CMapiApi();

  static BOOL LoadMapi(void);

  static BOOL LoadMapiEntryPoints(void);

  static void UnloadMapi(void);

  static HINSTANCE m_hMapi32;

  static void MAPIUninitialize(void);

  static HRESULT MAPIInitialize(LPVOID lpInit);

  static SCODE MAPIAllocateBuffer(ULONG cbSize, LPVOID FAR* lppBuffer);

  static ULONG MAPIFreeBuffer(LPVOID lpBuff);

  static HRESULT MAPILogonEx(ULONG ulUIParam, LPTSTR lpszProfileName,

                             LPTSTR lpszPassword, FLAGS flFlags,

                             LPMAPISESSION FAR* lppSession);

  static HRESULT OpenStreamOnFile(LPALLOCATEBUFFER lpAllocateBuffer,

                                  LPFREEBUFFER lpFreeBuffer, ULONG ulFlags,

                                  LPCTSTR lpszFileName, LPTSTR lpszPrefix,

                                  LPSTREAM FAR* lppStream);

  static void FreeProws(LPSRowSet prows);

  BOOL Initialize(void);

  BOOL LogOn(void);

  void AddMessageStore(CMsgStore* pStore);

  void SetCurrentMsgStore(LPMDB lpMdb) { m_lpMdb = lpMdb; }

  // Open any given entry from the current Message Store

  BOOL OpenEntry(ULONG cbEntry, LPENTRYID pEntryId, LPUNKNOWN* ppOpen);

  static BOOL OpenMdbEntry(LPMDB lpMdb, ULONG cbEntry, LPENTRYID pEntryId,

                           LPUNKNOWN* ppOpen);

  // Fill in the folders list with the hierarchy from the given

  // message store.

  BOOL GetStoreFolders(ULONG cbEid, LPENTRYID lpEid, CMapiFolderList& folders,

                       int startDepth);

  BOOL GetStoreAddressFolders(ULONG cbEid, LPENTRYID lpEid,

                              CMapiFolderList& folders);

  BOOL OpenStore(ULONG cbEid, LPENTRYID lpEid, LPMDB* ppMdb);

  // Iteration

  BOOL IterateStores(CMapiFolderList& list);

  BOOL IterateContents(CMapiContentIter* pIter, LPMAPIFOLDER pFolder,

                       ULONG flags = 0);

  BOOL IterateHierarchy(CMapiHierarchyIter* pIter, LPMAPIFOLDER pFolder,

                        ULONG flags = 0);

  // Properties

  static LPSPropValue GetMapiProperty(LPMAPIPROP pProp, ULONG tag);

  // If delVal is true, functions will call CMapiApi::MAPIFreeBuffer on pVal.

  static BOOL GetEntryIdFromProp(LPSPropValue pVal, ULONG& cbEntryId,

                                 LPENTRYID& lpEntryId, BOOL delVal = TRUE);

  static BOOL GetStringFromProp(LPSPropValue pVal, nsCString& val,

                                BOOL delVal = TRUE);

  static BOOL GetStringFromProp(LPSPropValue pVal, nsString& val,

                                BOOL delVal = TRUE);

  static LONG GetLongFromProp(LPSPropValue pVal, BOOL delVal = TRUE);

  static BOOL GetLargeStringProperty(LPMAPIPROP pProp, ULONG tag,

                                     nsCString& val);

  static BOOL GetLargeStringProperty(LPMAPIPROP pProp, ULONG tag,

                                     nsString& val);

  static BOOL IsLargeProperty(LPSPropValue pVal);

  static ULONG GetEmailPropertyTag(LPMAPIPROP lpProp, LONG nameID);

  static BOOL GetRTFPropertyDecodedAsUTF16(LPMAPIPROP pProp, nsString& val,

                                           unsigned long& nativeBodyType,

                                           unsigned long codepage = 0);

  // Debugging & reporting stuff

  static void ListProperties(LPMAPIPROP lpProp, BOOL getValues = TRUE);

  static void ListPropertyValue(LPSPropValue pVal, nsCString& s);

 protected:

  BOOL HandleHierarchyItem(ULONG oType, ULONG cb, LPENTRYID pEntry);

  BOOL HandleContentsItem(ULONG oType, ULONG cb, LPENTRYID pEntry);

  void GetStoreInfo(CMapiFolder* pFolder, long* pSzContents);

  // array of available message stores, cached so that

  // message stores are only opened once, preventing multiple

  // logon's by the user if the store requires a logon.

  CMsgStore* FindMessageStore(ULONG cbEid, LPENTRYID lpEid);

  void ClearMessageStores(void);

  static void CStrToUnicode(const char* pStr, nsString& result);

  // Debugging & reporting stuff

  static void GetPropTagName(ULONG tag, nsCString& s);

  static void ReportStringProp(const char* pTag, LPSPropValue pVal);

  static void ReportUIDProp(const char* pTag, LPSPropValue pVal);

  static void ReportLongProp(const char* pTag, LPSPropValue pVal);

 private:

  static int m_clients;

  static BOOL m_initialized;

  static nsTArray<CMsgStore*>* m_pStores;

  static LPMAPISESSION m_lpSession;

  static LPMDB m_lpMdb;

  static HRESULT m_lastError;

  static char16_t* m_pUniBuff;

  static int m_uniBuffLen;

  static BOOL GetLargeProperty(LPMAPIPROP pProp, ULONG tag, void** result);

};

class CMapiFolder {

 public:

  CMapiFolder();

  explicit CMapiFolder(const CMapiFolder* pCopyFrom);

  CMapiFolder(const char16_t* pDisplayName, ULONG cbEid, LPENTRYID lpEid,

              int depth, LONG oType = MAPI_FOLDER);

  ~CMapiFolder();

  void SetDoImport(BOOL doIt) { m_doImport = doIt; }

  void SetObjectType(long oType) { m_objectType = oType; }

  void SetDisplayName(const char16_t* pDisplayName) {

    m_displayName = pDisplayName;

  void SetEntryID(ULONG cbEid, LPENTRYID lpEid);

  void SetDepth(int depth) { m_depth = depth; }

  void SetFilePath(const char16_t* pFilePath) { m_mailFilePath = pFilePath; }

  BOOL GetDoImport(void) const { return m_doImport; }

  LONG GetObjectType(void) const { return m_objectType; }

  void GetDisplayName(nsString& name) const { name = m_displayName; }

  void GetFilePath(nsString& path) const { path = m_mailFilePath; }

  BOOL IsStore(void) const { return m_objectType == MAPI_STORE; }

  BOOL IsFolder(void) const { return m_objectType == MAPI_FOLDER; }

  int GetDepth(void) const { return m_depth; }

  LPENTRYID GetEntryID(ULONG* pCb = NULL) const {

    if (pCb) *pCb = m_cbEid;

    return (LPENTRYID)m_lpEid;

  ULONG GetCBEntryID(void) const { return m_cbEid; }

 private:

  LONG m_objectType;

  ULONG m_cbEid;

  BYTE* m_lpEid;

  nsString m_displayName;

  int m_depth;

  nsString m_mailFilePath;

  BOOL m_doImport;

};

class CMapiFolderList {

 public:

  CMapiFolderList();

  ~CMapiFolderList();

  void AddItem(CMapiFolder* pFolder);

  CMapiFolder* GetItem(int index) {

    if ((index >= 0) && (index < (int)m_array.Length()))

      return GetAt(index);

    else

      return NULL;

  void ClearAll(void);

  // Debugging and reporting

  void DumpList(void);

  CMapiFolder* GetAt(int index) { return m_array.ElementAt(index); }

  int GetSize(void) { return m_array.Length(); }

 protected:

  void EnsureUniqueName(CMapiFolder* pFolder);

  void GenerateFilePath(CMapiFolder* pFolder);

  void ChangeName(nsString& name);

 private:

  nsTArray<CMapiFolder*> m_array;

};

class CMsgStore {

 public:

  explicit CMsgStore(ULONG cbEid = 0, LPENTRYID lpEid = NULL);

  ~CMsgStore();

  void SetEntryID(ULONG cbEid, LPENTRYID lpEid);

  BOOL Open(LPMAPISESSION pSession, LPMDB* ppMdb);

  ULONG GetCBEntryID(void) { return m_cbEid; }

  LPENTRYID GetLPEntryID(void) { return (LPENTRYID)m_lpEid; }

 private:

  ULONG m_cbEid;

  BYTE* m_lpEid;

  LPMDB m_lpMdb;

};

class CMapiFolderContents {

 public:

  CMapiFolderContents(LPMDB lpMdb, ULONG cbEID, LPENTRYID lpEid);

  ~CMapiFolderContents();

  BOOL GetNext(ULONG* pcbEid, LPENTRYID* ppEid, ULONG* poType, BOOL* pDone);

  ULONG GetCount(void) { return m_count; }

 protected:

  BOOL SetUpIter(void);

 private:

  HRESULT m_lastError;

  BOOL m_failure;

  LPMDB m_lpMdb;

  LPMAPIFOLDER m_lpFolder;

  LPMAPITABLE m_lpTable;

  ULONG m_fCbEid;

  BYTE* m_fLpEid;

  ULONG m_count;

  ULONG m_iterCount;

  BYTE* m_lastLpEid;

  ULONG m_lastCbEid;

};

#endif /* MapiApi_h__ */