path: root/comm/mailnews/import/src/MapiMessage.cpp

/* -*- Mode: C++; tab-width: 2; 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 INITGUID
#  define INITGUID
#endif

#ifndef USES_IID_IMessage
#  define USES_IID_IMessage
#endif

#include "nscore.h"
#include <time.h>
#include "nsString.h"
#include "nsDirectoryServiceDefs.h"
#include "nsMsgUtils.h"
#include "nsMimeTypes.h"
#include "nsNativeCharsetUtils.h"
#include "nsIOutputStream.h"

#include "MapiDbgLog.h"
#include "MapiApi.h"

#include "MapiMimeTypes.h"

#include "nsMsgI18N.h"
#include "nsCRT.h"
#include "nsNetUtil.h"
#include "MapiMessage.h"

#include "nsOutlookMail.h"

#include "mozilla/Encoding.h"

#include <stdlib.h>
#include <tuple>

// needed for the call the OpenStreamOnFile
extern LPMAPIALLOCATEBUFFER gpMapiAllocateBuffer;
extern LPMAPIFREEBUFFER gpMapiFreeBuffer;

// Sample From line: From - 1 Jan 1965 00:00:00

typedef const char* PC_S8;

static const char* kWhitespace = "\b\t\r\n ";
static const char* sFromLine = "From - ";
static const char* sFromDate = "Mon Jan 1 00:00:00 1965";
static const char* sDaysOfWeek[7] = {"Sun", "Mon", "Tue", "Wed",
                                     "Thu", "Fri", "Sat"};

static const char* sMonths[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

CMapiMessage::CMapiMessage(LPMESSAGE lpMsg)
    : m_lpMsg(lpMsg), m_dldStateHeadersOnly(false), m_msgFlags(0) {
  nsresult rv;
  m_pIOService = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
  if (NS_FAILED(rv)) return;

  FetchHeaders();
  if (ValidState()) {
    BuildFromLine();
    FetchFlags();
    GetDownloadState();
    if (FullMessageDownloaded()) {
      FetchBody();
      ProcessAttachments();
    }
  }
}

CMapiMessage::~CMapiMessage() {
  ClearAttachments();
  if (m_lpMsg) m_lpMsg->Release();
}

void CMapiMessage::FormatDateTime(SYSTEMTIME& tm, nsCString& s,
                                  bool includeTZ) {
  long offset = _timezone;
  s += sDaysOfWeek[tm.wDayOfWeek];
  s += ", ";
  s.AppendInt((int32_t)tm.wDay);
  s += " ";
  s += sMonths[tm.wMonth - 1];
  s += " ";
  s.AppendInt((int32_t)tm.wYear);
  s += " ";
  int val = tm.wHour;
  if (val < 10) s += "0";
  s.AppendInt((int32_t)val);
  s += ":";
  val = tm.wMinute;
  if (val < 10) s += "0";
  s.AppendInt((int32_t)val);
  s += ":";
  val = tm.wSecond;
  if (val < 10) s += "0";
  s.AppendInt((int32_t)val);
  if (includeTZ) {
    s += " ";
    if (offset < 0) {
      offset *= -1;
      s += "+";
    } else
      s += "-";
    offset /= 60;
    val = (int)(offset / 60);
    if (val < 10) s += "0";
    s.AppendInt((int32_t)val);
    val = (int)(offset % 60);
    if (val < 10) s += "0";
    s.AppendInt((int32_t)val);
  }
}

bool CMapiMessage::EnsureHeader(CMapiMessageHeaders::SpecialHeader special,
                                ULONG mapiTag) {
  if (m_headers.Value(special)) return true;

  LPSPropValue pVal = CMapiApi::GetMapiProperty(m_lpMsg, mapiTag);
  bool success = false;
  if (pVal) {
    if (PROP_TYPE(pVal->ulPropTag) == PT_STRING8) {
      if (pVal->Value.lpszA && strlen(pVal->Value.lpszA)) {
        m_headers.SetValue(special, pVal->Value.lpszA);
        success = true;
      }
    } else if (PROP_TYPE(pVal->ulPropTag) == PT_UNICODE) {
      if (pVal->Value.lpszW && wcslen(pVal->Value.lpszW)) {
        m_headers.SetValue(special,
                           NS_ConvertUTF16toUTF8(pVal->Value.lpszW).get());
        success = true;
      }
    }
    CMapiApi::MAPIFreeBuffer(pVal);
  }

  return success;
}

bool CMapiMessage::EnsureDate() {
  if (m_headers.Value(CMapiMessageHeaders::hdrDate)) return true;

  LPSPropValue pVal =
      CMapiApi::GetMapiProperty(m_lpMsg, PR_MESSAGE_DELIVERY_TIME);
  if (!pVal) pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_CREATION_TIME);
  if (pVal) {
    SYSTEMTIME st;
    // the following call returns UTC
    ::FileTimeToSystemTime(&(pVal->Value.ft), &st);
    CMapiApi::MAPIFreeBuffer(pVal);
    // FormatDateTime would append the local time zone, so don't use it.
    // Instead, we just append +0000 for GMT/UTC here.
    nsCString str;
    FormatDateTime(st, str, false);
    str += " +0000";
    m_headers.SetValue(CMapiMessageHeaders::hdrDate, str.get());
    return true;
  }

  return false;
}

void CMapiMessage::BuildFromLine(void) {
  m_fromLine = sFromLine;
  LPSPropValue pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_CREATION_TIME);
  if (pVal) {
    SYSTEMTIME st;
    ::FileTimeToSystemTime(&(pVal->Value.ft), &st);
    CMapiApi::MAPIFreeBuffer(pVal);
    FormatDateTime(st, m_fromLine, FALSE);
  } else
    m_fromLine += sFromDate;

  m_fromLine += "\x0D\x0A";
}

#ifndef dispidHeaderItem
#  define dispidHeaderItem 0x8578
#endif
DEFINE_OLEGUID(PSETID_Common, MAKELONG(0x2000 + (8), 0x0006), 0, 0);

void CMapiMessage::GetDownloadState() {
  // See http://support.microsoft.com/kb/912239
  ULONG ulVal = 0;
  LPSPropValue lpPropVal = NULL;
  LPSPropTagArray lpNamedPropTag = NULL;
  MAPINAMEID NamedID = {0};
  LPMAPINAMEID lpNamedID = NULL;

  NamedID.lpguid = (LPGUID)&PSETID_Common;
  NamedID.ulKind = MNID_ID;
  NamedID.Kind.lID = dispidHeaderItem;
  lpNamedID = &NamedID;

  m_lpMsg->GetIDsFromNames(1, &lpNamedID, NULL, &lpNamedPropTag);

  if (lpNamedPropTag && 1 == lpNamedPropTag->cValues) {
    lpNamedPropTag->aulPropTag[0] =
        CHANGE_PROP_TYPE(lpNamedPropTag->aulPropTag[0], PT_LONG);

    // Get the value of the property.
    m_lpMsg->GetProps(lpNamedPropTag, 0, &ulVal, &lpPropVal);
    if (lpPropVal && 1 == ulVal && PT_LONG == PROP_TYPE(lpPropVal->ulPropTag) &&
        lpPropVal->Value.ul)
      m_dldStateHeadersOnly = true;
  }

  CMapiApi::MAPIFreeBuffer(lpPropVal);
  CMapiApi::MAPIFreeBuffer(lpNamedPropTag);
}

// Headers - fetch will get PR_TRANSPORT_MESSAGE_HEADERS
// or if they do not exist will build a header from
//  PR_DISPLAY_TO, _CC, _BCC
//  PR_SUBJECT
//  PR_MESSAGE_RECIPIENTS
// and PR_CREATION_TIME if needed?
bool CMapiMessage::FetchHeaders(void) {
  ULONG tag = PR_TRANSPORT_MESSAGE_HEADERS_A;
  LPSPropValue pVal = CMapiApi::GetMapiProperty(m_lpMsg, tag);
  if (!pVal)
    pVal = CMapiApi::GetMapiProperty(m_lpMsg,
                                     tag = PR_TRANSPORT_MESSAGE_HEADERS_W);
  if (pVal) {
    if (CMapiApi::IsLargeProperty(pVal)) {
      nsCString headers;
      CMapiApi::GetLargeStringProperty(m_lpMsg, tag, headers);
      m_headers.Assign(headers.get());
    } else if ((PROP_TYPE(pVal->ulPropTag) == PT_STRING8) &&
               (pVal->Value.lpszA) && (*(pVal->Value.lpszA)))
      m_headers.Assign(pVal->Value.lpszA);
    else if ((PROP_TYPE(pVal->ulPropTag) == PT_UNICODE) &&
             (pVal->Value.lpszW) && (*(pVal->Value.lpszW))) {
      nsCString headers;
      LossyCopyUTF16toASCII(nsDependentString(pVal->Value.lpszW), headers);
      m_headers.Assign(headers.get());
    }

    CMapiApi::MAPIFreeBuffer(pVal);
  }

  EnsureDate();
  if (!EnsureHeader(CMapiMessageHeaders::hdrFrom, PR_SENDER_NAME_W))
    EnsureHeader(CMapiMessageHeaders::hdrFrom, PR_SENDER_EMAIL_ADDRESS_W);
  EnsureHeader(CMapiMessageHeaders::hdrSubject, PR_SUBJECT_W);
  EnsureHeader(CMapiMessageHeaders::hdrTo, PR_DISPLAY_TO_W);
  EnsureHeader(CMapiMessageHeaders::hdrCc, PR_DISPLAY_CC_W);
  EnsureHeader(CMapiMessageHeaders::hdrBcc, PR_DISPLAY_BCC_W);

  ProcessContentType();

  return !m_headers.IsEmpty();
}

// Mime-Version: 1.0
// Content-Type: text/plain; charset="US-ASCII"
// Content-Type: multipart/mixed; boundary="=====================_874475278==_"

void CMapiMessage::ProcessContentType() {
  m_mimeContentType.Truncate();
  m_mimeBoundary.Truncate();
  m_mimeCharset.Truncate();

  const char* contentType =
      m_headers.Value(CMapiMessageHeaders::hdrContentType);
  if (!contentType) return;

  const char *begin = contentType, *end;
  nsCString tStr;

  // Note: this isn't a complete parser, the content type
  // we extract could have rfc822 comments in it
  while (*begin && IsSpace(*begin)) begin++;
  if (!(*begin)) return;
  end = begin;
  while (*end && (*end != ';')) end++;
  m_mimeContentType.Assign(begin, end - begin);
  if (!(*end)) return;
  // look for "boundary="
  begin = end + 1;
  bool haveB;
  bool haveC;
  while (*begin) {
    haveB = false;
    haveC = false;
    while (*begin && IsSpace(*begin)) begin++;
    if (!(*begin)) return;
    end = begin;
    while (*end && (*end != '=')) end++;
    if (end - begin) {
      tStr.Assign(begin, end - begin);
      if (tStr.LowerCaseEqualsLiteral("boundary"))
        haveB = true;
      else if (tStr.LowerCaseEqualsLiteral("charset"))
        haveC = true;
    }
    if (!(*end)) return;
    begin = end + 1;
    while (*begin && IsSpace(*begin)) begin++;
    if (*begin == '"') {
      begin++;
      bool slash = false;
      tStr.Truncate();
      while (*begin) {
        if (slash) {
          slash = false;
          tStr.Append(*begin);
        } else if (*begin == '"')
          break;
        else if (*begin != '\\')
          tStr.Append(*begin);
        else
          slash = true;
        begin++;
      }
      if (haveB) {
        m_mimeBoundary = tStr;
        haveB = false;
      }
      if (haveC) {
        m_mimeCharset = tStr;
        haveC = false;
      }
      if (!(*begin)) return;
      begin++;
    }
    tStr.Truncate();
    while (*begin && (*begin != ';')) {
      tStr.Append(*(begin++));
    }
    if (haveB) {
      tStr.Trim(kWhitespace);
      m_mimeBoundary = tStr;
    }
    if (haveC) {
      tStr.Trim(kWhitespace);
      m_mimeCharset = tStr;
    }
    if (*begin) begin++;
  }
}

const char* CpToCharset(unsigned int cp) {
  struct CODEPAGE_TO_CHARSET {
    unsigned long cp;
    const char* charset;
  };

  // This table is based on
  // http://msdn.microsoft.com/en-us/library/dd317756(v=VS.85).aspx#1; Please
  // extend as appropriate. The codepage values are sorted ascending.
  static const CODEPAGE_TO_CHARSET cptocharset[] = {
      {37, "IBM037"},     // IBM EBCDIC US-Canada
      {437, "IBM437"},    // OEM United States
      {500, "IBM500"},    // IBM EBCDIC International
      {708, "ASMO-708"},  // Arabic (ASMO 708)
      // 709  Arabic (ASMO-449+, BCON V4)
      // 710  Arabic - Transparent Arabic
      {720, "DOS-720"},   // Arabic (Transparent ASMO); Arabic (DOS)
      {737, "ibm737"},    // OEM Greek (formerly 437G); Greek (DOS)
      {775, "ibm775"},    // OEM Baltic; Baltic (DOS)
      {850, "ibm850"},    // OEM Multilingual Latin 1; Western European (DOS)
      {852, "ibm852"},    // OEM Latin 2; Central European (DOS)
      {855, "IBM855"},    // OEM Cyrillic (primarily Russian)
      {857, "ibm857"},    // OEM Turkish; Turkish (DOS)
      {858, "IBM00858"},  // OEM Multilingual Latin 1 + Euro symbol
      {860, "IBM860"},    // OEM Portuguese; Portuguese (DOS)
      {861, "ibm861"},    // OEM Icelandic; Icelandic (DOS)
      {862, "DOS-862"},   // OEM Hebrew; Hebrew (DOS)
      {863, "IBM863"},    // OEM French Canadian; French Canadian (DOS)
      {864, "IBM864"},    // OEM Arabic; Arabic (864)
      {865, "IBM865"},    // OEM Nordic; Nordic (DOS)
      {866, "cp866"},     // OEM Russian; Cyrillic (DOS)
      {869, "ibm869"},    // OEM Modern Greek; Greek, Modern (DOS)
      {870, "IBM870"},    // IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC
                          // Multilingual Latin 2
      {874, "windows-874"},  // ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai
                             // (Windows)
      {875, "cp875"},        // IBM EBCDIC Greek Modern
      {932, "shift_jis"},    // ANSI/OEM Japanese; Japanese (Shift-JIS)
      {936, "gb2312"},  // ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese
                        // Simplified (GB2312)
      {949, "ks_c_5601-1987"},  // ANSI/OEM Korean (Unified Hangul Code)
      {950, "big5"},  // ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR,
                      // PRC); Chinese Traditional (Big5)
      {1026, "IBM1026"},   // IBM EBCDIC Turkish (Latin 5)
      {1047, "IBM01047"},  // IBM EBCDIC Latin 1/Open System
      {1140, "IBM01140"},  // IBM EBCDIC US-Canada (037 + Euro symbol); IBM
                           // EBCDIC (US-Canada-Euro)
      {1141, "IBM01141"},  // IBM EBCDIC Germany (20273 + Euro symbol); IBM
                           // EBCDIC (Germany-Euro)
      {1142, "IBM01142"},  // IBM EBCDIC Denmark-Norway (20277 + Euro symbol);
                           // IBM EBCDIC (Denmark-Norway-Euro)
      {1143, "IBM01143"},  // IBM EBCDIC Finland-Sweden (20278 + Euro symbol);
                           // IBM EBCDIC (Finland-Sweden-Euro)
      {1144, "IBM01144"},  // IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC
                           // (Italy-Euro)
      {1145, "IBM01145"},  // IBM EBCDIC Latin America-Spain (20284 + Euro
                           // symbol); IBM EBCDIC (Spain-Euro)
      {1146, "IBM01146"},  // IBM EBCDIC United Kingdom (20285 + Euro symbol);
                           // IBM EBCDIC (UK-Euro)
      {1147, "IBM01147"},  // IBM EBCDIC France (20297 + Euro symbol); IBM
                           // EBCDIC (France-Euro)
      {1148, "IBM01148"},  // IBM EBCDIC International (500 + Euro symbol); IBM
                           // EBCDIC (International-Euro)
      {1149, "IBM01149"},  // IBM EBCDIC Icelandic (20871 + Euro symbol); IBM
                           // EBCDIC (Icelandic-Euro)
      {1200, "utf-16"},  // Unicode UTF-16, little endian byte order (BMP of ISO
                         // 10646); available only to managed applications
      {1201, "unicodeFFFE"},  // Unicode UTF-16, big endian byte order;
                              // available only to managed applications
      {1250,
       "windows-1250"},  // ANSI Central European; Central European (Windows)
      {1251, "windows-1251"},     // ANSI Cyrillic; Cyrillic (Windows)
      {1252, "windows-1252"},     // ANSI Latin 1; Western European (Windows)
      {1253, "windows-1253"},     // ANSI Greek; Greek (Windows)
      {1254, "windows-1254"},     // ANSI Turkish; Turkish (Windows)
      {1255, "windows-1255"},     // ANSI Hebrew; Hebrew (Windows)
      {1256, "windows-1256"},     // ANSI Arabic; Arabic (Windows)
      {1257, "windows-1257"},     // ANSI Baltic; Baltic (Windows)
      {1258, "windows-1258"},     // ANSI/OEM Vietnamese; Vietnamese (Windows)
      {1361, "Johab"},            // Korean (Johab)
      {10000, "macintosh"},       // MAC Roman; Western European (Mac)
      {10001, "x-mac-japanese"},  // Japanese (Mac)
      {10002, "x-mac-chinesetrad"},  // MAC Traditional Chinese (Big5); Chinese
                                     // Traditional (Mac)
      {10003, "x-mac-korean"},       // Korean (Mac)
      {10004, "x-mac-arabic"},       // Arabic (Mac)
      {10005, "x-mac-hebrew"},       // Hebrew (Mac)
      {10006, "x-mac-greek"},        // Greek (Mac)
      {10007, "x-mac-cyrillic"},     // Cyrillic (Mac)
      {10008, "x-mac-chinesesimp"},  // MAC Simplified Chinese (GB 2312);
                                     // Chinese Simplified (Mac)
      {10010, "x-mac-romanian"},     // Romanian (Mac)
      {10017, "x-mac-ukrainian"},    // Ukrainian (Mac)
      {10021, "x-mac-thai"},         // Thai (Mac)
      {10029, "x-mac-ce"},           // MAC Latin 2; Central European (Mac)
      {10079, "x-mac-icelandic"},    // Icelandic (Mac)
      {10081, "x-mac-turkish"},      // Turkish (Mac)
      {10082, "x-mac-croatian"},     // Croatian (Mac)
      // Unicode UTF-32, little endian byte order; available only to managed
      // applications impossible in 8-bit mail
      {12000, "utf-32"},
      // Unicode UTF-32, big endian byte order; available only to managed
      // applications impossible in 8-bit mail
      {12001, "utf-32BE"},
      {20000, "x-Chinese_CNS"},   // CNS Taiwan; Chinese Traditional (CNS)
      {20001, "x-cp20001"},       // TCA Taiwan
      {20002, "x_Chinese-Eten"},  // Eten Taiwan; Chinese Traditional (Eten)
      {20003, "x-cp20003"},       // IBM5550 Taiwan
      {20004, "x-cp20004"},       // TeleText Taiwan
      {20005, "x-cp20005"},       // Wang Taiwan
      {20105, "x-IA5"},  // IA5 (IRV International Alphabet No. 5, 7-bit);
                         // Western European (IA5)
      {20106, "x-IA5-German"},     // IA5 German (7-bit)
      {20107, "x-IA5-Swedish"},    // IA5 Swedish (7-bit)
      {20108, "x-IA5-Norwegian"},  // IA5 Norwegian (7-bit)
      {20127, "us-ascii"},         // US-ASCII (7-bit)
      {20261, "x-cp20261"},        // T.61
      {20269, "x-cp20269"},        // ISO 6937 Non-Spacing Accent
      {20273, "IBM273"},           // IBM EBCDIC Germany
      {20277, "IBM277"},           // IBM EBCDIC Denmark-Norway
      {20278, "IBM278"},           // IBM EBCDIC Finland-Sweden
      {20280, "IBM280"},           // IBM EBCDIC Italy
      {20284, "IBM284"},           // IBM EBCDIC Latin America-Spain
      {20285, "IBM285"},           // IBM EBCDIC United Kingdom
      {20290, "IBM290"},           // IBM EBCDIC Japanese Katakana Extended
      {20297, "IBM297"},           // IBM EBCDIC France
      {20420, "IBM420"},           // IBM EBCDIC Arabic
      {20423, "IBM423"},           // IBM EBCDIC Greek
      {20424, "IBM424"},           // IBM EBCDIC Hebrew
      {20833, "x-EBCDIC-KoreanExtended"},  // IBM EBCDIC Korean Extended
      {20838, "IBM-Thai"},                 // IBM EBCDIC Thai
      {20866, "koi8-r"},  // Russian (KOI8-R); Cyrillic (KOI8-R)
      {20871, "IBM871"},  // IBM EBCDIC Icelandic
      {20880, "IBM880"},  // IBM EBCDIC Cyrillic Russian
      {20905, "IBM905"},  // IBM EBCDIC Turkish
      {20924,
       "IBM00924"},       // IBM EBCDIC Latin 1/Open System (1047 + Euro symbol)
      {20932, "EUC-JP"},  // Japanese (JIS 0208-1990 and 0121-1990)
      {20936, "x-cp20936"},  // Simplified Chinese (GB2312); Chinese Simplified
                             // (GB2312-80)
      {20949, "x-cp20949"},  // Korean Wansung
      {21025, "cp1025"},     // IBM EBCDIC Cyrillic Serbian-Bulgarian
      // 21027  (deprecated)
      {21866, "koi8-u"},      // Ukrainian (KOI8-U); Cyrillic (KOI8-U)
      {28591, "iso-8859-1"},  // ISO 8859-1 Latin 1; Western European (ISO)
      {28592,
       "iso-8859-2"},  // ISO 8859-2 Central European; Central European (ISO)
      {28593, "iso-8859-3"},    // ISO 8859-3 Latin 3
      {28594, "iso-8859-4"},    // ISO 8859-4 Baltic
      {28595, "iso-8859-5"},    // ISO 8859-5 Cyrillic
      {28596, "iso-8859-6"},    // ISO 8859-6 Arabic
      {28597, "iso-8859-7"},    // ISO 8859-7 Greek
      {28598, "iso-8859-8"},    // ISO 8859-8 Hebrew; Hebrew (ISO-Visual)
      {28599, "iso-8859-9"},    // ISO 8859-9 Turkish
      {28603, "iso-8859-13"},   // ISO 8859-13 Estonian
      {28605, "iso-8859-15"},   // ISO 8859-15 Latin 9
      {29001, "x-Europa"},      // Europa 3
      {38598, "iso-8859-8-i"},  // ISO 8859-8 Hebrew; Hebrew (ISO-Logical)
      {50220, "iso-2022-jp"},   // ISO 2022 Japanese with no halfwidth Katakana;
                                // Japanese (JIS)
      {50221, "csISO2022JP"},   // ISO 2022 Japanese with halfwidth Katakana;
                                // Japanese (JIS-Allow 1 byte Kana)
      {50222, "iso-2022-jp"},   // ISO 2022 Japanese JIS X 0201-1989; Japanese
                                // (JIS-Allow 1 byte Kana - SO/SI)
      {50225, "iso-2022-kr"},   // ISO 2022 Korean
      {50227, "x-cp50227"},  // ISO 2022 Simplified Chinese; Chinese Simplified
                             // (ISO 2022)
      // 50229  ISO 2022 Traditional Chinese
      // 50930  EBCDIC Japanese (Katakana) Extended
      // 50931  EBCDIC US-Canada and Japanese
      // 50933  EBCDIC Korean Extended and Korean
      // 50935  EBCDIC Simplified Chinese Extended and Simplified Chinese
      // 50936  EBCDIC Simplified Chinese
      // 50937  EBCDIC US-Canada and Traditional Chinese
      // 50939  EBCDIC Japanese (Latin) Extended and Japanese
      {51932, "euc-jp"},  // EUC Japanese
      {51936, "EUC-CN"},  // EUC Simplified Chinese; Chinese Simplified (EUC)
      {51949, "euc-kr"},  // EUC Korean
      // 51950  EUC Traditional Chinese
      {52936,
       "hz-gb-2312"},  // HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ)
      {54936, "GB18030"},  // Windows XP and later: GB18030 Simplified Chinese
                           // (4 byte); Chinese Simplified (GB18030)
      {57002, "x-iscii-de"},  // ISCII Devanagari
      {57003, "x-iscii-be"},  // ISCII Bengali
      {57004, "x-iscii-ta"},  // ISCII Tamil
      {57005, "x-iscii-te"},  // ISCII Telugu
      {57006, "x-iscii-as"},  // ISCII Assamese
      {57007, "x-iscii-or"},  // ISCII Oriya (Odia)
      {57008, "x-iscii-ka"},  // ISCII Kannada
      {57009, "x-iscii-ma"},  // ISCII Malayalam
      {57010, "x-iscii-gu"},  // ISCII Gujarati
      {57011, "x-iscii-pa"},  // ISCII Punjabi
      {65000, "utf-7"},       // Unicode (UTF-7)
      {65001, "utf-8"},       // Unicode (UTF-8)
  };

  // Binary search
  int begin = 0, end = sizeof(cptocharset) / sizeof(cptocharset[0]) - 1;
  while (begin <= end) {
    int mid = (begin + end) / 2;
    unsigned int mid_cp = cptocharset[mid].cp;
    if (cp == mid_cp) return cptocharset[mid].charset;
    if (cp < mid_cp)
      end = mid - 1;
    else  // cp > cptocharset[mid].cp
      begin = mid + 1;
  }
  return 0;  // not found
}

// This function returns true only if the unicode (utf-16) text can be
// losslessly represented in specified charset
bool CMapiMessage::CheckBodyInCharsetRange(const char* charset) {
  if (m_body.IsEmpty()) return true;
  if (!_stricmp(charset, "utf-8")) return true;

  auto encoding =
      mozilla::Encoding::ForLabelNoReplacement(nsDependentCString(charset));
  if (!encoding) return false;
  auto encoder = encoding->NewEncoder();

  uint8_t buffer[512];
  auto src = mozilla::Span(m_body);
  auto dst = mozilla::Span(buffer);
  while (true) {
    uint32_t result;
    size_t read;
    std::tie(result, read, std::ignore) =
        encoder->EncodeFromUTF16WithoutReplacement(src, dst, false);
    if (result == mozilla::kInputEmpty) {
      // All converted successfully.
      break;
    } else if (result != mozilla::kOutputFull) {
      // Didn't use all the input but the output isn't full, hence
      // there was an unencodable character.
      return false;
    }
    src = src.From(read);
  }

  return true;
}

bool CaseInsensitiveComp(wchar_t elem1, wchar_t elem2) {
  return _wcsnicmp(&elem1, &elem2, 1) == 0;
}

void ExtractMetaCharset(const wchar_t* body, int bodySz,
                        /*out*/ nsCString& charset) {
  charset.Truncate();
  const wchar_t* body_end = body + bodySz;
  const wchar_t str_eohd[] = L"/head";
  const wchar_t* str_eohd_end =
      str_eohd + sizeof(str_eohd) / sizeof(str_eohd[0]) - 1;
  const wchar_t* eohd_pos =
      std::search(body, body_end, str_eohd, str_eohd_end, CaseInsensitiveComp);
  if (eohd_pos == body_end)  // No header!
    return;
  const wchar_t str_chset[] = L"charset=";
  const wchar_t* str_chset_end =
      str_chset + sizeof(str_chset) / sizeof(str_chset[0]) - 1;
  const wchar_t* chset_pos = std::search(body, eohd_pos, str_chset,
                                         str_chset_end, CaseInsensitiveComp);
  if (chset_pos == eohd_pos)  // No charset!
    return;
  chset_pos += 8;

  // remove everything from the string after the next ; or " or space,
  // whichever comes first.
  // The initial string looks something like
  // <META content="text/html; charset=utf-8" http-equiv=Content-Type>
  // <META content="text/html; charset=utf-8;" http-equiv=Content-Type>
  // <META content="text/html; charset=utf-8 ;" http-equiv=Content-Type>
  // <META content="text/html; charset=utf-8 " http-equiv=Content-Type>
  const wchar_t term[] = L";\" ",
                *term_end = term + sizeof(term) / sizeof(term[0]) - 1;
  const wchar_t* chset_end =
      std::find_first_of(chset_pos, eohd_pos, term, term_end);
  if (chset_end != eohd_pos)
    LossyCopyUTF16toASCII(
        Substring(char16ptr_t(chset_pos), char16ptr_t(chset_end)), charset);
}

