bool CMAPIAdviseSink::_GetIgnoredFolders()
{
LPSPropValue rgprops = NULL;
// LPSPropValue lppPropArray = NULL;
ULONG cValues = 0;
// IMAPIFolder *pPOPInboxFolder = NULL;
SizedSPropTagArray(1, rgFolderTags) = {1, { /* PR_IPM_OUTBOX_ENTRYID, */ PR_CE_IPM_DRAFTS_ENTRYID, } };
HRESULT hr = m_pStore->GetProps((LPSPropTagArray)&rgFolderTags, MAPI_UNICODE, &cValues, &rgprops);
if(FAILED(hr))
return false;
for (ULONG i = 0; i < 1; i++)
{
ULONG cbEntryID = rgprops[i].Value.bin.cb;
LPENTRYID lpEntryID = (LPENTRYID)rgprops[i].Value.bin.lpb;
rawEntryID* reID = new rawEntryID;
reID->cbSize = cbEntryID;
reID->lpEntryID = (LPBYTE)lpEntryID;
//_ignoredFolders.push_back(reID);
IMAPIFolder* pFolder = NULL;
hr = m_pStore->OpenEntry(
cbEntryID,
lpEntryID,
NULL,
MAPI_MODIFY,
NULL,
(LPUNKNOWN*)&pFolder);
if (!pFolder) {
MAPIFreeBuffer(rgprops);
return false;
}
SizedSPropTagArray(1, ptaFolder) = {1, {PR_DISPLAY_NAME}};
LPSPropValue rgFolderProps = NULL;
pFolder->GetProps((LPSPropTagArray)&ptaFolder, MAPI_UNICODE, &cValues, &rgFolderProps);
LPWSTR lpFolderName = rgFolderProps[0].Value.lpszW;
}
MAPIFreeBuffer(rgprops);
return true;
}
// if I try to use MAPI_UNICODE when UNICODE is defined I get the MAPI_E_BAD_CHARWIDTH
// error so I force narrow strings here
LPCTSTR CExMapi::GetProfileName()
{
if(!m_pSession) return NULL;
static CString strProfileName;
LPSRowSet pRows=NULL;
const int nProperties=2;
SizedSPropTagArray(nProperties,Columns)={nProperties,{PR_DISPLAY_NAME_A, PR_RESOURCE_TYPE}};
IMAPITable* pStatusTable;
if(m_pSession->GetStatusTable(0,&pStatusTable)==S_OK) {
if(pStatusTable->SetColumns((LPSPropTagArray)&Columns, 0)==S_OK) {
while(TRUE) {
if(pStatusTable->QueryRows(1,0,&pRows)!=S_OK) MAPIFreeBuffer(pRows);
else if(pRows->cRows!=1) FreeProws(pRows);
else if(pRows->aRow[0].lpProps[1].Value.ul==MAPI_SUBSYSTEM) {
strProfileName=(LPSTR)GetValidString(pRows->aRow[0].lpProps[0]);
FreeProws(pRows);
} else {
FreeProws(pRows);
continue;
}
break;
}
}
RELEASE(pStatusTable);
}
return strProfileName;
}
int MAPIRfc2445::GetNumHiddenAttachments()
{
int retval = 0;
HRESULT hr = S_OK;
LPCWSTR errMsg;
Zimbra::Util::ScopedInterface<IStream> pSrcStream;
Zimbra::Util::ScopedRowSet pAttachRows;
Zimbra::Util::ScopedInterface<IMAPITable> pAttachTable;
SizedSPropTagArray(1, attachProps) = {
1, { PR_ATTACHMENT_HIDDEN }
};
hr = m_pMessage->GetAttachmentTable(MAPI_UNICODE, pAttachTable.getptr());
if (SUCCEEDED(hr))
{
if (FAILED(hr = pAttachTable->SetColumns((LPSPropTagArray) &attachProps, 0)))
{
errMsg = FormatExceptionInfo(hr, L"Error setting attachment table columns", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
ULONG ulRowCount = 0;
if (FAILED(hr = pAttachTable->GetRowCount(0, &ulRowCount)))
{
errMsg = FormatExceptionInfo(hr, L"Error getting attachment table row count", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
if (FAILED(hr = pAttachTable->QueryRows(ulRowCount, 0, pAttachRows.getptr())))
{
errMsg = FormatExceptionInfo(hr, L"Error querying attachment table rows", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
if (SUCCEEDED(hr))
{
hr = MAPI_E_NOT_FOUND;
for (unsigned int i = 0; i < pAttachRows->cRows; i++)
{
// if property couldn't be found or returns error, skip it
if ((pAttachRows->aRow[i].lpProps[0].ulPropTag != PT_ERROR) &&
(pAttachRows->aRow[i].lpProps[0].Value.err != MAPI_E_NOT_FOUND))
{
if (pAttachRows->aRow[i].lpProps[0].Value.b)
{
retval++;
}
}
}
}
}
else
{
errMsg = FormatExceptionInfo(hr, L"Error getting attachment tables", __FILE__, __LINE__);
dlogw(errMsg);
return 0;
}
return retval;
}
LPWSTR getFolderName(IMsgStore* pStore, ULONG cbEntryID, LPENTRYID lpEntryID)
{
HRESULT hRes = E_FAIL;
ULONG ulObjType = MAPI_FOLDER;
LPMAPIFOLDER lpFolder = NULL;
// Get parent folder
hRes = pStore->OpenEntry(cbEntryID, lpEntryID, 0, 0, &ulObjType, (LPUNKNOWN*)&lpFolder);
if (hRes != S_OK) {
return NULL;
}
SizedSPropTagArray(2, ptaFolder) = {2, {PR_DISPLAY_NAME, PR_ENTRYID}};
LPSPropValue rgFolderProps = NULL;
ULONG cValues = 0;
// Get parent folder properties
hRes = lpFolder->GetProps((LPSPropTagArray)&ptaFolder, MAPI_UNICODE, &cValues, &rgFolderProps);
if (hRes != S_OK) {
lpFolder->Release();
return NULL;
}
// folder name
return rgFolderProps[0].Value.lpszW;
}
HRESULT MAPIAppointment::UpdateAttendeeFromEntryId(Attendee &pAttendee,
SBinary &eid)
{
Zimbra::Util::ScopedInterface<IMailUser> pUser;
ULONG ulObjType = 0;
if(!m_pAddrBook)
return E_FAIL;
HRESULT hr = m_pAddrBook->OpenEntry(eid.cb, (LPENTRYID)eid.lpb, NULL, MAPI_BEST_ACCESS,
&ulObjType, (LPUNKNOWN *)pUser.getptr());
if (FAILED(hr) || (ulObjType != MAPI_MAILUSER))
return E_FAIL;
SizedSPropTagArray(3, tags) = {
3, { PR_ADDRTYPE_W, PR_DISPLAY_NAME_W, PR_EMAIL_ADDRESS_W }
};
ULONG cVals = 0;
Zimbra::Util::ScopedBuffer<SPropValue> pVals;
hr = pUser->GetProps((LPSPropTagArray) & tags, MAPI_UNICODE, &cVals, pVals.getptr());
if (FAILED(hr))
return hr;
// no smtp address, bail
if ((pVals->ulPropTag != PR_ADDRTYPE_W) || (wcsicmp(pVals->Value.lpszW, L"SMTP") != 0))
return E_FAIL;
if ((pVals[1].ulPropTag == PR_DISPLAY_NAME_W) && ((pAttendee.nam == L"")))
pAttendee.nam = pVals[1].Value.lpszW;
if ((pVals[2].ulPropTag == PR_EMAIL_ADDRESS_W) && (pAttendee.addr == L""))
pAttendee.addr=pVals[2].Value.lpszW;
return S_OK;
}
ULONGLONG ComputeSingleFolderSize(
_In_ LPMAPIFOLDER lpFolder)
{
HRESULT hRes = S_OK;
LPMAPITABLE lpTable = NULL;
LPSRowSet lpsRowSet = NULL;
SizedSPropTagArray (1, sProps) = { 1, {PR_MESSAGE_SIZE} };
ULONGLONG ullThisFolderSize = 0;
// Look at each item in this folder
WC_MAPI(lpFolder->GetContentsTable(0, &lpTable));
if (lpTable)
{
WC_MAPI(HrQueryAllRows(lpTable, (LPSPropTagArray)&sProps, NULL, NULL, 0, &lpsRowSet));
if (lpsRowSet)
{
for(ULONG i = 0; i < lpsRowSet->cRows; i++)
{
if (PROP_TYPE(lpsRowSet->aRow[i].lpProps[0].ulPropTag) != PT_ERROR)
ullThisFolderSize += lpsRowSet->aRow[i].lpProps[0].Value.l;
}
MAPIFreeBuffer(lpsRowSet);
lpsRowSet = NULL;
}
lpTable->Release();
lpTable = NULL;
}
DebugPrint(DBGGeneric, "Content size = %I64u\n", ullThisFolderSize);
// printf("Content size = %I64d\n", ullThisFolderSize);
WC_MAPI(lpFolder->GetContentsTable(MAPI_ASSOCIATED, &lpTable));
if (lpTable)
{
WC_MAPI(HrQueryAllRows(lpTable, (LPSPropTagArray)&sProps, NULL, NULL, 0, &lpsRowSet));
if (lpsRowSet)
{
for(ULONG i = 0; i < lpsRowSet->cRows; i++)
{
if (PROP_TYPE(lpsRowSet->aRow[i].lpProps[0].ulPropTag) != PT_ERROR)
ullThisFolderSize += lpsRowSet->aRow[i].lpProps[0].Value.l;
}
MAPIFreeBuffer(lpsRowSet);
lpsRowSet = NULL;
}
lpTable->Release();
lpTable = NULL;
}
DebugPrint(DBGGeneric, "Total size = %I64u\n", ullThisFolderSize);
// printf("Total size = %I64d\n", ullThisFolderSize);
return ullThisFolderSize;
} // ComputeSingleFolderSize
BOOL CMAPIEx::GetContents(LPMAPIFOLDER pFolder) {
if (!pFolder) {
pFolder = m_pFolder;
if (!pFolder) return FALSE;
}
RELEASE(m_pContents);
if (pFolder->GetContentsTable(CMAPIEx::cm_nMAPICode, &m_pContents) != S_OK) return FALSE;
const int nProperties = MESSAGE_COLS;
SizedSPropTagArray(nProperties, Columns) = { nProperties, { PR_MESSAGE_FLAGS, PR_ENTRYID } };
return m_pContents->SetColumns((LPSPropTagArray) & Columns, 0) == S_OK;
}
BOOL CExMapi::OpenDefaultMessageStore(LPCTSTR szStore,ULONG ulFlags)
{
if(!m_pSession) return FALSE;
m_ulMDBFlags=ulFlags;
LPSRowSet pRows = NULL;
const int nProperties = 3;
SizedSPropTagArray(nProperties,Columns)={nProperties,{PR_DISPLAY_NAME, PR_ENTRYID, PR_DEFAULT_STORE}};
BOOL bResult = FALSE;
IMAPITable* pMsgStoresTable;
if(m_pSession->GetMsgStoresTable(0, &pMsgStoresTable) == S_OK)
{
if(pMsgStoresTable->SetColumns((LPSPropTagArray)&Columns, 0) == S_OK)
{
while(TRUE)
{
if(pMsgStoresTable->QueryRows(1,0,&pRows) != S_OK)
MAPIFreeBuffer(pRows);
else if(pRows->cRows!=1)
FreeProws(pRows);
else
{
if(!szStore)
{
if(pRows->aRow[0].lpProps[2].Value.b) bResult=TRUE;
}
else
{
CString strStore = GetValidString(pRows->aRow[0].lpProps[0]);
if(strStore.Find(szStore) != -1)
bResult = TRUE;
}
if(!bResult)
{
FreeProws(pRows);
continue;
}
}
break;
}
if(bResult)
{
RELEASE(m_pMsgStore);
bResult = (m_pSession->OpenMsgStore(NULL,pRows->aRow[0].lpProps[1].Value.bin.cb,(ENTRYID*)pRows->aRow[0].lpProps[1].Value.bin.lpb,NULL,MDB_NO_DIALOG | MAPI_BEST_ACCESS,&m_pMsgStore) == S_OK);
FreeProws(pRows);
}
}
RELEASE(pMsgStoresTable);
}
return bResult;
}
void COLAddrFolder::ExtractContents()
{
m_contents.clear();
if (!m_initRef->Inited())
return;
if (!m_pABCont)
return;
LPMAPITABLE pContentTable = NULL;
if (SUCCEEDED(m_pABCont->GetContentsTable(0, &pContentTable)))
{
SizedSPropTagArray ( 4, sptCols ) = {4, PR_DISPLAY_NAME, PR_SMTP_ADDRESS, PR_EMAIL_ADDRESS, PR_ADDRTYPE};
LPSRowSet pRowSet = NULL;
if (SUCCEEDED(g_pMAPIEDK->pHrQueryAllRows(pContentTable, reinterpret_cast<SPropTagArray*>(&sptCols), NULL, NULL, 0, &pRowSet)))
{
m_contents.reserve(pRowSet->cRows);
for (ULONG i = 0; i < pRowSet->cRows; ++i)
{
string addrType;
if (LPSPropValue lpDN = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_ADDRTYPE))
{
addrType = lpDN->Value.lpszA ? lpDN->Value.lpszA : "";
}
if (0 == addrType.compare("SMTP"))
{
if (LPSPropValue lpDN = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_EMAIL_ADDRESS))
{
if (lpDN->Value.lpszA)
m_contents.push_back(lpDN->Value.lpszA);
}
}
else
{
if (LPSPropValue lpDN = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_SMTP_ADDRESS))
{
if (lpDN->Value.lpszA)
m_contents.push_back(lpDN->Value.lpszA);
}
}
}
g_pMAPIEDK->pFreeProws(pRowSet);
}
}
if (pContentTable)
pContentTable->Release();
}
LPMAPITABLE CMAPIEx::GetHierarchy(LPMAPIFOLDER pFolder) {
if (!pFolder) {
pFolder = m_pFolder;
if (!pFolder) return NULL;
}
RELEASE(m_pHierarchy);
if (pFolder->GetHierarchyTable(0, &m_pHierarchy) != S_OK) return NULL;
const int nProperties = 2;
SizedSPropTagArray(nProperties, Columns) = { nProperties, { PR_DISPLAY_NAME, PR_ENTRYID } };
if (m_pHierarchy->SetColumns((LPSPropTagArray) & Columns, 0) == S_OK) return m_pHierarchy;
return NULL;
}
/* open inbox */
bool Mapix::openInbox()
{
if(m_lpSession && m_lpMsgstore && m_lpFolder)
{
clearCommonObjects();
result = m_lpFolder->GetHierarchyTable(NULL, &m_lpTable);
if(result != S_OK)
{
setError(result);
return 0;
}
else
{
const int nProperties = 2;
SizedSPropTagArray(nProperties, Column) = {nProperties, {PR_DISPLAY_NAME, PR_ENTRYID}};
result = m_lpTable->SetColumns((LPSPropTagArray)&Column, 0);
if(result == S_OK)
{
while(m_lpTable->QueryRows(1,0, &m_lpRows) == S_OK)
{
if(m_lpRows->cRows != 1)
break;
else
{
selectedFlag = openSpecialFolder(INBOX, m_lpRows->aRow[0].lpProps[1].Value.bin, m_lpMsgstore);
if(selectedFlag)
{
selectedFlag = FALSE;
clearCommonObjects();
return 1;
}
}
}
}
else
{
setError(result);
return 0;
}
}
}
else
return 0;
return 0;
}
void COLAddrBook::GetProfiles(Profiles& profiles)
{
profiles.clear();
LPPROFADMIN pProfAdmin = NULL;
if (SUCCEEDED(g_pMAPIEDK->pMAPIAdminProfiles(0, &pProfAdmin)))
{
LPMAPITABLE pProfTable = NULL;
if (SUCCEEDED(pProfAdmin->GetProfileTable(0, &pProfTable)))
{
SizedSPropTagArray ( 2, sptCols ) = {2, PR_DISPLAY_NAME, PR_DEFAULT_PROFILE};
LPSRowSet pRowSet = NULL;
if (SUCCEEDED(g_pMAPIEDK->pHrQueryAllRows(pProfTable, reinterpret_cast<SPropTagArray*>(&sptCols), NULL, NULL, 0, &pRowSet)))
{
for (ULONG i = 0; i < pRowSet->cRows; ++i)
{
bool bDefaultProfile = false;
if (LPSPropValue pPVN = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_DEFAULT_PROFILE))
{
bDefaultProfile = pPVN->Value.b != 0;
}
if (LPSPropValue pPVN = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_DISPLAY_NAME))
{
profiles.push_back(std::make_pair(pPVN->Value.lpszA ? pPVN->Value.lpszA : "", bDefaultProfile));
}
}
g_pMAPIEDK->pFreeProws(pRowSet);
}
}
if (pProfTable)
pProfTable->Release();
}
if (pProfAdmin)
pProfAdmin->Release();
}
HRESULT ArchiverSession::GetUserInfo(const abentryid_t &sEntryId, tstring *lpstrUser, tstring *lpstrFullname)
{
HRESULT hr = hrSuccess;
ULONG ulType = 0;
MAPIPropPtr ptrUser;
ULONG cUserProps = 0;
SPropArrayPtr ptrUserProps;
SizedSPropTagArray(2, sptaUserProps) = {2, {PR_ACCOUNT, PR_DISPLAY_NAME}};
enum {IDX_ACCOUNT, IDX_DISPLAY_NAME};
hr = m_ptrSession->OpenEntry(sEntryId.size(), sEntryId, NULL, MAPI_DEFERRED_ERRORS, &ulType, &ptrUser);
if (hr != hrSuccess)
goto exit;
hr = ptrUser->GetProps((LPSPropTagArray)&sptaUserProps, 0, &cUserProps, &ptrUserProps);
if (FAILED(hr))
goto exit;
hr = hrSuccess;
if (lpstrUser) {
if (PROP_TYPE(ptrUserProps[IDX_ACCOUNT].ulPropTag) != PT_ERROR)
lpstrUser->assign(ptrUserProps[IDX_ACCOUNT].Value.LPSZ);
else
lpstrUser->assign(_T("<Unknown>"));
}
if (lpstrFullname) {
if (PROP_TYPE(ptrUserProps[IDX_DISPLAY_NAME].ulPropTag) != PT_ERROR)
lpstrFullname->assign(ptrUserProps[IDX_DISPLAY_NAME].Value.LPSZ);
else
lpstrFullname->assign(_T("<Unknown>"));
}
exit:
return hr;
}
// if I try to use MAPI_UNICODE when UNICODE is defined I get the MAPI_E_BAD_CHARWIDTH
// error so I force narrow strings here
BOOL CMAPIEx::GetProfileName(CString& strProfileName)
{
BOOL bResult=FALSE;
#ifndef _WIN32_WCE
if(!m_pSession) return FALSE;
LPSRowSet pRows=NULL;
const int nProperties=2;
SizedSPropTagArray(nProperties, Columns)={nProperties,{PR_DISPLAY_NAME_A, PR_RESOURCE_TYPE}};
IMAPITable* pStatusTable;
if(m_pSession->GetStatusTable(0, &pStatusTable)==S_OK)
{
if(pStatusTable->SetColumns((LPSPropTagArray)&Columns, 0)==S_OK)
{
while(pStatusTable->QueryRows(1, 0, &pRows)==S_OK)
{
if(pRows->cRows!=1) FreeProws(pRows);
else if(pRows->aRow[0].lpProps[1].Value.ul==MAPI_SUBSYSTEM)
{
strProfileName=(LPSTR)GetValidString(pRows->aRow[0].lpProps[0]);
FreeProws(pRows);
bResult=TRUE;
}
else
{
FreeProws(pRows);
continue;
}
break;
}
}
RELEASE(pStatusTable);
}
#endif
return bResult;
}
HRESULT AddReportTag(LPMESSAGE lpMessage)
{
if (!lpMessage) return MAPI_E_INVALID_PARAMETER;
HRESULT hRes = S_OK;
ULONG cValues = 0;
LPSPropValue lpPropArray = NULL;
SizedSPropTagArray(2, sptaProps) = { 2, { PR_PARENT_ENTRYID, PR_SEARCH_KEY } };
hRes = lpMessage->GetProps((LPSPropTagArray)&sptaProps, 0, &cValues, &lpPropArray);
if (SUCCEEDED(hRes))
{
SPropValue sProp = { 0 };
sProp.ulPropTag = PR_REPORT_TAG;
hRes = BuildReportTag(NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
(lpPropArray[0].ulPropTag == PR_PARENT_ENTRYID) ? lpPropArray[0].Value.bin.cb : 0,
(lpPropArray[0].ulPropTag == PR_PARENT_ENTRYID) ? lpPropArray[0].Value.bin.lpb : 0,
(lpPropArray[1].ulPropTag == PR_SEARCH_KEY) ? lpPropArray[1].Value.bin.cb : 0,
(lpPropArray[1].ulPropTag == PR_SEARCH_KEY) ? lpPropArray[1].Value.bin.lpb : 0,
"",
&sProp.Value.bin.cb,
&sProp.Value.bin.lpb);
if (SUCCEEDED(hRes) && sProp.Value.bin.cb && sProp.Value.bin.lpb)
{
hRes = lpMessage->SetProps(1, &sProp, NULL);
}
delete[] sProp.Value.bin.lpb;
}
return hRes;
}
/* open special folder */
bool Mapix::openSpecialFolder(CString folderName, SBinary bin, LPMDB msgStore)
{
LPMAPITABLE table = NULL;
LPMAPIFOLDER m_folder= NULL;
ULONG objectType = NULL;
LPSRowSet pRows = NULL;
result = msgStore->OpenEntry(bin.cb, (LPENTRYID)bin.lpb, NULL, MAPI_MODIFY|MAPI_BEST_ACCESS, &objectType, (LPUNKNOWN*)&m_folder);
if(result != S_OK)
{
setError(result);
return 0;
}
else
{
result = m_folder->GetHierarchyTable(NULL, &table);
if(result == S_OK)
{
const int nProperties = 2;
SizedSPropTagArray(nProperties, Column) = {nProperties, {PR_DISPLAY_NAME, PR_ENTRYID}};
result = table->SetColumns((LPSPropTagArray)&Column, 0);
if(result == S_OK)
{
while(table->QueryRows(1,0, &pRows) == S_OK)
{
if(pRows->cRows != 1)
break;
else
{
CString nameOfFolder( pRows->aRow[0].lpProps[0].Value.lpszW);
if(nameOfFolder == folderName)
{
sBin = pRows->aRow[0].lpProps[1].Value.bin;
m_lpInboxMsgStore = msgStore;
m_folder->Release();
table->Release();
pRows = NULL;
return 1;
}
// open enumarate folder
openSpecialFolder(folderName, pRows->aRow[0].lpProps[1].Value.bin, msgStore);
}
}
}
else
{
setError(result);
return 0;
}
}
else
{
setError(result);
return 0;
}
}
return 0;
}
HRESULT ExchangeAdmin::CreateProfile(wstring strProfileName, wstring strMailboxName, wstring
strPassword)
{
HRESULT hr = S_OK;
Zimbra::Util::ScopedBuffer<char> strServer;
Zimbra::Util::ScopedBuffer<char> strMBName;
Zimbra::Util::ScopedBuffer<char> strProfName;
Zimbra::Util::ScopedBuffer<char> strProfPwd;
Zimbra::Util::ScopedInterface<IMsgServiceAdmin> pSvcAdmin;
Zimbra::Util::ScopedInterface<IMAPITable> pMsgSvcTable;
Zimbra::Util::ScopedRowSet pSvcRows;
SPropValue rgval[2] = { 0 };
SPropValue sProps = { 0 };
SRestriction sres;
WCHAR errDescrption[256] = {};
// Columns to get from HrQueryAllRows.
enum { iSvcName, iSvcUID, cptaSvc };
SizedSPropTagArray(cptaSvc, sptCols) = { cptaSvc, PR_SERVICE_NAME, PR_SERVICE_UID };
WtoA((LPWSTR)strProfileName.c_str(), strProfName.getref());
WtoA((LPWSTR)strPassword.c_str(), strProfPwd.getref());
// create new profile
if (FAILED(hr = m_pProfAdmin->CreateProfile((LPTSTR)strProfName.get(),
(LPTSTR)strProfPwd.get(), NULL, 0)))
{
throw ExchangeAdminException(hr, L"CreateProfile(): CreateProfile Failed.",
ERR_CREATE_EXCHPROFILE, __LINE__, __FILE__);
}
// Get an IMsgServiceAdmin interface off of the IProfAdmin interface.
if (FAILED(hr = m_pProfAdmin->AdminServices((LPTSTR)strProfName.get(),
(LPTSTR)strProfPwd.get(), NULL, 0, pSvcAdmin.getptr())))
{
wcscpy(errDescrption, L"CreateProfile(): AdminServices Failed.");
goto CRT_PROFILE_EXIT;
}
// Create the new message service for Exchange.
if (FAILED(hr = pSvcAdmin->CreateMsgService((LPTSTR)"MSEMS", (LPTSTR)"MSEMS", NULL, NULL)))
{
wcscpy(errDescrption, L"CreateProfile(): CreateMsgService Failed.");
goto CRT_PROFILE_EXIT;
}
// Need to obtain the entry id for the new service. This can be done by getting the message service table
// and getting the entry that corresponds to the new service.
if (FAILED(hr = pSvcAdmin->GetMsgServiceTable(0, pMsgSvcTable.getptr())))
{
wcscpy(errDescrption, L"CreateProfile(): GetMsgServiceTable Failed.");
goto CRT_PROFILE_EXIT;
}
sres.rt = RES_CONTENT;
sres.res.resContent.ulFuzzyLevel = FL_FULLSTRING;
sres.res.resContent.ulPropTag = PR_SERVICE_NAME;
sres.res.resContent.lpProp = &sProps;
sProps.ulPropTag = PR_SERVICE_NAME;
sProps.Value.lpszA = "MSEMS";
// Query the table to obtain the entry for the newly created message service.
if (FAILED(hr = HrQueryAllRows(pMsgSvcTable.get(), (LPSPropTagArray) & sptCols, NULL, NULL,
0, pSvcRows.getptr())))
{
wcscpy(errDescrption, L"CreateProfile(): HrQueryAllRows Failed.");
goto CRT_PROFILE_EXIT;
}
// Set up a SPropValue array for the properties that you have to configure.
if (pSvcRows->cRows > 0)
{
// First, the exchange server name.
ZeroMemory(&rgval[0], sizeof (SPropValue));
rgval[0].ulPropTag = PR_PROFILE_UNRESOLVED_SERVER;
WtoA((LPWSTR)m_strServer.c_str(), strServer.getref());
rgval[0].Value.lpszA = (LPSTR)strServer.get();
// Next, the user's AD name.
ZeroMemory(&rgval[1], sizeof (SPropValue));
rgval[1].ulPropTag = PR_PROFILE_UNRESOLVED_NAME;
WtoA((LPWSTR)strMailboxName.c_str(), strMBName.getref());
rgval[1].Value.lpszA = (LPSTR)strMBName.get();
// Configure the message service by using the previous properties.
// int trials = 10;
int trials = 2;
int itrTrials = 0;
hr = 0x81002746; // WSAECONNRESET
while ((hr == 0x81002746) && (itrTrials < trials))
{
hr = pSvcAdmin->ConfigureMsgService(
(LPMAPIUID)pSvcRows->aRow->lpProps[iSvcUID].Value.bin.lpb, NULL, 0, 2, rgval);
//if (hr == 0x81002746)
// Sleep(30000);
//Sleep(10000);
itrTrials++;
}
if (FAILED(hr))
{
/* =
* pSvcAdmin->ConfigureMsgService((LPMAPIUID)pSvcRows->aRow->lpProps[iSvcUID].
* Value.bin.lpb,NULL, 0, 2, rgval)))*/
wcscpy(errDescrption, L"CreateProfile(): ConfigureMsgService Failed.");
goto CRT_PROFILE_EXIT;
}
}
CRT_PROFILE_EXIT:
if (hr != S_OK)
{
DeleteProfile(strProfileName);
throw ExchangeAdminException(hr, errDescrption, ERR_CREATE_EXCHPROFILE, __LINE__, __FILE__);
}
else
{
//Create supporting OL profile entries else crash may happen!
if(!Zimbra::MAPI::Util::SetOLProfileRegistryEntries(strProfileName.c_str()))
{
throw ExchangeAdminException(hr, L"ExchangeAdmin::CreateProfile()::SetOLProfileRegistryEntries Failed.",
ERR_CREATE_EXCHPROFILE, __LINE__, __FILE__);
}
/* Zimbra::Util::ScopedBuffer<char> strProfName;
WtoA((LPWSTR)strProfileName.c_str(), strProfName.getref());
hr=m_pProfAdmin->SetDefaultProfile((LPTSTR)strProfName.get(),NULL);
*/
}
return hr;
}
HRESULT MAPIAppointment::SetOrganizerAndAttendees()
{
Zimbra::Util::ScopedInterface<IMAPITable> pRecipTable;
HRESULT hr = 0;
hr = m_pMessage->GetRecipientTable(fMapiUnicode, pRecipTable.getptr());
if (FAILED(hr))
{
return hr;
}
typedef enum _AttendeePropTagIdx
{
AT_ADDRTYPE, AT_ENTRYID, AT_DISPLAY_NAME, AT_SMTP_ADDR, AT_RECIPIENT_FLAGS, AT_RECIPIENT_TYPE, AT_RECIPIENT_TRACKSTATUS,AT_EMAIL_ADDRESS, AT_NPROPS
} AttendeePropTagIdx;
SizedSPropTagArray(AT_NPROPS, reciptags) = {
AT_NPROPS, { PR_ADDRTYPE, PR_ENTRYID, PR_DISPLAY_NAME_W, PR_SMTP_ADDRESS_W, PR_RECIPIENT_FLAGS, PR_RECIPIENT_TYPE, PR_RECIPIENT_TRACKSTATUS,PR_EMAIL_ADDRESS }
};
ULONG ulRows = 0;
Zimbra::Util::ScopedRowSet pRecipRows;
hr = pRecipTable->SetColumns((LPSPropTagArray) & reciptags, 0);
if (FAILED(hr))
{
//LOG_ERROR(_T("could not get the recipient table, hr: %x"), hr);
return hr;
}
hr = pRecipTable->GetRowCount(0, &ulRows);
if (FAILED(hr))
{
//LOG_ERROR(_T("could not get the recipient table row count, hr: %x"), hr);
return hr;
}
hr = pRecipTable->QueryRows(ulRows, 0, pRecipRows.getptr());
if (FAILED(hr))
{
//LOG_ERROR(_T("Failed to query table rows. hr: %x"), hr);
return hr;
}
if (pRecipRows != NULL)
{
for (ULONG iRow = 0; iRow < pRecipRows->cRows; iRow++)
{
if (pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_FLAGS].ulPropTag ==
reciptags.aulPropTag[AT_RECIPIENT_FLAGS])
{
if (pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_FLAGS].Value.l == 3)
{
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].ulPropTag) != PT_ERROR)
{
m_pOrganizerName = pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].Value.lpszW;
}
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].ulPropTag) != PT_ERROR)
{
m_pOrganizerAddr = pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].Value.lpszW;
}
if((lstrcmpiW(m_pOrganizerAddr.c_str(),L"") == 0) ||(m_pOrganizerName ==L""))
{
Attendee* pAttendee = new Attendee();
dlogi("Going to Update organizer from EID...");
if(UpdateAttendeeFromEntryId(*pAttendee,pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin) !=S_OK)
{
dlogi("Going to update organizer from AD");
RECIP_INFO tempRecip;
tempRecip.pAddrType = NULL;
tempRecip.pEmailAddr = NULL;
tempRecip.cbEid = 0;
tempRecip.pEid = NULL;
tempRecip.pAddrType =
pRecipRows->aRow[iRow].lpProps[AT_ADDRTYPE].Value.lpszW;
tempRecip.pEmailAddr =
pRecipRows->aRow[iRow].lpProps[AT_EMAIL_ADDRESS].Value.lpszW;
if (pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].ulPropTag != PT_ERROR)
{
tempRecip.cbEid =
pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin.cb;
tempRecip.pEid =
(LPENTRYID)pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value
.bin.lpb;
}
std::wstring wstrEmailAddress;
try
{
Zimbra::MAPI::Util::GetSMTPFromAD(*m_session, tempRecip,L"" , L"",wstrEmailAddress);
}
catch(...)
{
dlogw("mapiappointment::exception from MAPi::util::GetSMTPFromAD ");
}
pAttendee->addr = wstrEmailAddress;
dlogi("Email address(AD):",wstrEmailAddress);
dlogi("AD update end.");
}
dlogi("EID update end.");
if(m_pOrganizerAddr==L"")
m_pOrganizerAddr = pAttendee->addr;
if(m_pOrganizerName==L"")
m_pOrganizerName = pAttendee->nam;
}
dlogi("OrganizerAddr: ",m_pOrganizerAddr, " OrganizerName: ",m_pOrganizerName);
}
else
{
if (!(RECIP_FLAG_EXCEP_DELETED & pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_FLAGS].Value.l)) // make sure attendee wasn't deleted
{
Attendee* pAttendee = new Attendee(); // delete done in CMapiAccessWrap::GetData after we allocate dict string for ZimbraAPI
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].ulPropTag) != PT_ERROR)
pAttendee->nam = pRecipRows->aRow[iRow].lpProps[AT_DISPLAY_NAME].Value.lpszW;
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].ulPropTag) != PT_ERROR)
pAttendee->addr = pRecipRows->aRow[iRow].lpProps[AT_SMTP_ADDR].Value.lpszW;
wstring attaddress = pAttendee->addr;
if(lstrcmpiW(attaddress.c_str(),L"") == 0)
{
if (((pAttendee->nam==L"") || (pAttendee->addr==L"")) && (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].ulPropTag) != PT_ERROR))
{
dlogi("Going to Update attendee from EID...");
if(UpdateAttendeeFromEntryId(*pAttendee,pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin)!=S_OK)
{
dlogi("Going to update attendee from AD");
RECIP_INFO tempRecip;
tempRecip.pAddrType = NULL;
tempRecip.pEmailAddr = NULL;
tempRecip.cbEid = 0;
tempRecip.pEid = NULL;
tempRecip.pAddrType =
pRecipRows->aRow[iRow].lpProps[AT_ADDRTYPE].Value.lpszW;
tempRecip.pEmailAddr =
pRecipRows->aRow[iRow].lpProps[AT_EMAIL_ADDRESS].Value.lpszW;
if (pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].ulPropTag != PT_ERROR)
{
tempRecip.cbEid =
pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value.bin.cb;
tempRecip.pEid =
(LPENTRYID)pRecipRows->aRow[iRow].lpProps[AT_ENTRYID].Value
.bin.lpb;
}
std::wstring wstrEmailAddress;
try
{
Zimbra::MAPI::Util::GetSMTPFromAD(*m_session, tempRecip,L"" , L"",wstrEmailAddress);
}
catch(...)
{
dlogw(" Mapiappoinemtn::Exception in MAPI::Util::GetSMTPFromAD");
}
pAttendee->addr = wstrEmailAddress;
dlogi("Email address(AD):",wstrEmailAddress);
dlogi("AD update end.");
}
dlogi("EID update end.");
}
}
dlogi("AttendeeAddr: ",pAttendee->addr," AttendeeName :",pAttendee->nam);
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TYPE].ulPropTag) != PT_ERROR)
pAttendee->role = ConvertValueToRole(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TYPE].Value.l);
if (PROP_TYPE(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TRACKSTATUS].ulPropTag) != PT_ERROR)
pAttendee->partstat = ConvertValueToPartStat(pRecipRows->aRow[iRow].lpProps[AT_RECIPIENT_TRACKSTATUS].Value.l);
m_vAttendees.push_back(pAttendee);
}
}
}
}
}
return hr;
}
/**
* Populate the user list through one AB container.
* When this method completes, the userlist will be available for all users
* from the passed container that should have one or more archives attached to
* their primary store.
* @param[in] lpContainer The addressbook container to process.
*/
HRESULT ArchiveStateCollector::PopulateFromContainer(LPABCONT lpContainer)
{
HRESULT hr = hrSuccess;
SPropValue sPropObjType;
SPropValue sPropDispType;
SRestrictionPtr ptrRestriction;
MAPITablePtr ptrTable;
SRowSetPtr ptrRows;
SizedSPropTagArray(4, sptaUserProps) = {4, {PR_ENTRYID, PR_ACCOUNT, PR_EC_ARCHIVE_SERVERS, PR_EC_ARCHIVE_COUPLINGS}};
enum {IDX_ENTRYID, IDX_ACCOUNT, IDX_EC_ARCHIVE_SERVERS, IDX_EC_ARCHIVE_COUPLINGS};
ECAndRestriction resFilter(
ECPropertyRestriction(RELOP_EQ, PR_OBJECT_TYPE, &sPropObjType, ECRestriction::Cheap) +
ECPropertyRestriction(RELOP_EQ, PR_DISPLAY_TYPE, &sPropDispType, ECRestriction::Cheap) +
ECOrRestriction(
ECExistRestriction(PR_EC_ARCHIVE_SERVERS) +
ECExistRestriction(PR_EC_ARCHIVE_COUPLINGS)
)
);
sPropObjType.ulPropTag = PR_OBJECT_TYPE;
sPropObjType.Value.ul = MAPI_MAILUSER;
sPropDispType.ulPropTag = PR_DISPLAY_TYPE;
sPropDispType.Value.ul = DT_MAILUSER;;
hr = resFilter.CreateMAPIRestriction(&ptrRestriction, ECRestriction::Cheap);
if (hr != hrSuccess)
goto exit;
hr = lpContainer->GetContentsTable(0, &ptrTable);
if (hr != hrSuccess)
goto exit;
hr = ptrTable->SetColumns((LPSPropTagArray)&sptaUserProps, TBL_BATCH);
if (hr != hrSuccess)
goto exit;
hr = ptrTable->Restrict(ptrRestriction, TBL_BATCH);
if (hr != hrSuccess)
goto exit;
while (true) {
hr = ptrTable->QueryRows(50, 0, &ptrRows);
if (hr != hrSuccess)
goto exit;
if (ptrRows.size() == 0)
break;
for (SRowSetPtr::size_type i = 0; i < ptrRows.size(); ++i) {
ArchiveInfoMap::iterator iterator;
if (ptrRows[i].lpProps[IDX_ENTRYID].ulPropTag != PR_ENTRYID) {
m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Unable to get entryid from address list. hr=0x%08x", ptrRows[i].lpProps[IDX_ACCOUNT].Value.err);
continue;
}
if (ptrRows[i].lpProps[IDX_ACCOUNT].ulPropTag != PR_ACCOUNT) {
m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Unable to get username from address list. hr=0x%08x", ptrRows[i].lpProps[IDX_ACCOUNT].Value.err);
continue;
}
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Inserting row for user '" TSTRING_PRINTF "'", ptrRows[i].lpProps[IDX_ACCOUNT].Value.LPSZ);
iterator = m_mapArchiveInfo.insert(std::make_pair(abentryid_t(ptrRows[i].lpProps[IDX_ENTRYID].Value.bin), ArchiveInfo())).first;
iterator->second.userName.assign(ptrRows[i].lpProps[IDX_ACCOUNT].Value.LPSZ);
if (ptrRows[i].lpProps[IDX_EC_ARCHIVE_SERVERS].ulPropTag == PR_EC_ARCHIVE_SERVERS) {
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Adding %u archive server(s)", ptrRows[i].lpProps[IDX_EC_ARCHIVE_SERVERS].Value.MVSZ.cValues);
for (ULONG j = 0; j < ptrRows[i].lpProps[IDX_EC_ARCHIVE_SERVERS].Value.MVSZ.cValues; ++j)
iterator->second.lstServers.push_back(ptrRows[i].lpProps[IDX_EC_ARCHIVE_SERVERS].Value.MVSZ.LPPSZ[j]);
}
if (ptrRows[i].lpProps[IDX_EC_ARCHIVE_COUPLINGS].ulPropTag == PR_EC_ARCHIVE_COUPLINGS) {
m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Adding %u archive coupling(s)", ptrRows[i].lpProps[IDX_EC_ARCHIVE_COUPLINGS].Value.MVSZ.cValues);
for (ULONG j = 0; j < ptrRows[i].lpProps[IDX_EC_ARCHIVE_COUPLINGS].Value.MVSZ.cValues; ++j)
iterator->second.lstCouplings.push_back(ptrRows[i].lpProps[IDX_EC_ARCHIVE_COUPLINGS].Value.MVSZ.LPPSZ[j]);
}
}
}
exit:
return hr;
}
HRESULT ExchangeAdmin::GetAllProfiles(vector<string> &vProfileList)
{
HRESULT hr = S_OK;
Zimbra::Util::ScopedInterface<IMAPITable> pProftable;
// get profile table
if ((hr = m_pProfAdmin->GetProfileTable(0, pProftable.getptr())) == S_OK)
{
SizedSPropTagArray(3, proftablecols) = {
3, { PR_DISPLAY_NAME_A, PR_DEFAULT_PROFILE, PR_SERVICE_NAME }
};
Zimbra::Util::ScopedRowSet profrows;
// get all profile rows
if ((hr = HrQueryAllRows(pProftable.get(), (SPropTagArray *)&proftablecols, NULL, NULL,
0, profrows.getptr())) == S_OK)
{
for (unsigned int i = 0; i < profrows->cRows; i++)
{
if (profrows->aRow[i].lpProps[0].ulPropTag == PR_DISPLAY_NAME_A)
{
Zimbra::Util::ScopedInterface<IMsgServiceAdmin> spServiceAdmin;
Zimbra::Util::ScopedInterface<IMAPITable> spServiceTable;
string strpname = profrows->aRow[i].lpProps[0].Value.lpszA;
// get profile's admin service
hr = m_pProfAdmin->AdminServices((LPTSTR)strpname.c_str(), NULL, NULL, 0,
spServiceAdmin.getptr());
if (FAILED(hr))
throw ExchangeAdminException(hr,L"GetAllProfiles(): AdminServices Failed.",
ERR_GETALL_PROFILE, __LINE__, __FILE__);
// get message service table
hr = spServiceAdmin->GetMsgServiceTable(0, spServiceTable.getptr());
if (FAILED(hr))
{
throw ExchangeAdminException(hr,L"GetAllProfiles(): GetMsgServiceTable Failed.",
ERR_GETALL_PROFILE, __LINE__, __FILE__);
}
// lets get the service name and the service uid for the primary service
SizedSPropTagArray(2, tags) = {
2, { PR_SERVICE_NAME, PR_SERVICE_UID }
};
spServiceTable->SetColumns((LPSPropTagArray) & tags, 0);
DWORD dwCount = 0;
hr = spServiceTable->GetRowCount(0, &dwCount);
if (FAILED(hr))
throw ExchangeAdminException(hr,
L"GetAllProfiles(): GetRowCount Failed.",
ERR_GETALL_PROFILE, __LINE__, __FILE__);
else if (!dwCount)
return hr;
Zimbra::Util::ScopedRowSet pRows;
hr = spServiceTable->QueryRows(dwCount, 0, pRows.getptr());
if (FAILED(hr))
throw ExchangeAdminException(hr, L"GetAllProfiles(): QueryRows Failed.",
ERR_GETALL_PROFILE, __LINE__, __FILE__);
for (ULONG j = 0; j < pRows->cRows; j++)
{
if (PR_SERVICE_NAME == pRows->aRow[j].lpProps[0].ulPropTag)
{
// if MSExchange service
if (0 == lstrcmpiW(pRows->aRow[j].lpProps[0].Value.LPSZ, L"MSEMS"))
{
if (profrows->aRow[i].lpProps[0].ulPropTag == PR_DISPLAY_NAME_A)
vProfileList.push_back(
profrows->aRow[i].lpProps[0].Value.lpszA);
break;
}
}
}
}
}
}
}
return hr;
}
void COLFolderBase::ExtractChildFolders()
{
m_childs.clear();
if (!m_initRef->Inited())
return;
if (!m_pABCont)
return;
LPMAPITABLE pChildTable = NULL;
if (SUCCEEDED(m_pABCont->GetHierarchyTable(0, &pChildTable)))
{
SizedSPropTagArray ( 2, sptCols ) = {2, PR_DISPLAY_NAME, PR_ENTRYID};
LPSRowSet pRowSet = NULL;
if (SUCCEEDED(g_pMAPIEDK->pHrQueryAllRows(pChildTable, reinterpret_cast<SPropTagArray*>(&sptCols), NULL, NULL, 0, &pRowSet)))
{
for (ULONG i = 0; i < pRowSet->cRows; ++i)
{
string name;
if (LPSPropValue pPVN = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_DISPLAY_NAME))
{
name = pPVN->Value.lpszA ? pPVN->Value.lpszA : "";
}
LPABCONT pChildContainer = NULL;
if (LPSPropValue pPVE = g_pMAPIEDK->pPpropFindProp(pRowSet->aRow[i].lpProps, pRowSet->aRow[i].cValues, PR_ENTRYID))
{
SBinary entry = pPVE->Value.bin;
ULONG ulObjType = 0;
LPUNKNOWN pUnk = NULL;
if (SUCCEEDED(m_pABCont->OpenEntry(entry.cb, (LPENTRYID)entry.lpb, NULL, MAPI_BEST_ACCESS, &ulObjType, &pUnk)))
{
if (MAPI_ABCONT == ulObjType)
{
pChildContainer = (LPABCONT)pUnk;
pChildContainer->AddRef();
}
}
if (pUnk)
pUnk->Release();
}
if (pChildContainer)
{
m_childs.push_back(TAddrFolderPtr(new COLAddrFolder(name.c_str(), m_initRef, pChildContainer)));
pChildContainer->Release();
}
}
g_pMAPIEDK->pFreeProws(pRowSet);
}
}
if (pChildTable)
pChildTable->Release();
}
HRESULT CMailRuleClient::ProcessMessage(
IMsgStore *pMsgStore,
ULONG cbMsg,
LPENTRYID lpMsg,
ULONG cbDestFolder,
LPENTRYID lpDestFolder,
ULONG *pulEventType,
MRCHANDLED *pHandled)
{
HRESULT hr = S_OK;
IMessage *pMsg = NULL;
SizedSPropTagArray(1, sptaSubject) = { 1, PR_SUBJECT };
SizedSPropTagArray(1, sptaSenderEmailAddress) = { 1, PR_SENDER_EMAIL_ADDRESS };
ULONG cValues = 0;
SPropValue *pspvSubject = NULL;
SPropValue *pspvSenderEmailAddress = NULL;
if (this->m_cInitialized == false)
return hr;
//
// open message
//
hr = pMsgStore->OpenEntry(cbMsg, lpMsg, NULL, 0, NULL, (LPUNKNOWN *) &pMsg);
if (FAILED(hr)) {
DBG_TRACE(L"Failed opening message.", DBG_CRITICAL, TRUE);
return hr;
}
//
// get message properties
//
LPWSTR lpwSubject = NULL;
hr = pMsg->GetProps((SPropTagArray *) &sptaSubject, MAPI_UNICODE, &cValues, &pspvSubject);
if (FAILED(hr))
DBG_TRACE(L"Failed getting subject.", DBG_HIGH, FALSE);
else
lpwSubject = pspvSubject->Value.lpszW;
LPWSTR lpwPhoneNumber = NULL;
hr = pMsg->GetProps((SPropTagArray *) &sptaSenderEmailAddress, MAPI_UNICODE, &cValues, &pspvSenderEmailAddress);
if (FAILED(hr))
DBG_TRACE(L"Failed getting sender address.", DBG_HIGH, FALSE);
else
lpwPhoneNumber = pspvSenderEmailAddress->Value.lpszW;
DBG_TRACE(L"Sender phone number:", DBG_CRITICAL, FALSE);
DBG_TRACE(lpwPhoneNumber, DBG_CRITICAL, FALSE);
//
// write message to queue
//
IPCMsg* msg = new IPCMsg(lpwPhoneNumber, lpwSubject);
if (m_qWrite->WriteMessage(msg) == false)
{
DBG_TRACE(L"Write failed", DBG_HIGH, FALSE);
return S_OK;
}
DBG_TRACE(L"Message written to queue.", DBG_NOTIFY, FALSE);
//
// wait for reply
//
IPCMsg* msgReply = m_qRead->WaitForReply();
DWORD dwReply = IPC_PROCESS;
if (msgReply) {
dwReply = msgReply->Reply();
} else {
DBG_TRACE(L"No reply, assuming default (PROCESS)\n", DBG_HIGH, FALSE);
}
WCHAR lpwStr[256] = {0};
// ZeroMemory(lpwStr, 256 * sizeof(WCHAR));
switch(dwReply)
{
case IPC_HIDE:
this->DeleteMessage(pMsgStore, pMsg, cbMsg, lpMsg, cbDestFolder, lpDestFolder, pulEventType, pHandled);
if (pMsg)
pMsg->Release();
DBG_TRACE(L"Message deleted", DBG_NOTIFY, FALSE);
break;
case IPC_PROCESS:
default:
DBG_TRACE(L"Message accepted", DBG_NOTIFY, FALSE);
// do nothing
break;
}
if (msgReply)
delete msgReply;
DBG_TRACE(L"processing completed.", DBG_NOTIFY, FALSE);
return S_OK;
}
HRESULT MAPITask::SetMAPITaskValues()
{
SizedSPropTagArray(T_NUMALLTASKPROPS, taskProps) = {
T_NUMALLTASKPROPS, {
PR_MESSAGE_FLAGS, PR_SUBJECT, PR_BODY, PR_HTML, PR_IMPORTANCE, pr_isrecurringt, pr_recurstreamt, pr_status,
pr_percentcomplete, pr_taskstart, pr_taskdue, pr_totalwork,
pr_actualwork, pr_companies, pr_mileage, pr_billinginfo,
pr_taskreminderset, pr_taskflagdueby, pr_private
}
};
HRESULT hr = S_OK;
ULONG cVals = 0;
m_bHasAttachments = false;
m_bIsRecurring = false;
m_bIsTaskReminderSet = false;
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & taskProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPITaskException(hr, L"SetMAPITaskValues(): GetProps Failed.",
ERR_MAPI_TASK, __LINE__, __FILE__);
if (m_pPropVals[T_MESSAGE_FLAGS].ulPropTag == taskProps.aulPropTag[T_MESSAGE_FLAGS])
{
m_bHasAttachments = (m_pPropVals[T_MESSAGE_FLAGS].Value.l & MSGFLAG_HASATTACH) != 0;
}
if (m_pPropVals[T_ISRECURT].ulPropTag == taskProps.aulPropTag[T_ISRECURT]) // do this first to set dates correctly
{
m_bIsRecurring = (m_pPropVals[T_ISRECURT].Value.b == 1);
}
if (m_pPropVals[T_TASKREMINDERSET].ulPropTag == taskProps.aulPropTag[T_TASKREMINDERSET]) // do this first to set dates correctly
{
m_bIsTaskReminderSet = (m_pPropVals[T_TASKREMINDERSET].Value.b == 1);
}
if (m_pPropVals[T_SUBJECT].ulPropTag == taskProps.aulPropTag[T_SUBJECT])
{
SetSubject(m_pPropVals[T_SUBJECT].Value.lpszW);
}
if (m_pPropVals[T_IMPORTANCE].ulPropTag == taskProps.aulPropTag[T_IMPORTANCE])
{
SetImportance(m_pPropVals[T_IMPORTANCE].Value.l);
}
if (m_pPropVals[T_STATUS].ulPropTag == taskProps.aulPropTag[T_STATUS])
{
SetTaskStatus(m_pPropVals[T_STATUS].Value.l);
}
if (m_pPropVals[T_PERCENTCOMPLETE].ulPropTag == taskProps.aulPropTag[T_PERCENTCOMPLETE])
{
SetPercentComplete(m_pPropVals[T_PERCENTCOMPLETE].Value.dbl);
}
if (m_pPropVals[T_TASKSTART].ulPropTag == taskProps.aulPropTag[T_TASKSTART])
{
SetTaskStart(m_pPropVals[T_TASKSTART].Value.ft);
}
if (m_pPropVals[T_TASKDUE].ulPropTag == taskProps.aulPropTag[T_TASKDUE])
{
SetTaskDue(m_pPropVals[T_TASKDUE].Value.ft);
}
if (m_pPropVals[T_TOTALWORK].ulPropTag == taskProps.aulPropTag[T_TOTALWORK])
{
SetTotalWork(m_pPropVals[T_TOTALWORK].Value.l);
}
if (m_pPropVals[T_ACTUALWORK].ulPropTag == taskProps.aulPropTag[T_ACTUALWORK])
{
SetActualWork(m_pPropVals[T_ACTUALWORK].Value.l);
}
if (m_pPropVals[T_COMPANIES].ulPropTag == taskProps.aulPropTag[T_COMPANIES])
{
SetCompanies(m_pPropVals[T_COMPANIES].Value.MVszW.lppszW[0]); // get first one for now
}
if (m_pPropVals[T_MILEAGE].ulPropTag == taskProps.aulPropTag[T_MILEAGE])
{
SetMileage(m_pPropVals[T_MILEAGE].Value.lpszW);
}
if (m_pPropVals[T_BILLING].ulPropTag == taskProps.aulPropTag[T_BILLING])
{
SetBillingInfo(m_pPropVals[T_BILLING].Value.lpszW);
}
if (m_pPropVals[T_TASKFLAGDUEBY].ulPropTag == taskProps.aulPropTag[T_TASKFLAGDUEBY])
{
SetTaskFlagDueBy(m_pPropVals[T_TASKFLAGDUEBY].Value.ft);
}
if (m_pPropVals[T_PRIVATE].ulPropTag == taskProps.aulPropTag[T_PRIVATE])
{
SetPrivate(m_pPropVals[T_PRIVATE].Value.b);
}
SetPlainTextFileAndContent();
SetHtmlFileAndContent();
if (m_bHasAttachments)
{
if (FAILED(ExtractAttachments()))
{
dlogw(L"Could not extract attachments");
}
}
if (m_bIsRecurring)
{
if (m_pPropVals[T_RECURSTREAMT].ulPropTag == taskProps.aulPropTag[T_RECURSTREAMT])
{
SetRecurValues();
}
}
return hr;
}
HRESULT MAPIContact::GetContactImage(wstring &wstrImagePath)
{
HRESULT hr = S_OK;
Zimbra::Util::ScopedInterface<IStream> pSrcStream;
{
Zimbra::Util::ScopedRowSet pAttachRows;
Zimbra::Util::ScopedInterface<IMAPITable> pAttachTable;
SizedSPropTagArray(3, attachProps) = {
3, { PR_ATTACH_NUM, PR_ATTACH_SIZE, PR_ATTACH_LONG_FILENAME }
};
hr = m_pMessage->GetAttachmentTable(MAPI_UNICODE, pAttachTable.getptr());
if (SUCCEEDED(hr))
{
if (FAILED(hr = pAttachTable->SetColumns((LPSPropTagArray) & attachProps, 0)))
return hr;
ULONG ulRowCount = 0;
if (FAILED(hr = pAttachTable->GetRowCount(0, &ulRowCount)))
return hr;
if (FAILED(hr = pAttachTable->QueryRows(ulRowCount, 0, pAttachRows.getptr())))
return hr;
if (SUCCEEDED(hr))
{
hr = MAPI_E_NOT_FOUND;
for (unsigned int i = 0; i < pAttachRows->cRows; i++)
{
// if property couldn't be found or returns error, skip it
if ((pAttachRows->aRow[i].lpProps[2].ulPropTag == PT_ERROR) ||
(pAttachRows->aRow[i].lpProps[2].Value.err == MAPI_E_NOT_FOUND))
continue;
// Discard the attachmetnt if its not contact picture
if (_tcscmp(pAttachRows->aRow[i].lpProps[2].Value.LPSZ, _T(
"ContactPicture.jpg")))
continue;
Zimbra::Util::ScopedInterface<IAttach> pAttach;
if (FAILED(hr = m_pMessage->OpenAttach(
pAttachRows->aRow[i].lpProps[0].Value.l, NULL, 0,
pAttach.getptr())))
continue;
if (FAILED(hr = pAttach->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream,
STGM_READ, 0, (LPUNKNOWN FAR *)pSrcStream.getptr())))
return hr;
break;
}
}
}
}
if (hr != S_OK)
return hr;
// copy image to file
wstring wstrTempAppDirPath;
char *lpszDirName = NULL;
char *lpszUniqueName = NULL;
Zimbra::Util::ScopedInterface<IStream> pDestStream;
if (!Zimbra::MAPI::Util::GetAppTemporaryDirectory(wstrTempAppDirPath))
return MAPI_E_ACCESS_DENIED;
WtoA((LPWSTR)wstrTempAppDirPath.c_str(), lpszDirName);
string strFQFileName = lpszDirName;
WtoA((LPWSTR)Zimbra::MAPI::Util::GetUniqueName().c_str(), lpszUniqueName);
strFQFileName += "\\ZmContact_";
strFQFileName += lpszUniqueName;
strFQFileName += ".jpg";
SafeDelete(lpszDirName);
SafeDelete(lpszUniqueName);
// Open stream on file
if (FAILED(hr = OpenStreamOnFile(MAPIAllocateBuffer, MAPIFreeBuffer, STGM_CREATE |
STGM_READWRITE, (LPTSTR)strFQFileName.c_str(), NULL, pDestStream.getptr())))
return hr;
ULARGE_INTEGER liAll = { 0 };
liAll.QuadPart = (ULONGLONG)-1;
if (FAILED(hr = pSrcStream->CopyTo(pDestStream.get(), liAll, NULL, NULL)))
return hr;
if (FAILED(hr = pDestStream->Commit(0)))
{
return hr;
;
}
// mime file path
LPWSTR lpwstrFQFileName = NULL;
AtoW((LPSTR)strFQFileName.c_str(), lpwstrFQFileName);
wstrImagePath = lpwstrFQFileName;
SafeDelete(lpwstrFQFileName);
return hr;
}
/* opern root folder */
bool Mapix::openRootFolder()
{
if(m_lpSession)
{
// open msg store table that open mailbox in outlook
clearCommonObjects();
result = m_lpSession->GetMsgStoresTable(0, &m_lpTable);
if(result != S_OK)
{
m_lpTable->Release();
setError(result);
return 0;
}
else
{
const int nProperties = 3;
SizedSPropTagArray(nProperties, Column) = {nProperties, {PR_ENTRYID, PR_DEFAULT_STORE, PR_DISPLAY_NAME}};
result = m_lpTable->SetColumns((LPSPropTagArray)&Column, 0);
if(result == S_OK)
{
while(m_lpTable->QueryRows(1,0, &m_lpRows) == S_OK)
{
if(m_lpRows->cRows != 1)
break;
else
{
if(m_lpRows->aRow[0].lpProps[1].Value.b)
break;
}
}
if(m_lpRows->aRow[0].lpProps[1].Value.b)
{
result = m_lpSession->OpenMsgStore(NULL, m_lpRows->aRow[0].lpProps[0].Value.bin.cb,(LPENTRYID)m_lpRows->aRow[0].lpProps[0].Value.bin.lpb, NULL, MAPI_BEST_ACCESS|MDB_NO_DIALOG, &m_lpMsgstore);
if(result != S_OK)
{
setError(result);
return 0;
}
else
{
// release table objects
clearCommonObjects();
ULONG cbEntryID = 0;
LPENTRYID lpEntryID = NULL;
ULONG ulObjectType;
result = m_lpMsgstore->OpenEntry(cbEntryID, lpEntryID, NULL, MAPI_MODIFY|MAPI_BEST_ACCESS, &ulObjectType, (LPUNKNOWN*)&m_lpFolder);
if(result != S_OK)
{
setError(result);
return 0;
}
else
return 1;
}
}
else
return 0;
}
else
{
setError(result);
return 0;
}
}
}
else
return 0;
}
int CExtImpl::EncryptSignMessage(HWND hwnd,
IMessage *pmsg,
RECIPIENTDIALOGSTRUCT *prds,
PGPOptionListRef *pSignOptions)
{
IStream *pstrmBody = 0;
STATSTG StreamStats;
DWORD dwInSize;
UINT nOutSize;
BOOL bExchangeUser = FALSE;
char *pInput;
char *pOutput = NULL;
LPMAPITABLE ptableAttach = 0;
SizedSPropTagArray(1, tagaTable) = {
1, {PR_ATTACH_NUM}};
SRowSet *prAttach = 0;
PGPError nError = kPGPError_NoErr;
HRESULT hr;
char szName[256];
char szFile[256];
UIGetString(szName, sizeof(szName), IDS_LOGNAME);
UIGetString(szFile, sizeof(szFile), IDS_DLL);
pmsg->GetAttachmentTable(0, &ptableAttach);
HrQueryAllRows(ptableAttach, (SPropTagArray *)&tagaTable,
NULL, NULL, 0, &prAttach);
hr = pmsg->OpenProperty(PR_BODY, &IID_IStream, STGM_READ,
0, (IUnknown**)&pstrmBody);
if (FAILED(hr))
{
UIDisplayStringID(hwnd, IDS_E_NOBODY);
ptableAttach->Release();
return kPGPError_ItemNotFound;
}
pstrmBody->Stat(&StreamStats, STATFLAG_NONAME);
dwInSize = StreamStats.cbSize.LowPart;
pInput = (char *) calloc(dwInSize+1, sizeof(char));
if (!pInput)
{
UIDisplayStringID(hwnd, IDS_E_NOMEMORY);
pstrmBody->Release();
ptableAttach->Release();
return kPGPError_OutOfMemory;
}
pstrmBody->Read(pInput, dwInSize, &dwInSize);
pstrmBody->Release();
pInput[dwInSize] = 0;
nError = EncryptSignBuffer(UIGetInstance(), hwnd, _pgpContext,
_tlsContext, szName, szFile, pInput,
dwInSize, prds, NULL, pSignOptions, (VOID ** )&pOutput,
&nOutSize, _bEncrypt, _bSign, FALSE);
if ((dwInSize > 0) && IsntPGPError(nError))
{
LARGE_INTEGER li = {0,0};
ULARGE_INTEGER uli = {1,0};
BOOL fPartied;
pmsg->OpenProperty(PR_BODY, &IID_IStream, STGM_READWRITE,
MAPI_MODIFY, (IUnknown**)&pstrmBody);
pstrmBody->Seek(li, STREAM_SEEK_SET, NULL);
pstrmBody->Write("\0", 1, NULL);
pstrmBody->SetSize(uli);
pstrmBody->Commit(STGC_DEFAULT);
pstrmBody->Release();
RTFSync(pmsg, RTF_SYNC_BODY_CHANGED, &fPartied);
pmsg->OpenProperty(PR_BODY, &IID_IStream, STGM_READWRITE,
MAPI_MODIFY, (IUnknown**)&pstrmBody);
}
if (IsntPGPError(nError))
{
LARGE_INTEGER li = {0,0};
ULARGE_INTEGER uli = {nOutSize + prAttach->cRows, 0};
BOOL fPartied;
pstrmBody->Seek(li, STREAM_SEEK_SET, NULL);
pstrmBody->Write(pOutput, nOutSize, NULL);
pstrmBody->SetSize(uli);
pstrmBody->Commit(STGC_DEFAULT);
pstrmBody->Release();
RTFSync(pmsg, RTF_SYNC_BODY_CHANGED, &fPartied);
PGPFreeData(pOutput);
}
free(pInput);
if (IsntPGPError(nError))
{
hr = pmsg->OpenProperty(PR_BODY_HTML, &IID_IStream, STGM_READWRITE,
MAPI_MODIFY, (IUnknown**)&pstrmBody);
if (FAILED(hr))
goto NoBodyHTML;
else
{
LARGE_INTEGER li = {0,0};
ULARGE_INTEGER uli = {1,0};
BOOL fPartied;
pstrmBody->Seek(li, STREAM_SEEK_SET, NULL);
pstrmBody->Write("\0", 1, NULL);
pstrmBody->SetSize(uli);
pstrmBody->Commit(STGC_DEFAULT);
pstrmBody->Release();
RTFSync(pmsg, RTF_SYNC_BODY_CHANGED, &fPartied);
}
}
NoBodyHTML:
if (prAttach->cRows && IsntPGPError(nError))
nError = EncryptSignAttachment(hwnd, pmsg, nOutSize,
prAttach, prds, pSignOptions);
ptableAttach->Release();
return nError;
}
/* get inbox all emails in inbox folder */
bool Mapix::getInboxContent(LPMDB m_InboxMsgStore = NULL)
{
if(m_InboxMsgStore == NULL)
{
if(m_lpInboxMsgStore)
{
m_InboxMsgStore = m_lpInboxMsgStore;
clearCommonObjects();
}
else
return 0;
}
if(m_InboxMsgStore)
{
ULONG dwObjectType;
LPMAPIFOLDER m_Folder = NULL;
result = m_InboxMsgStore->OpenEntry(sBin.cb, (LPENTRYID)sBin.lpb, NULL, MAPI_MODIFY|MAPI_BEST_ACCESS, &dwObjectType, (LPUNKNOWN*)&m_Folder);
if(result == S_OK)
{
ULONG rowCount = getRowCountInInboxFolder(m_InboxMsgStore);
result = m_Folder->GetContentsTable(MAPI_UNICODE|MAPI_DEFERRED_ERRORS, &m_lpTable);
if(result != S_OK)
{
setError(result);
return 0;
}
else
{
contentOfMessage = new MailContent[rowCount+1];
const int nProperties = 6;
int i = 0;
SizedSPropTagArray(nProperties, Column) = {nProperties, PR_ENTRYID, PR_SENDER_NAME, PR_SENDER_EMAIL_ADDRESS, PR_BODY, PR_SUBJECT, PR_MESSAGE_DELIVERY_TIME};
result = m_lpTable->SetColumns((LPSPropTagArray)&Column, 0);
if(result == S_OK)
{
while(m_lpTable->QueryRows(1, 0, &m_lpRows) == S_OK)
{
if(m_lpRows->cRows != 1)
break;
else
{
if(m_lpRows->aRow[0].lpProps[1].Value.lpszW)
{
contentOfMessage[i].senderName = m_lpRows->aRow[0].lpProps[1].Value.lpszW;
contentOfMessage[i].SenderReceivedTime = getTimeToFileTimeObjects(m_lpRows->aRow[0].lpProps[5].Value.ft);
}
if(m_lpRows->aRow[0].lpProps[2].Value.lpszW)
contentOfMessage[i].senderEmail = m_lpRows->aRow[0].lpProps[2].Value.lpszW;
if(m_lpRows->aRow[0].lpProps[3].Value.lpszW)
contentOfMessage[i].senderBody = m_lpRows->aRow[0].lpProps[3].Value.lpszW;
if(m_lpRows->aRow[0].lpProps[4].Value.lpszW)
contentOfMessage[i].senderSubject = m_lpRows->aRow[0].lpProps[4].Value.lpszW;
}
i++;
}
}
else
{
setError(result);
return 0;
}
}
}
else
{
setError(result);
return 0;
}
}
else
return 0;
return 1;
}
BOOL CExMapi::OpenNextMessageStore(LPMAPITABLE lpMsgStoreTable, ULONG ulFlags)
{
if(!m_pSession) return FALSE;
if(!lpMsgStoreTable) return FALSE;
BOOL doLog = m_pCtrl->IsEnableLog();
if(doLog)
{
m_logHelper.LogPAB(L"Function OpenNextMessageStore START.");
}
m_ulMDBFlags = ulFlags;
LPSRowSet pRows = NULL;
const int nProperties = 1;
SizedSPropTagArray(nProperties,Columns)={nProperties,{PR_ENTRYID}};
BOOL bResult = FALSE;
try
{
if(lpMsgStoreTable->SetColumns((LPSPropTagArray)&Columns, 0) == S_OK)
{
while(TRUE)
{
bResult = FALSE;
if(lpMsgStoreTable->QueryRows(1,0,&pRows) != S_OK)
MAPIFreeBuffer(pRows);
else if(pRows->cRows!=1)
FreeProws(pRows);
else
{
LPMDB pMsgStore = NULL;
ULONG cbEntryId = pRows->aRow[0].lpProps[0].Value.bin.cb;
LPENTRYID lpEntryId = (ENTRYID*)pRows->aRow[0].lpProps[0].Value.bin.lpb;
bResult = (m_pSession->OpenMsgStore(NULL,
cbEntryId,
lpEntryId,
NULL,
MDB_NO_DIALOG | MAPI_BEST_ACCESS,
&pMsgStore) == S_OK);
if(bResult)
{
if(m_pMsgStore)
{
//check if new open msg store is the same as opened msg store.
if(AreSame(m_pMsgStore,pMsgStore))
{
if(doLog)
{
m_logHelper.LogPAB(L"Message Store is already opend.");
}
RELEASE(pMsgStore);
FreeProws(pRows);
continue;
}
else
{
RELEASE(m_pMsgStore);
m_pMsgStore = pMsgStore;
bResult = TRUE;
}
}
else
{
m_pMsgStore = pMsgStore;
}
}
FreeProws(pRows);
}
break;
}
}
}
catch(_com_error& e)
{
if(doLog)
{
m_logHelper.LogPAB(L"OpenNextMessageStore Exception:");
m_logHelper.LogPAB(e.ErrorMessage());
}
return FALSE;
}
if(doLog)
{
m_logHelper.LogPAB(L"Function OpenNextMessageStore END.");
}
return bResult;
}
HRESULT MAPIContact::Init()
{
HRESULT hr = S_OK;
Zimbra::Util::ScopedBuffer<SPropValue> pPropValMsgClass;
if (FAILED(hr = HrGetOneProp(m_pMessage, PR_MESSAGE_CLASS, pPropValMsgClass.getptr())))
throw MAPIContactException(hr, L"Init(): HrGetOneProp Failed.",
ERR_MAPI_CONTACT, __LINE__, __FILE__);
if ((pPropValMsgClass->ulPropTag == PR_MESSAGE_CLASS_W) && (_tcsicmp(
pPropValMsgClass->Value.LPSZ, L"ipm.distlist") == 0))
m_bPersonalDL = true;
// initialize the MAPINAMEID structure GetIDsFromNames requires
LPMAPINAMEID ppNames[N_NUM_NAMES] = { 0 };
for (int i = 0; i < N_NUM_NAMES; i++)
{
MAPIAllocateBuffer(sizeof (MAPINAMEID), (LPVOID *)&(ppNames[i]));
ppNames[i]->ulKind = MNID_ID;
ppNames[i]->lpguid = (LPGUID)(&PS_CONTACT_PROPERTIES);
ppNames[i]->Kind.lID = nameIds[i];
}
// get the real prop tag ID's
LPSPropTagArray pContactTags = NULL;
if (FAILED(hr = m_pMessage->GetIDsFromNames(N_NUM_NAMES, ppNames, MAPI_CREATE,
&pContactTags)))
throw MAPIContactException(hr, L"Init(): GetIDsFromNames Failed.",
ERR_MAPI_CONTACT, __LINE__, __FILE__);
// give the prop tag ID's a type
pr_mail1address = SetPropType(pContactTags->aulPropTag[N_MAIL1], PT_TSTRING);
pr_mail1entryid = SetPropType(pContactTags->aulPropTag[N_MAIL1EID], PT_BINARY);
pr_mail1type = SetPropType(pContactTags->aulPropTag[N_MAIL1TYPE], PT_TSTRING);
pr_mail1dispname = SetPropType(pContactTags->aulPropTag[N_MAIL1DISPNAME], PT_TSTRING);
pr_mail2address = SetPropType(pContactTags->aulPropTag[N_MAIL2], PT_TSTRING);
pr_mail2entryid = SetPropType(pContactTags->aulPropTag[N_MAIL2EID], PT_BINARY);
pr_mail2type = SetPropType(pContactTags->aulPropTag[N_MAIL2TYPE], PT_TSTRING);
pr_mail2dispname = SetPropType(pContactTags->aulPropTag[N_MAIL2DISPNAME], PT_TSTRING);
pr_mail3address = SetPropType(pContactTags->aulPropTag[N_MAIL3], PT_TSTRING);
pr_mail3entryid = SetPropType(pContactTags->aulPropTag[N_MAIL3EID], PT_BINARY);
pr_mail3type = SetPropType(pContactTags->aulPropTag[N_MAIL3TYPE], PT_TSTRING);
pr_mail3dispname = SetPropType(pContactTags->aulPropTag[N_MAIL3DISPNAME], PT_TSTRING);
pr_fileas = SetPropType(pContactTags->aulPropTag[N_FILEAS], PT_TSTRING);
pr_fileasID = SetPropType(pContactTags->aulPropTag[N_FILEAS_ID], PT_LONG);
pr_business_address_city = SetPropType(pContactTags->aulPropTag[N_BUS_CITY], PT_TSTRING);
pr_business_address_country = SetPropType(pContactTags->aulPropTag[N_BUS_COUNTRY],
PT_TSTRING);
pr_business_address_postal_code = SetPropType(pContactTags->aulPropTag[N_BUS_ZIP],
PT_TSTRING);
pr_business_address_state = SetPropType(pContactTags->aulPropTag[N_BUS_STATE], PT_TSTRING);
pr_business_address_street = SetPropType(pContactTags->aulPropTag[N_BUS_STREET],
PT_TSTRING);
pr_contact_user1_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER1_IDX],
PT_TSTRING);
pr_contact_user2_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER2_IDX],
PT_TSTRING);
pr_contact_user3_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER3_IDX],
PT_TSTRING);
pr_contact_user4_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER4_IDX],
PT_TSTRING);
pr_contact_oneoffmemebrs = SetPropType(
pContactTags->aulPropTag[N_CONTACT_ONEOFFMEMEBRS_IDX], PT_MV_BINARY);
pr_imaddress = SetPropType(pContactTags->aulPropTag[N_IMADDRESS], PT_TSTRING);
pr_anniversary = SetPropType(pContactTags->aulPropTag[N_ANNIVERSARY], PT_TSTRING);
// free the memory we allocated on the head
for (int i = 0; i < N_NUM_NAMES; i++)
MAPIFreeBuffer(ppNames[i]);
MAPIFreeBuffer(pContactTags);
// these are the contact properties we need to get
SizedSPropTagArray(C_NUM_PROPS, contactProps) = {
C_NUM_PROPS, {
PR_CALLBACK_TELEPHONE_NUMBER, PR_CAR_TELEPHONE_NUMBER, PR_COMPANY_NAME,
pr_mail1address, pr_mail1entryid, pr_mail1type, pr_mail1dispname,
pr_mail2address, pr_mail2entryid, pr_mail2type, pr_mail2dispname,
pr_mail3address, pr_mail3entryid, pr_mail3type, pr_mail3dispname, pr_fileas,
pr_fileasID, PR_GIVEN_NAME, PR_HOME_ADDRESS_CITY, PR_HOME_ADDRESS_COUNTRY,
PR_HOME_FAX_NUMBER, PR_HOME_TELEPHONE_NUMBER, PR_HOME2_TELEPHONE_NUMBER,
PR_HOME_ADDRESS_POSTAL_CODE, PR_HOME_ADDRESS_STATE_OR_PROVINCE,
PR_HOME_ADDRESS_STREET, PR_TITLE, PR_SURNAME, PR_MIDDLE_NAME,
PR_CELLULAR_TELEPHONE_NUMBER, PR_DISPLAY_NAME_PREFIX, PR_GENERATION,
// notes is PR_BODY and PR_BODY_HTML
PR_OTHER_ADDRESS_CITY, PR_OTHER_ADDRESS_COUNTRY, PR_PRIMARY_FAX_NUMBER, // other fax
PR_OTHER_TELEPHONE_NUMBER, PR_OTHER_ADDRESS_POSTAL_CODE,
PR_OTHER_ADDRESS_STATE_OR_PROVINCE, PR_OTHER_ADDRESS_STREET,
PR_PAGER_TELEPHONE_NUMBER, pr_business_address_city,
pr_business_address_country, PR_BUSINESS_FAX_NUMBER, PR_OFFICE_TELEPHONE_NUMBER,
pr_business_address_postal_code, pr_business_address_state,
pr_business_address_street, PR_BUSINESS_HOME_PAGE, PR_BIRTHDAY,
pr_contact_user1_idx, pr_contact_user2_idx, pr_contact_user3_idx,
pr_contact_user4_idx, pr_contact_oneoffmemebrs, pr_imaddress,
PR_WEDDING_ANNIVERSARY
}
};
ULONG cVals = 0;
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & contactProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPIContactException(hr, L"Init(): GetProps Failed.",
ERR_MAPI_CONTACT, __LINE__, __FILE__);
// see if there is a file-as id
LONG zimbraFileAsId = 0;
if (m_bPersonalDL) // PDL's always have a custom file-as
{
zimbraFileAsId = 8;
Type(L"group");
}
else if (m_pPropVals[C_FILEASID].ulPropTag == contactProps.aulPropTag[C_FILEASID])
{
switch (m_pPropVals[C_FILEASID].Value.l)
{
case OFA_LAST_C_FIRST:
zimbraFileAsId = 1;
break;
case OFA_FIRST_LAST:
zimbraFileAsId = 2;
break;
case OFA_COMPANY:
zimbraFileAsId = 3;
break;
case OFA_LAST_C_FIRST_COMPANY:
zimbraFileAsId = 4;
break;
case OFA_COMPANY_LAST_C_FIRST:
zimbraFileAsId = 6;
break;
case OFA_CUSTOM:
zimbraFileAsId = 8;
break;
}
}
// process all "String" properties
if (m_pPropVals[C_CALLBACK_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_CALLBACK_TELEPHONE_NUMBER])
CallbackPhone(m_pPropVals[C_CALLBACK_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_CAR_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_CAR_TELEPHONE_NUMBER])
CarPhone(m_pPropVals[C_CAR_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_COMPANY_NAME].ulPropTag == contactProps.aulPropTag[C_COMPANY_NAME])
Company(m_pPropVals[C_COMPANY_NAME].Value.lpszW);
if (m_pPropVals[C_FILEAS].ulPropTag == contactProps.aulPropTag[C_FILEAS])
{
if (zimbraFileAsId == 8)
{
LPWSTR pwszFileAsValue = m_pPropVals[C_FILEAS].Value.lpszW;
if ((pwszFileAsValue != NULL) && (wcsicmp(pwszFileAsValue, L"") != 0))
{
LPWSTR pwszTemp = new WCHAR[wcslen(m_pPropVals[C_FILEAS].Value.lpszW) + 3];
// there is a legit string for the custom fileas value
wsprintf(pwszTemp, L"8:%s", pwszFileAsValue);
FileAs(pwszTemp);
// PDL's require a nickname
if (m_bPersonalDL)
NickName(m_pPropVals[C_FILEAS].Value.lpszW);
delete[] pwszTemp;
}
else
{
LPWSTR pwszNONAME = new WCHAR[wcslen(L"NO_NAME") + 1];
wsprintf(pwszNONAME, L"%s", L"NO_NAME");
LPWSTR pwszTemp = new WCHAR[wcslen(pwszNONAME) + 3];
// there is a legit string for the custom fileas value
wsprintf(pwszTemp, L"8:%s", pwszNONAME);
FileAs(pwszTemp);
// PDL's require a nickname
if (m_bPersonalDL)
NickName(pwszNONAME);
delete[] pwszTemp;
delete[] pwszNONAME;
}
}
else if (zimbraFileAsId)
{
WCHAR pwszTemp[3];
_ltow(zimbraFileAsId, pwszTemp, 10);
FileAs(pwszTemp);
}
}
if (m_pPropVals[C_GIVEN_NAME].ulPropTag == contactProps.aulPropTag[C_GIVEN_NAME])
FirstName(m_pPropVals[C_GIVEN_NAME].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_CITY].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_CITY])
HomeCity(m_pPropVals[C_HOME_ADDRESS_CITY].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_COUNTRY].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_COUNTRY])
HomeCountry(m_pPropVals[C_HOME_ADDRESS_COUNTRY].Value.lpszW);
if (m_pPropVals[C_HOME_FAX_NUMBER].ulPropTag == contactProps.aulPropTag[C_HOME_FAX_NUMBER])
HomeFax(m_pPropVals[C_HOME_FAX_NUMBER].Value.lpszW);
if (m_pPropVals[C_HOME_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_HOME_TELEPHONE_NUMBER])
HomePhone(m_pPropVals[C_HOME_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_HOME2_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_HOME2_TELEPHONE_NUMBER])
HomePhone2(m_pPropVals[C_HOME2_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_POSTAL_CODE].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_POSTAL_CODE])
HomePostalCode(m_pPropVals[C_HOME_ADDRESS_POSTAL_CODE].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_STATE_OR_PROVINCE].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_STATE_OR_PROVINCE])
HomeState(m_pPropVals[C_HOME_ADDRESS_STATE_OR_PROVINCE].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_STREET].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_STREET])
HomeStreet(m_pPropVals[C_HOME_ADDRESS_STREET].Value.lpszW);
if (m_pPropVals[C_TITLE].ulPropTag == contactProps.aulPropTag[C_TITLE])
JobTitle(m_pPropVals[C_TITLE].Value.lpszW);
if (m_pPropVals[C_SURNAME].ulPropTag == contactProps.aulPropTag[C_SURNAME])
LastName(m_pPropVals[C_SURNAME].Value.lpszW);
if (m_pPropVals[C_MIDDLE_NAME].ulPropTag == contactProps.aulPropTag[C_MIDDLE_NAME])
MiddleName(m_pPropVals[C_MIDDLE_NAME].Value.lpszW);
if (m_pPropVals[C_CELLULAR_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_CELLULAR_TELEPHONE_NUMBER])
MobilePhone(m_pPropVals[C_CELLULAR_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_DISPLAY_NAME_PREFIX].ulPropTag ==
contactProps.aulPropTag[C_DISPLAY_NAME_PREFIX])
NamePrefix(m_pPropVals[C_DISPLAY_NAME_PREFIX].Value.lpszW);
if (m_pPropVals[C_GENERATION].ulPropTag == contactProps.aulPropTag[C_GENERATION])
NameSuffix(m_pPropVals[C_GENERATION].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_CITY].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_CITY])
OtherCity(m_pPropVals[C_OTHER_ADDRESS_CITY].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_COUNTRY].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_COUNTRY])
OtherCountry(m_pPropVals[C_OTHER_ADDRESS_COUNTRY].Value.lpszW);
if (m_pPropVals[C_PRIMARY_FAX_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_PRIMARY_FAX_NUMBER])
OtherFax(m_pPropVals[C_PRIMARY_FAX_NUMBER].Value.lpszW);
if (m_pPropVals[C_OTHER_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_OTHER_TELEPHONE_NUMBER])
OtherPhone(m_pPropVals[C_OTHER_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_POSTAL_CODE].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_POSTAL_CODE])
OtherPostalCode(m_pPropVals[C_OTHER_ADDRESS_POSTAL_CODE].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_STATE_OR_PROVINCE].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_STATE_OR_PROVINCE])
OtherState(m_pPropVals[C_OTHER_ADDRESS_STATE_OR_PROVINCE].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_STREET].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_STREET])
OtherStreet(m_pPropVals[C_OTHER_ADDRESS_STREET].Value.lpszW);
if (m_pPropVals[C_PAGER_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_PAGER_TELEPHONE_NUMBER])
Pager(m_pPropVals[C_PAGER_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_CITY].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_CITY])
WorkCity(m_pPropVals[C_BUSINESS_ADDRESS_CITY].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_COUNTRY].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_COUNTRY])
WorkCountry(m_pPropVals[C_BUSINESS_ADDRESS_COUNTRY].Value.lpszW);
if (m_pPropVals[C_BUSINESS_FAX_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_FAX_NUMBER])
WorkFax(m_pPropVals[C_BUSINESS_FAX_NUMBER].Value.lpszW);
if (m_pPropVals[C_OFFICE_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_OFFICE_TELEPHONE_NUMBER])
WorkPhone(m_pPropVals[C_OFFICE_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_POSTAL_CODE].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_POSTAL_CODE])
WorkPostalCode(m_pPropVals[C_BUSINESS_ADDRESS_POSTAL_CODE].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_STATE].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_STATE])
WorkState(m_pPropVals[C_BUSINESS_ADDRESS_STATE].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_STREET].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_STREET])
WorkStreet(m_pPropVals[C_BUSINESS_ADDRESS_STREET].Value.lpszW);
if (m_pPropVals[C_BUSINESS_HOME_PAGE].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_HOME_PAGE])
WorkURL(m_pPropVals[C_BUSINESS_HOME_PAGE].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER1_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER1_IDX])
UserField1(m_pPropVals[C_CONTACT_USER1_IDX].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER2_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER2_IDX])
UserField2(m_pPropVals[C_CONTACT_USER2_IDX].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER3_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER3_IDX])
UserField3(m_pPropVals[C_CONTACT_USER3_IDX].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER4_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER4_IDX])
UserField4(m_pPropVals[C_CONTACT_USER4_IDX].Value.lpszW);
if (m_pPropVals[C_BIRTHDAY].ulPropTag == contactProps.aulPropTag[C_BIRTHDAY])
{
SYSTEMTIME st = { 0 };
FileTimeToSystemTime(&(m_pPropVals[C_BIRTHDAY].Value.ft), &st);
// We get PR_BIRTHDAY in UTC so let's convert it into local time
TIME_ZONE_INFORMATION tzInfo = { 0 };
GetTimeZoneInformation(&tzInfo);
SystemTimeToTzSpecificLocalTime(&tzInfo, &st, &st);
TCHAR pszBDay[11];
swprintf(pszBDay, 11, _T("%4d-%02d-%02d"), st.wYear, st.wMonth, st.wDay);
Birthday(pszBDay);
}
if (m_pPropVals[C_ANNIVERSARY].ulPropTag == contactProps.aulPropTag[C_ANNIVERSARY])
{
SYSTEMTIME st = { 0 };
FileTimeToSystemTime(&(m_pPropVals[C_ANNIVERSARY].Value.ft), &st);
// We get PR_ANNIVERSARY in UTC so let's convert it into local time
TIME_ZONE_INFORMATION tzInfo = { 0 };
GetTimeZoneInformation(&tzInfo);
SystemTimeToTzSpecificLocalTime(&tzInfo, &st, &st);
TCHAR pszAnniv[11];
swprintf(pszAnniv, 11, _T("%4d-%02d-%02d"), st.wYear, st.wMonth, st.wDay);
Anniversary(pszAnniv);
}
// email 1
RECIP_INFO tempRecip;
if ((m_pPropVals[C_MAIL1TYPE].ulPropTag == contactProps.aulPropTag[C_MAIL1TYPE]) &&
(m_pPropVals[C_MAIL1ADDRESS].ulPropTag == contactProps.aulPropTag[C_MAIL1ADDRESS]))
{
if (wcscmp(m_pPropVals[C_MAIL1TYPE].Value.lpszW, L"SMTP") == 0)
{
Email(m_pPropVals[C_MAIL1ADDRESS].Value.lpszW);
}
else if (wcscmp(m_pPropVals[C_MAIL1TYPE].Value.lpszW, L"EX") == 0)
{
tempRecip.pAddrType = m_pPropVals[C_MAIL1TYPE].Value.lpszW;
tempRecip.pEmailAddr = m_pPropVals[C_MAIL1ADDRESS].Value.lpszW;
tempRecip.cbEid = m_pPropVals[C_MAIL1EID].Value.bin.cb;
tempRecip.pEid = (LPENTRYID)(m_pPropVals[C_MAIL1EID].Value.bin.lpb);
wstring strSenderEmail(_TEXT(""));
HRESULT hr = Zimbra::MAPI::Util::HrMAPIGetSMTPAddress(*m_session, tempRecip,
strSenderEmail);
if (hr != S_OK)
Email(m_pPropVals[C_MAIL1DISPNAME].Value.lpszW);
else
Email((LPTSTR)strSenderEmail.c_str());
}
}
// email 2
if ((m_pPropVals[C_MAIL2TYPE].ulPropTag == contactProps.aulPropTag[C_MAIL2TYPE]) &&
(m_pPropVals[C_MAIL2ADDRESS].ulPropTag == contactProps.aulPropTag[C_MAIL2ADDRESS]))
{
if (wcscmp(m_pPropVals[C_MAIL2TYPE].Value.lpszW, L"SMTP") == 0)
{
Email2(m_pPropVals[C_MAIL2ADDRESS].Value.lpszW);
}
else if (wcscmp(m_pPropVals[C_MAIL2TYPE].Value.lpszW, L"EX") == 0)
{
tempRecip.pAddrType = m_pPropVals[C_MAIL2TYPE].Value.lpszW;
tempRecip.pEmailAddr = m_pPropVals[C_MAIL2ADDRESS].Value.lpszW;
tempRecip.cbEid = m_pPropVals[C_MAIL2EID].Value.bin.cb;
tempRecip.pEid = (LPENTRYID)(m_pPropVals[C_MAIL2EID].Value.bin.lpb);
wstring strSenderEmail(_TEXT(""));
HRESULT hr = Zimbra::MAPI::Util::HrMAPIGetSMTPAddress(*m_session, tempRecip,
strSenderEmail);
if (hr != S_OK)
Email(m_pPropVals[C_MAIL2DISPNAME].Value.lpszW);
else
Email2((LPTSTR)strSenderEmail.c_str());
}
}
// email 3
if ((m_pPropVals[C_MAIL3TYPE].ulPropTag == contactProps.aulPropTag[C_MAIL3TYPE]) &&
(m_pPropVals[C_MAIL3ADDRESS].ulPropTag == contactProps.aulPropTag[C_MAIL3ADDRESS]))
{
if (wcscmp(m_pPropVals[C_MAIL3TYPE].Value.lpszW, L"SMTP") == 0)
{
Email3(m_pPropVals[C_MAIL3ADDRESS].Value.lpszW);
}
else if (wcscmp(m_pPropVals[C_MAIL3TYPE].Value.lpszW, L"EX") == 0)
{
tempRecip.pAddrType = m_pPropVals[C_MAIL3TYPE].Value.lpszW;
tempRecip.pEmailAddr = m_pPropVals[C_MAIL3ADDRESS].Value.lpszW;
tempRecip.cbEid = m_pPropVals[C_MAIL3EID].Value.bin.cb;
tempRecip.pEid = (LPENTRYID)(m_pPropVals[C_MAIL3EID].Value.bin.lpb);
wstring strSenderEmail(_TEXT(""));
HRESULT hr = Zimbra::MAPI::Util::HrMAPIGetSMTPAddress(*m_session, tempRecip,
strSenderEmail);
if (hr != S_OK)
Email(m_pPropVals[C_MAIL3DISPNAME].Value.lpszW);
else
Email3((LPTSTR)strSenderEmail.c_str());
}
}
if (m_pPropVals[C_IMADDRESS].ulPropTag == contactProps.aulPropTag[C_IMADDRESS])
IMAddress1(m_pPropVals[C_IMADDRESS].Value.lpszW);
// add the 'notes' section
if (m_mapiMessage->HasTextPart())
{
LPTSTR pBody = NULL;
UINT nText = 0;
m_mapiMessage->TextBody(&pBody, nText);
LPTSTR psz = pBody;
if (psz)
{
const char SPACE = ' ', TAB = '\t', CR = 0x0d, LF = 0x0a;
while (*psz)
{
// Replace control characters with space
// Exclude carriage return and new line characters while doing the same
if ((*psz < SPACE) && (*psz != CR) && (*psz != LF))
*psz = _T(' ');
psz++;
}
// We'll add the body only if it has data other than white spaces and new lines
bool bHasValidChars = false;
psz = pBody;
while (*psz)
{
if ((*psz == SPACE) || (*psz == TAB) || (*psz == CR) || (*psz == LF))
{
psz++;
continue;
}
else
{
bHasValidChars = true;
break;
}
}
if (bHasValidChars)
Notes(pBody);
MAPIFreeBuffer(pBody);
}
}
// if its a distribution list, add the dist list members to the property
wstring strInvalidGroupContacts;
if (m_bPersonalDL)
{
std::wstring dlist = L"";
if (m_pPropVals[C_ONEOFFMEMEBRS_IDX].ulPropTag ==
contactProps.aulPropTag[C_ONEOFFMEMEBRS_IDX])
{
bool bFirst = true;
for (ULONG i = 0; i < m_pPropVals[C_ONEOFFMEMEBRS_IDX].Value.MVbin.cValues; i++)
{
DWORD dwObjType;
SBinary &bin = m_pPropVals[C_ONEOFFMEMEBRS_IDX].Value.MVbin.lpbin[i];
IMailUser *pUser = NULL;
hr = m_session->OpenEntry(bin.cb, (LPENTRYID)bin.lpb, NULL, 0, &dwObjType,
(LPUNKNOWN *)&pUser);
if (FAILED(hr) || !pUser)
continue;
LPSPropValue pDNProp = NULL;
LPSPropValue pAddrProp = NULL;
std::wstring user = L"";
BOOL bIsInvalidContact = TRUE;
HrGetOneProp(pUser, PR_DISPLAY_NAME_W, &pDNProp);
HrGetOneProp(pUser, PR_EMAIL_ADDRESS_W, &pAddrProp);
if (pDNProp && (pDNProp->ulPropTag == PR_DISPLAY_NAME_W) && wcslen(
pDNProp->Value.lpszW))
user += pDNProp->Value.lpszW;
if (pAddrProp && (pAddrProp->ulPropTag == PR_EMAIL_ADDRESS_W) && wcslen(
pAddrProp->Value.lpszW))
{
std::wstring temp = pAddrProp->Value.lpszW;
if (temp.find(L'@') != std::wstring::npos)
bIsInvalidContact = FALSE;
if (!user.empty())
user += L" ";
user += L"<";
user += temp;
user += L">";
}
if (bIsInvalidContact)
{
if (!user.empty())
{
if (!strInvalidGroupContacts.empty())
strInvalidGroupContacts += _T(", ");
strInvalidGroupContacts += user.c_str();
}
}
else
{
if (bFirst)
bFirst = false;
else
dlist += L",";
dlist += user;
}
pUser->Release();
MAPIFreeBuffer(pDNProp);
MAPIFreeBuffer(pAddrProp);
}
}
//set DL values
DList((LPTSTR)dlist.c_str());
}
//user define props
if (!m_bPersonalDL)
{
LPMAPINAMEID FAR *lppPropNames = NULL;
LPSPropTagArray tagArray;
ULONG lCount = 0;
hr = m_pMessage->GetPropList(MAPI_UNICODE, &tagArray);
if (hr == S_OK)
{
hr = m_pMessage->GetNamesFromIDs(&tagArray, (LPGUID)&PS_PUBLIC_STRINGS, 0, &lCount,
&lppPropNames);
if (SUCCEEDED(hr))
{
WCHAR wszProps2GUID[40] = { 0 };
Zimbra::Util::Guid nameProps2Guid(OUTLOOK_NAME_PROPS_GUID_2);
nameProps2Guid.toString(wszProps2GUID);
WCHAR wszContactPropGUID[40] = { 0 };
WCHAR wszVal[1024]={0};
for (ULONG i = 0; i < lCount; i++)
{
Zimbra::Util::ScopedBuffer<SPropValue> pPropVal;
hr = HrGetOneProp(m_pMessage, tagArray->aulPropTag[i], pPropVal.getptr());
if (lppPropNames[i] != NULL) // FBS bug 71786 -- 3/20/12
{
if (lppPropNames[i]->ulKind == MNID_STRING)
{
Zimbra::Util::Guid propGuid(*lppPropNames[i]->lpguid);
propGuid.toString(wszContactPropGUID);
if (lstrcmpiW(wszContactPropGUID, wszProps2GUID) == 0)
{
LPWSTR szPropName = lppPropNames[i]->Kind.lpwstrName;
// now format a string depending on the type
ULONG ulPropType = PROP_TYPE(pPropVal->ulPropTag);
BOOL bSetAttribute = TRUE;
switch (ulPropType)
{
case PT_UNICODE:
wcscpy(wszVal, pPropVal->Value.lpszW);
break;
case PT_SYSTIME:
{
SYSTEMTIME sysTime = { 0 };
if (FileTimeToSystemTime(&(pPropVal->Value.ft), &sysTime))
{
TIME_ZONE_INFORMATION tzInfo = { 0 };
GetTimeZoneInformation(&tzInfo);
SystemTimeToTzSpecificLocalTime(&tzInfo, &sysTime, &sysTime);
wsprintf(wszVal, L"%4d-%02d-%02d", sysTime.wYear,
sysTime.wMonth, sysTime.wDay);
}
break;
}
case PT_LONG:
wsprintf(wszVal, L"%d", pPropVal->Value.l);
break;
case PT_DOUBLE:
{
CHAR tmp[36];
_gcvt(pPropVal->Value.dbl, 6, tmp);
LPWSTR wszTmp = Zimbra::Util::AnsiiToUnicode(tmp);
wcscpy(wszVal, wszTmp);
break;
}
case PT_BOOLEAN:
if (pPropVal->Value.b)
wcscpy(wszVal, L"TRUE");
else
wcscpy(wszVal, L"FALSE");
break;
case PT_CURRENCY:
{
LONGLONG lCurrency;
CURRENCY currency;
currency = pPropVal->Value.cur;
lCurrency = currency.int64;
lCurrency = lCurrency / 10000;
wsprintf(wszVal, L"$%I64d", lCurrency);
break;
}
default: // can't deal with these other types
bSetAttribute = FALSE;
//LOG("%hs: MAPI type %0x not supported: user defined field %s will not be synced"),
// __FUNCTION__, ulPropType, szPropName);
}
ContactUDFields cudf;
cudf.Name = szPropName;
cudf.value = wszVal;
AddUserDefinedField(cudf);
}
}
}
}
MAPIFreeBuffer(lppPropNames);
}
MAPIFreeBuffer(tagArray);
}
}
// Save image path
wstring wstrImagePath;
if (m_mapiMessage->HasAttach())
{
if (!FAILED(hr = GetContactImage(wstrImagePath)))
ContactImagePath((LPTSTR)wstrImagePath.c_str());
}
return S_OK;
}
bool MAPIStorageAdviser::AdviseAll()
{
IMAPISession* pSession = InitIMAPISession();
IMAPITable* pStoresTable = GetStoresTable(pSession);
SizedSPropTagArray(2, tblColumns) = {2, {PR_DISPLAY_NAME, PR_ENTRYID}};
pStoresTable->SetColumns((LPSPropTagArray)&tblColumns, 0);
for(;;) {
SRowSet * pRowSet = NULL;
pStoresTable->QueryRows(1, 0, &pRowSet);
if(pRowSet->cRows != 1)
break;
ASSERT(pRowSet->aRow[0].cValues == tblColumns.cValues);
SPropValue* pVal = pRowSet->aRow[0].lpProps;
ASSERT(pVal[0].ulPropTag == PR_DISPLAY_NAME);
ASSERT(pVal[1].ulPropTag == PR_ENTRYID);
LPWSTR lpStoreName = pRowSet->aRow[0].lpProps[0].Value.lpszW;
// Open Store
LPBYTE pEntry = (LPBYTE)pRowSet->aRow[0].lpProps[1].Value.bin.lpb;
ULONG ulStoreBytes = pRowSet->aRow[0].lpProps[1].Value.bin.cb;
IMsgStore* pStore = _GetStoreFromEntryID(pSession, ulStoreBytes, pEntry);
if (pStore == NULL)
{
continue;
}
if (AddSink(pStore) == true) {
}else{
}
pStore->Release();
FreeProws(pRowSet);
}
pStoresTable->Release();
pSession->Release();
return true;
}