bool CMapiMessage::FetchBody(void) {
  m_bodyIsHtml = false;
  m_body.Truncate();

  // Get the Outlook codepage info; if unsuccessful then it defaults to 0
  // (CP_ACP) -> system default Maybe we can use this info later?
  unsigned int codepage = 0;
  LPSPropValue pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_INTERNET_CPID);
  if (pVal) {
    if (PROP_TYPE(pVal->ulPropTag) == PT_LONG) codepage = pVal->Value.l;
    CMapiApi::MAPIFreeBuffer(pVal);
  }

  unsigned long nativeBodyType = 0;
  if (CMapiApi::GetRTFPropertyDecodedAsUTF16(m_lpMsg, m_body, nativeBodyType,
                                             codepage)) {
    m_bodyIsHtml = nativeBodyType == MAPI_NATIVE_BODY_TYPE_HTML;
  } else {  // Cannot get RTF version
    // Is it html?
    pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_BODY_HTML_W);
    if (pVal) {
      if (CMapiApi::IsLargeProperty(pVal))
        CMapiApi::GetLargeStringProperty(m_lpMsg, PR_BODY_HTML_W, m_body);
      else if ((PROP_TYPE(pVal->ulPropTag) == PT_UNICODE) &&
               (pVal->Value.lpszW) && (*(pVal->Value.lpszW)))
        m_body.Assign(pVal->Value.lpszW);
      CMapiApi::MAPIFreeBuffer(pVal);
    }

    // Kind-hearted Outlook will give us html even for a plain text message.
    // But it will include a comment saying it did the conversion.
    // We'll use this as a hack to really use the plain text part.
    //
    // Sadly there are cases where this string is returned despite the fact
    // that the message is indeed HTML.
    //
    // To detect the "true" plain text messages, we look for our string
    // immediately following the <BODY> tag.
    if (!m_body.IsEmpty() &&
        m_body.Find(u"<BODY>\r\n<!-- Converted from text/plain format -->") ==
            kNotFound) {
      m_bodyIsHtml = true;
    } else {
      pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_BODY_W);
      if (pVal) {
        if (CMapiApi::IsLargeProperty(pVal))
          CMapiApi::GetLargeStringProperty(m_lpMsg, PR_BODY_W, m_body);
        else if ((PROP_TYPE(pVal->ulPropTag) == PT_UNICODE) &&
                 (pVal->Value.lpszW) && (*(pVal->Value.lpszW)))
          m_body.Assign(pVal->Value.lpszW);
        CMapiApi::MAPIFreeBuffer(pVal);
      }
    }
  }

  // OK, now let's restore the original encoding!
  // 1. We may have a header defining the charset (we already called the
  // FetchHeaders(), and there ProcessHeaders();
  //    in this case, the m_mimeCharset is set. See
  //    nsOutlookMail::ImportMailbox())
  // 2. We may have the codepage walue provided by Outlook ("codepage" at the
  // very beginning of this function)
  // 3. We may have an HTML charset header.

  bool bFoundCharset = false;

  if (!m_mimeCharset.IsEmpty())  // The top-level header data
    bFoundCharset = CheckBodyInCharsetRange(m_mimeCharset.get());
  // No valid charset in the message header - try the HTML header.
  // arguably may be useless
  if (!bFoundCharset && m_bodyIsHtml) {
    ExtractMetaCharset(m_body.get(), m_body.Length(), m_mimeCharset);
    if (!m_mimeCharset.IsEmpty())
      bFoundCharset = CheckBodyInCharsetRange(m_mimeCharset.get());
  }
  // Get from Outlook (seems like it keeps the MIME part header encoding info)
  if (!bFoundCharset && codepage) {
    const char* charset = CpToCharset(codepage);
    if (charset) {
      bFoundCharset = CheckBodyInCharsetRange(charset);
      if (bFoundCharset) m_mimeCharset.Assign(charset);
    }
  }
  if (!bFoundCharset)  // Everything else failed, let's use the lossless
                       // utf-8...
    m_mimeCharset.AssignLiteral("utf-8");

  MAPI_DUMP_STRING(m_body.get());
  MAPI_TRACE0("\r\n");

  return true;
}

void CMapiMessage::GetBody(nsCString& dest) const {
  nsMsgI18NConvertFromUnicode(m_mimeCharset, m_body, dest);
}

void CMapiMessage::FetchFlags(void) {
  LPSPropValue pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_MESSAGE_FLAGS);
  if (pVal) m_msgFlags = CMapiApi::GetLongFromProp(pVal);
  pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_LAST_VERB_EXECUTED);
  if (pVal) m_msgLastVerb = CMapiApi::GetLongFromProp(pVal);
}

enum { ieidPR_ATTACH_NUM = 0, ieidAttachMax };

static const SizedSPropTagArray(ieidAttachMax, ptaEid) = {ieidAttachMax,
                                                          {PR_ATTACH_NUM}};

bool CMapiMessage::IterateAttachTable(LPMAPITABLE lpTable) {
  ULONG rowCount;
  HRESULT hr = lpTable->GetRowCount(0, &rowCount);
  if (!rowCount) {
    return true;
  }

  hr = lpTable->SetColumns((LPSPropTagArray)&ptaEid, 0);
  if (FAILED(hr)) {
    MAPI_TRACE2("SetColumns for attachment table failed: 0x%lx, %d\r\n",
                (long)hr, (int)hr);
    return false;
  }

  hr = lpTable->SeekRow(BOOKMARK_BEGINNING, 0, NULL);
  if (FAILED(hr)) {
    MAPI_TRACE2("SeekRow for attachment table failed: 0x%lx, %d\r\n", (long)hr,
                (int)hr);
    return false;
  }

  int cNumRows = 0;
  LPSRowSet lpRow;
  bool bResult = true;
  do {
    lpRow = NULL;
    hr = lpTable->QueryRows(1, 0, &lpRow);

    if (HR_FAILED(hr)) {
      MAPI_TRACE2("QueryRows for attachment table failed: 0x%lx, %d\n",
                  (long)hr, (int)hr);
      bResult = false;
      break;
    }

    if (lpRow) {
      cNumRows = lpRow->cRows;

      if (cNumRows) {
        DWORD aNum = lpRow->aRow[0].lpProps[ieidPR_ATTACH_NUM].Value.ul;
        AddAttachment(aNum);
        MAPI_TRACE1("\t\t****Attachment found - #%d\r\n", (int)aNum);
      }
      CMapiApi::FreeProws(lpRow);
    }

  } while (SUCCEEDED(hr) && cNumRows && lpRow);

  return bResult;
}

bool CMapiMessage::GetTmpFile(/*out*/ nsIFile** aResult) {
  nsCOMPtr<nsIFile> tmpFile;
  nsresult rv = GetSpecialDirectoryWithFileName(
      NS_OS_TEMP_DIR, "mapiattach.tmp", getter_AddRefs(tmpFile));
  if (NS_FAILED(rv)) return false;

  rv = tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
  if (NS_FAILED(rv)) return false;

  tmpFile.forget(aResult);
  return true;
}

bool CMapiMessage::CopyMsgAttachToFile(LPATTACH lpAttach,
                                       /*out*/ nsIFile** tmp_file) {
  LPMESSAGE lpMsg;
  HRESULT hr = lpAttach->OpenProperty(PR_ATTACH_DATA_OBJ, &IID_IMessage, 0, 0,
                                      reinterpret_cast<LPUNKNOWN*>(&lpMsg));
  if (HR_FAILED(hr)) return false;

  if (!GetTmpFile(tmp_file)) return false;

  nsCOMPtr<nsIOutputStream> destOutputStream;
  nsresult rv = MsgNewBufferedFileOutputStream(getter_AddRefs(destOutputStream),
                                               *tmp_file, -1, 0600);
  if (NS_SUCCEEDED(rv))
    rv = ImportMailboxRunnable::ImportMessage(lpMsg, destOutputStream,
                                              nsIMsgSend::nsMsgSaveAsDraft);

  if (NS_FAILED(rv)) {
    (*tmp_file)->Remove(false);
    (*tmp_file)->Release();
    *tmp_file = 0;
  }

  return NS_SUCCEEDED(rv);
}

bool CMapiMessage::CopyBinAttachToFile(LPATTACH lpAttach, nsIFile** tmp_file) {
  nsCOMPtr<nsIFile> _tmp_file;
  nsresult rv = GetSpecialDirectoryWithFileName(
      NS_OS_TEMP_DIR, "mapiattach.tmp", getter_AddRefs(_tmp_file));
  NS_ENSURE_SUCCESS(rv, false);

  rv = _tmp_file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 00600);
  NS_ENSURE_SUCCESS(rv, false);

  nsString tmpPath = _tmp_file->NativePath();
  // We have to use native charset unless we migrate to Outlook 2013 "W" API.
  nsCString tmpNativePath;
  rv = NS_CopyUnicodeToNative(tmpPath, tmpNativePath);
  NS_ENSURE_SUCCESS(rv, false);
  LPSTREAM lpStreamFile;
  HRESULT hr = CMapiApi::OpenStreamOnFile(
      gpMapiAllocateBuffer, gpMapiFreeBuffer, STGM_READWRITE | STGM_CREATE,
      tmpNativePath.get(), NULL, &lpStreamFile);
  if (HR_FAILED(hr)) {
    MAPI_TRACE1("~~ERROR~~ OpenStreamOnFile failed - temp path: %s\r\n",
                tmpNativePath.get());
    return false;
  }

  bool bResult = true;
  LPSTREAM lpAttachStream;
  hr = lpAttach->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream, 0, 0,
                              (LPUNKNOWN*)&lpAttachStream);

  if (HR_FAILED(hr)) {
    MAPI_TRACE0("~~ERROR~~ OpenProperty failed for PR_ATTACH_DATA_BIN.\r\n");
    lpAttachStream = NULL;
    bResult = false;
  } else {
    STATSTG st;
    hr = lpAttachStream->Stat(&st, STATFLAG_NONAME);
    if (HR_FAILED(hr)) {
      MAPI_TRACE0("~~ERROR~~ Stat failed for attachment stream\r\n");
      bResult = false;
    } else {
      hr = lpAttachStream->CopyTo(lpStreamFile, st.cbSize, NULL, NULL);
      if (HR_FAILED(hr)) {
        MAPI_TRACE0("~~ERROR~~ Attach Stream CopyTo temp file failed.\r\n");
        bResult = false;
      }
    }
  }

  if (lpAttachStream) lpAttachStream->Release();
  lpStreamFile->Release();
  if (!bResult)
    _tmp_file->Remove(false);
  else
    _tmp_file.forget(tmp_file);

  return bResult;
}

bool CMapiMessage::GetURL(nsIFile* aFile, nsIURI** url) {
  if (!m_pIOService) return false;

  nsresult rv = m_pIOService->NewFileURI(aFile, url);
  return NS_SUCCEEDED(rv);
}

bool CMapiMessage::AddAttachment(DWORD aNum) {
  LPATTACH lpAttach = NULL;
  HRESULT hr = m_lpMsg->OpenAttach(aNum, NULL, 0, &lpAttach);
  if (HR_FAILED(hr)) {
    MAPI_TRACE2(
        "\t\t****Attachment error, unable to open attachment: %d, 0x%lx\r\n",
        idx, hr);
    return false;
  }

  bool bResult = false;
  attach_data* data = new attach_data;
  ULONG aMethod;
  if (data) {
    bResult = true;

    // 1. Get the file that contains the attachment data
    LPSPropValue pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_METHOD);
    if (pVal) {
      aMethod = CMapiApi::GetLongFromProp(pVal);
      switch (aMethod) {
        case ATTACH_BY_VALUE:
          MAPI_TRACE1("\t\t** Attachment #%d by value.\r\n", aNum);
          bResult =
              CopyBinAttachToFile(lpAttach, getter_AddRefs(data->tmp_file));
          data->delete_file = true;
          break;
        case ATTACH_BY_REFERENCE:
        case ATTACH_BY_REF_RESOLVE:
        case ATTACH_BY_REF_ONLY:
          pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_PATHNAME_W);
          if (pVal) {
            nsCString path;
            CMapiApi::GetStringFromProp(pVal, path);
            nsresult rv;
            data->tmp_file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
            if (NS_FAILED(rv) || !data->tmp_file) {
              MAPI_TRACE0("*** Error creating file spec for attachment\n");
              bResult = false;
            } else
              data->tmp_file->InitWithNativePath(path);
          }
          MAPI_TRACE2("\t\t** Attachment #%d by ref: %s\r\n", aNum,
                      m_attachPath.get());
          break;
        case ATTACH_EMBEDDED_MSG:
          MAPI_TRACE1("\t\t** Attachment #%d by Embedded Message??\r\n", aNum);
          // Convert the embedded IMessage from PR_ATTACH_DATA_OBJ to rfc822
          // attachment (see
          // http://msdn.microsoft.com/en-us/library/cc842329.aspx) This is a
          // recursive call.
          bResult =
              CopyMsgAttachToFile(lpAttach, getter_AddRefs(data->tmp_file));
          data->delete_file = true;
          break;
        case ATTACH_OLE:
          MAPI_TRACE1("\t\t** Attachment #%d by OLE - yuck!!!\r\n", aNum);
          break;
        default:
          MAPI_TRACE2(
              "\t\t** Attachment #%d unknown attachment method - 0x%lx\r\n",
              aNum, aMethod);
          bResult = false;
      }
    } else
      bResult = false;

    if (bResult) bResult = data->tmp_file;

    if (bResult) {
      bool isFile = false;
      bool exists = false;
      data->tmp_file->Exists(&exists);
      data->tmp_file->IsFile(&isFile);

      if (!exists || !isFile) {
        bResult = false;
        MAPI_TRACE0("Attachment file does not exist\n");
      }
    }

    if (bResult)
      bResult = GetURL(data->tmp_file, getter_AddRefs(data->orig_url));

    if (bResult) {
      // Now we have the file; proceed to the other properties

      data->encoding = NS_xstrdup(ENCODING_BINARY);

      nsString fname, fext;
      pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_LONG_FILENAME_W);
      if (!pVal)
        pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_FILENAME_W);
      CMapiApi::GetStringFromProp(pVal, fname);
      pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_EXTENSION_W);
      CMapiApi::GetStringFromProp(pVal, fext);
      MAPI_TRACE2("\t\t\t--- File name: %s, extension: %s\r\n", fname.get(),
                  fext.get());

      if (fext.IsEmpty()) {
        int idx = fname.RFindChar(L'.');
        if (idx != -1) fext = Substring(fname, idx);
      } else if (fname.RFindChar(L'.') == -1) {
        fname += L".";
        fname += fext;
      }
      if (fname.IsEmpty()) {
        // If no description use "Attachment i" format.
        fname = L"Attachment ";
        fname.AppendInt(static_cast<uint32_t>(aNum));
      }
      data->real_name = ToNewUTF8String(fname);

      nsCString tmp;
      // We have converted it to the rfc822 document
      if (aMethod == ATTACH_EMBEDDED_MSG) {
        data->type = NS_xstrdup(MESSAGE_RFC822);
      } else {
        pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_MIME_TAG_A);
        CMapiApi::GetStringFromProp(pVal, tmp);
        MAPI_TRACE1("\t\t\t--- Mime type: %s\r\n", tmp.get());
        if (tmp.IsEmpty()) {
          uint8_t* pType = NULL;
          if (!fext.IsEmpty()) {
            pType = CMimeTypes::GetMimeType(fext);
          }
          if (pType)
            data->type = NS_xstrdup((PC_S8)pType);
          else
            data->type = NS_xstrdup(APPLICATION_OCTET_STREAM);
        } else
          data->type = ToNewCString(tmp);
      }

      pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_CONTENT_ID_A);
      CMapiApi::GetStringFromProp(pVal, tmp);
      if (!tmp.IsEmpty()) data->cid = ToNewCString(tmp);
    }
    if (bResult) {
      // Now we need to decide if this attachment is embedded or not.
      // At first, I tried to simply check for the presence of the Content-Id.
      // But it turned out that this method is unreliable, since there exist
      // cases when an attachment has a Content-Id while isn't embedded (even in
      // a message with a plain-text body!). So next I tried to look for <img>
      // tags that contain the found Content-Id. But this is unreliable, too,
      // because there exist cases where other places of HTML reference the
      // embedded messages (e.g. it may be a background of a table cell, or some
      // CSS; further, it is possible that the reference to an embedded object
      // is not in the main body, but in another embedded object - like body
      // references a CSS attachment that in turn references a picture as a
      // background of its element). From the other hand, it's unreliable to
      // relax the search criteria to any occurrence of the Content-Id string in
      // the body - partly because the string may be simply in a text or other
      // non-referencing part, partly because of the abovementioned possibility
      // that the reference is outside the body at all. There exist the
      // PR_ATTACH_FLAGS property of the attachment. The MS documentation tells
      // about two possible flags in it: ATT_INVISIBLE_IN_HTML and
      // ATT_INVISIBLE_IN_RTF. There is at least one more undocumented flag:
      // ATT_MHTML_REF. Some sources in Internet suggest simply check for the
      // latter flag to distinguish between the embedded and ordinary
      // attachments. But my observations indicate that even if the flags don't
      // include ATT_MHTML_REF, the attachment is still may be embedded.
      // However, my observations always show that the message is embedded if
      // the flags is not 0. So now I will simply test for the non-zero flags to
      // decide whether the attachment is embedded or not. Possible advantage is
      // reliability (I hope). Another advantage is that it's much faster than
      // search the body for Content-Id.

      DWORD flags = 0;

      pVal = CMapiApi::GetMapiProperty(lpAttach, PR_ATTACH_FLAGS);
      if (pVal) flags = CMapiApi::GetLongFromProp(pVal);
      if (m_bodyIsHtml && data->cid &&
          (flags != 0))  // this is the embedded attachment
        m_embattachments.push_back(data);
      else  // this is ordinary attachment
        m_stdattachments.push_back(data);
    } else {
      delete data;
    }
  }

  lpAttach->Release();
  return bResult;
}

void CMapiMessage::ClearAttachment(attach_data* data) {
  if (data->delete_file && data->tmp_file) data->tmp_file->Remove(false);

  if (data->type) free(data->type);
  if (data->encoding) free(data->encoding);
  if (data->real_name) free(data->real_name);
  if (data->cid) free(data->cid);

  delete data;
}

void CMapiMessage::ClearAttachments() {
  std::for_each(m_stdattachments.begin(), m_stdattachments.end(),
                ClearAttachment);
  m_stdattachments.clear();
  std::for_each(m_embattachments.begin(), m_embattachments.end(),
                ClearAttachment);
  m_embattachments.clear();
}

// This method must be called AFTER the retrieval of the body,
// since the decision if an attachment is embedded or not is made
// based on the body type and contents
void CMapiMessage::ProcessAttachments() {
  LPSPropValue pVal = CMapiApi::GetMapiProperty(m_lpMsg, PR_HASATTACH);
  bool hasAttach = true;

  if (pVal) {
    if (PROP_TYPE(pVal->ulPropTag) == PT_BOOLEAN)
      hasAttach = (pVal->Value.b != 0);
    CMapiApi::MAPIFreeBuffer(pVal);
  }

  if (!hasAttach) return;

  // Get the attachment table?
  LPMAPITABLE pTable = NULL;
  HRESULT hr = m_lpMsg->GetAttachmentTable(0, &pTable);
  if (FAILED(hr) || !pTable) return;
  IterateAttachTable(pTable);
  pTable->Release();
}

nsresult CMapiMessage::GetAttachments(
    nsTArray<RefPtr<nsIMsgAttachedFile>>& attachments) {
  attachments.Clear();
  attachments.SetCapacity(m_stdattachments.size());

  for (std::vector<attach_data*>::const_iterator it = m_stdattachments.begin();
       it != m_stdattachments.end(); it++) {
    nsresult rv;
    nsCOMPtr<nsIMsgAttachedFile> a(
        do_CreateInstance("@mozilla.org/messengercompose/attachedfile;1", &rv));
    NS_ENSURE_SUCCESS(rv, rv);
    a->SetOrigUrl((*it)->orig_url);
    a->SetTmpFile((*it)->tmp_file);
    a->SetEncoding(nsDependentCString((*it)->encoding));
    a->SetRealName(nsDependentCString((*it)->real_name));
    a->SetType(nsDependentCString((*it)->type));
    attachments.AppendElement(a);
  }
  return NS_OK;
}

bool CMapiMessage::GetEmbeddedAttachmentInfo(unsigned int i, nsIURI** uri,
                                             const char** cid,
                                             const char** name) const {
  if (i >= m_embattachments.size()) return false;
  attach_data* data = m_embattachments[i];
  if (!data) return false;
  *uri = data->orig_url;
  *cid = data->cid;
  *name = data->real_name;
  return true;
}

//////////////////////////////////////////////////////

// begin and end MUST point to the same string
char* dup(const char* begin, const char* end) {
  if (begin >= end) return 0;
  char* str = new char[end - begin + 1];
  memcpy(str, begin, (end - begin) * sizeof(begin[0]));
  str[end - begin] = 0;
  return str;
}

// See RFC822
// 9 = '\t', 32 = ' '.
inline bool IsPrintableASCII(char c) { return (c > ' ') && (c < 127); }
inline bool IsWSP(char c) { return (c == ' ') || (c == '\t'); }

CMapiMessageHeaders::CHeaderField::CHeaderField(const char* begin, int len)
    : m_fname(0), m_fbody(0), m_fbody_utf8(false) {
  const char *end = begin + len, *fname_end = begin;
  while ((fname_end < end) && IsPrintableASCII(*fname_end) &&
         (*fname_end != ':'))
    ++fname_end;
  if ((fname_end == end) || (*fname_end != ':')) return;  // Not a valid header!
  m_fname = dup(begin, fname_end + 1);                    // including colon
  m_fbody = dup(fname_end + 1, end);
}

CMapiMessageHeaders::CHeaderField::CHeaderField(const char* name,
                                                const char* body, bool utf8)
    : m_fname(dup(name, name + strlen(name))),
      m_fbody(dup(body, body + strlen(body))),
      m_fbody_utf8(utf8) {}

CMapiMessageHeaders::CHeaderField::~CHeaderField() {
  delete[] m_fname;
  delete[] m_fbody;
}

void CMapiMessageHeaders::CHeaderField::set_fbody(const char* txt) {
  if (m_fbody == txt) return;  // to avoid assigning to self
  char* oldbody = m_fbody;
  m_fbody = dup(txt, txt + strlen(txt));
  delete[] oldbody;
  m_fbody_utf8 = true;
}

void CMapiMessageHeaders::CHeaderField::GetUnfoldedString(
    nsString& dest, const char* fallbackCharset) const {
  dest.Truncate();
  if (!m_fbody) return;

  nsCString unfolded;
  const char* pos = m_fbody;
  while (*pos) {
    if ((*pos == nsCRT::CR) && (*(pos + 1) == nsCRT::LF) && IsWSP(*(pos + 2)))
      pos += 2;  // Skip CRLF if it is followed by SPACE or TAB
    else
      unfolded.Append(*(pos++));
  }
  if (m_fbody_utf8)
    CopyUTF8toUTF16(unfolded, dest);
  else
    nsMsgI18NConvertToUnicode(
        fallbackCharset ? nsDependentCString(fallbackCharset) : EmptyCString(),
        unfolded, dest);
}

////////////////////////////////////////

const char* CMapiMessageHeaders::Specials[hdrMax] = {
    "Date:",    "From:",         "Sender:",       "Reply-To:",
    "To:",      "Cc:",           "Bcc:",          "Message-ID:",
    "Subject:", "Mime-Version:", "Content-Type:", "Content-Transfer-Encoding:"};

CMapiMessageHeaders::~CMapiMessageHeaders() { ClearHeaderFields(); }

void CMapiMessageHeaders::Delete(CHeaderField* p) { delete p; }

void CMapiMessageHeaders::ClearHeaderFields() {
  std::for_each(m_headerFields.begin(), m_headerFields.end(), Delete);
  m_headerFields.clear();
}

void CMapiMessageHeaders::Assign(const char* headers) {
  for (int i = 0; i < hdrMax; i++) m_SpecialHeaders[i] = 0;
  ClearHeaderFields();
  if (!headers) return;

  const char *start = headers, *end = headers;
  while (*end) {
    if ((*end == nsCRT::CR) && (*(end + 1) == nsCRT::LF)) {
      if (!IsWSP(
              *(end +
                2))) {  // Not SPACE nor TAB (avoid FSP) -> next header or EOF
        Add(new CHeaderField(start, end - start));
        start = ++end + 1;
      }
    }
    ++end;
  }

  if (start < end) {  // Last header left
    Add(new CHeaderField(start, end - start));
  }
}

void CMapiMessageHeaders::Add(CHeaderField* f) {
  if (!f) return;
  if (!f->Valid()) {
    delete f;
    return;
  }

  SpecialHeader idx = CheckSpecialHeader(f->fname());
  if (idx != hdrNone) {
    // Now check if the special header was already inserted;
    // if so, remove previous and add this new
    CHeaderField* PrevSpecial = m_SpecialHeaders[idx];
    if (PrevSpecial) {
      std::vector<CHeaderField*>::iterator iter =
          std::find(m_headerFields.begin(), m_headerFields.end(), PrevSpecial);
      if (iter != m_headerFields.end()) m_headerFields.erase(iter);
      delete PrevSpecial;
    }
    m_SpecialHeaders[idx] = f;
  }
  m_headerFields.push_back(f);
}

CMapiMessageHeaders::SpecialHeader CMapiMessageHeaders::CheckSpecialHeader(
    const char* fname) {
  for (int i = hdrFirst; i < hdrMax; i++)
    if (stricmp(fname, Specials[i]) == 0) return static_cast<SpecialHeader>(i);

  return hdrNone;
}

const CMapiMessageHeaders::CHeaderField* CMapiMessageHeaders::CFind(
    const char* name) const {
  SpecialHeader special = CheckSpecialHeader(name);
  if ((special > hdrNone) && (special < hdrMax))
    return m_SpecialHeaders[special];  // No need to search further, because it
                                       // MUST be here

  std::vector<CHeaderField*>::const_iterator iter = std::find_if(
      m_headerFields.begin(), m_headerFields.end(), fname_equals(name));
  if (iter == m_headerFields.end()) return 0;
  return *iter;
}

const char* CMapiMessageHeaders::SpecialName(SpecialHeader special) {
  if ((special <= hdrNone) || (special >= hdrMax)) return 0;
  return Specials[special];
}

const char* CMapiMessageHeaders::Value(SpecialHeader special) const {
  if ((special <= hdrNone) || (special >= hdrMax)) return 0;
  return (m_SpecialHeaders[special]) ? m_SpecialHeaders[special]->fbody() : 0;
}

const char* CMapiMessageHeaders::Value(const char* name) const {
  const CHeaderField* result = CFind(name);
  return result ? result->fbody() : 0;
}

void CMapiMessageHeaders::UnfoldValue(const char* name, nsString& dest,
                                      const char* fallbackCharset) const {
  const CHeaderField* result = CFind(name);
  if (result)
    result->GetUnfoldedString(dest, fallbackCharset);
  else
    dest.Truncate();
}

void CMapiMessageHeaders::UnfoldValue(SpecialHeader special, nsString& dest,
                                      const char* fallbackCharset) const {
  if ((special <= hdrNone) || (special >= hdrMax) ||
      (!m_SpecialHeaders[special]))
    dest.Truncate();
  else
    m_SpecialHeaders[special]->GetUnfoldedString(dest, fallbackCharset);
}

int CMapiMessageHeaders::SetValue(const char* name, const char* value,
                                  bool replace) {
  if (!replace) {
    CHeaderField* result = Find(name);
    if (result) {
      result->set_fbody(value);
      return 0;
    }
  }
  Add(new CHeaderField(name, value, true));
  return 0;  // No sensible result is returned; maybe do something senseful
             // later
}

int CMapiMessageHeaders::SetValue(SpecialHeader special, const char* value) {
  CHeaderField* result = m_SpecialHeaders[special];
  if (result)
    result->set_fbody(value);
  else
    Add(new CHeaderField(Specials[special], value, true));
  return 0;
}

void CMapiMessageHeaders::write_to_stream::operator()(const CHeaderField* f) {
  if (!f || NS_FAILED(m_rv)) return;

  uint32_t written;
  m_rv = m_pDst->Write(f->fname(), strlen(f->fname()), &written);
  NS_ENSURE_SUCCESS_VOID(m_rv);
  if (f->fbody()) {
    m_rv = m_pDst->Write(f->fbody(), strlen(f->fbody()), &written);
    NS_ENSURE_SUCCESS_VOID(m_rv);
  }
  m_rv = m_pDst->Write("\x0D\x0A", 2, &written);
}

nsresult CMapiMessageHeaders::ToStream(nsIOutputStream* pDst) const {
  nsresult rv = std::for_each(m_headerFields.begin(), m_headerFields.end(),
                              write_to_stream(pDst));
  if (NS_SUCCEEDED(rv)) {
    uint32_t written;
    rv = pDst->Write("\x0D\x0A", 2, &written);  // Separator line
  }
  return rv;
}