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
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;
}
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 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;
}
/// <summary>
/// <para name='Name'>OpenDefaultMessageStore</para>
/// <para name='Purpose'>Find and open the default message store</para>
/// </summary>
/// <param name='lppDefaultMDB'>[out] Pointer to the opened default message store</param>
/// <returns>HRESULT</returns>
/// <remarks>
/// <para name='Notes'>Adapted from MFCMapi's MAPIStoreFunctions.cpp\OpenDefaultMessageStore()</para>
/// <para name='Author'></para>
/// <para name='LastModified'>29Jan2016</para>
/// </remarks>
STDMETHODIMP ZybraxiSoft::CMailbox::OpenDefaultMessageStore(LPMDB * lppDefaultMDB)
{
HRESULT hr = S_OK;
LPMAPITABLE pStoresTable = NULL;
SPropValue sPropVal;
static SRestriction sRes;
LPSRowSet pSRowSet = NULL;
// Set up an enum to mask the numbers into pretty text
enum
{
EID,
NUM_COLS
};
// Set up a constant SPropTagArray
/*static const SizedSPropTagArray(NUM_COLS, sptEIDCol) =
{
NUM_COLS,
PR_ENTRYID,
};*/
static const struct _SPropTagArray_sptEIDCol
{
ULONG NUM_COLS;
ULONG aulPropTag[1];
} sptEIDCol =
{
NUM_COLS,
PR_ENTRYID
};
// Get our message stores table
// See https://msdn.microsoft.com/en-us/library/cc839751(v=office.15).aspx
if (FAILED(hr = m_lpSession->GetMsgStoresTable(
0, // ulFlags (not sure why we don't use MAPI_UNICODE)
&pStoresTable))) // [out] lppTable
{
ERROR_MSG_W_HR("Unable to get message stores table", hr);
goto CLEANUP;
}
// Set up our property value to restrict against
sPropVal.ulPropTag = PR_DEFAULT_STORE; // The proptag to check
sPropVal.Value.b = true; // what to check against
// Set up to restrict so QueryRows gets only the default store
sRes.rt = RES_PROPERTY; // Compare if property
sRes.res.resProperty.ulPropTag = PR_DEFAULT_STORE; // PR_DEFAULT_STORE
sRes.res.resProperty.relop = RELOP_EQ; // is equal to
sRes.res.resProperty.lpProp = &sPropVal; // this property value
// Run the query
// See https://msdn.microsoft.com/en-us/library/office/cc815764.aspx
if (FAILED(hr = HrQueryAllRows(
pStoresTable,
(LPSPropTagArray)&sptEIDCol,
&sRes,
NULL,
0,
&pSRowSet)))
{
ERROR_MSG_W_HR("HrQueryAllRows failed", hr);
goto CLEANUP;
}
// Always check to see if we actually returned some rows
if (pSRowSet && pSRowSet->cRows)
{
// Check to make sure we only returned one default
// We'll use the first one regardless, but let's sound
// a warning anyway.
if (pSRowSet->cRows > 1)
{
WARN("We returned more than on Default store!");
}
// Open the message store
if (FAILED(hr = DoOpenMsgStore(
&pSRowSet->aRow[0].lpProps[EID].Value.bin,
MDB_WRITE,
lppDefaultMDB)))
{
ERROR_MSG_W_HR("DoOpenMsgStore failed.", hr);
goto CLEANUP;
}
}
else
hr = MAPI_E_NOT_FOUND;
CLEANUP:
if (pSRowSet)
{
FreeProws(pSRowSet);
pSRowSet = NULL;
}
if (pStoresTable)
{
pStoresTable->Release();
pStoresTable = NULL;
}
return hr;
}
// Search folder for entry ID of child folder by name.
HRESULT HrMAPIFindFolderW(
_In_ LPMAPIFOLDER lpFolder, // pointer to folder
_In_z_ LPCWSTR lpszName, // name of child folder to find
_Out_opt_ ULONG* lpcbeid, // pointer to count of bytes in entry ID
_Deref_out_opt_ LPENTRYID* lppeid) // pointer to entry ID pointer
{
DebugPrint(DBGGeneric,"HrMAPIFindFolderW: Locating folder \"%ws\"\n", lpszName);
HRESULT hRes = S_OK;
LPMAPITABLE lpTable = NULL;
LPSRowSet lpRow = NULL;
LPSPropValue lpRowProp = NULL;
ULONG i = 0;
enum
{
ePR_DISPLAY_NAME_W,
ePR_ENTRYID,
NUM_COLS
};
static const SizedSPropTagArray(NUM_COLS, rgColProps) =
{
NUM_COLS,
PR_DISPLAY_NAME_W,
PR_ENTRYID
};
if (!lpcbeid || !lppeid) return MAPI_E_INVALID_PARAMETER;
*lpcbeid = 0;
*lppeid = NULL;
if (!lpFolder) return MAPI_E_INVALID_PARAMETER;
WC_MAPI(lpFolder->GetHierarchyTable(MAPI_UNICODE | MAPI_DEFERRED_ERRORS, &lpTable));
if (SUCCEEDED(hRes) && lpTable)
{
WC_MAPI(HrQueryAllRows(lpTable, (LPSPropTagArray)&rgColProps, NULL, NULL, 0, &lpRow));
}
if (SUCCEEDED(hRes) && lpRow)
{
for (i = 0; i < lpRow->cRows; i++)
{
lpRowProp = lpRow->aRow[i].lpProps;
if (PR_DISPLAY_NAME_W == lpRowProp[ePR_DISPLAY_NAME_W].ulPropTag &&
_wcsicmp(lpRowProp[ePR_DISPLAY_NAME_W].Value.lpszW, lpszName) == 0 &&
PR_ENTRYID == lpRowProp[ePR_ENTRYID].ulPropTag)
{
WC_H(MAPIAllocateBuffer(lpRowProp[ePR_ENTRYID].Value.bin.cb, (LPVOID*)lppeid));
if (SUCCEEDED(hRes) && lppeid)
{
*lpcbeid = lpRowProp[ePR_ENTRYID].Value.bin.cb;
CopyMemory(*lppeid, lpRowProp[ePR_ENTRYID].Value.bin.lpb, *lpcbeid);
}
break;
}
}
}
if (!*lpcbeid)
{
hRes = MAPI_E_NOT_FOUND;
}
FreeProws(lpRow);
if (lpTable) lpTable->Release();
return hRes;
} // HrMAPIFindFolderW
//$--HrFindExchangeGlobalAddressList-------------------------------------------------
// Returns the entry ID of the global address list container in the address
// book.
// -----------------------------------------------------------------------------
HRESULT HrFindExchangeGlobalAddressList( // RETURNS: return code
IN LPADRBOOK lpAdrBook, // address book pointer
OUT ULONG *lpcbeid, // pointer to count of bytes in entry ID
OUT LPENTRYID *lppeid) // pointer to entry ID pointer
{
HRESULT hr = NOERROR;
ULONG ulObjType = 0;
ULONG i = 0;
LPMAPIPROP lpRootContainer = NULL;
LPMAPIPROP lpContainer = NULL;
LPMAPITABLE lpContainerTable = NULL;
LPSRowSet lpRows = NULL;
ULONG cbContainerEntryId = 0;
LPENTRYID lpContainerEntryId = NULL;
LPSPropValue lpCurrProp = NULL;
SRestriction SRestrictAnd[2] = {0};
SRestriction SRestrictGAL = {0};
SPropValue SPropID = {0};
SPropValue SPropProvider = {0};
BYTE muid[] = MUIDEMSAB;
SizedSPropTagArray(1, rgPropTags) =
{
1,
{
PR_ENTRYID,
}
};
DEBUGPUBLIC("HrFindExchangeGlobalAddressList()");
hr = CHK_HrFindExchangeGlobalAddressList(
lpAdrBook,
lpcbeid,
lppeid);
if(FAILED(hr))
RETURN(hr);
*lpcbeid = 0;
*lppeid = NULL;
// Open the root container of the address book
hr = MAPICALL(lpAdrBook)->OpenEntry(
/*lpAdrBook,*/
0,
NULL,
NULL,
MAPI_DEFERRED_ERRORS,
&ulObjType,
(LPUNKNOWN FAR *)&lpRootContainer);
if(FAILED(hr))
{
goto cleanup;
}
if(ulObjType != MAPI_ABCONT)
{
hr = HR_LOG(E_FAIL);
goto cleanup;
}
// Get the hierarchy table of the root container
hr = MAPICALL(((LPABCONT)lpRootContainer))->GetHierarchyTable(
/*(LPABCONT)lpRootContainer,*/
MAPI_DEFERRED_ERRORS|CONVENIENT_DEPTH,
&lpContainerTable);
if(FAILED(hr))
{
goto cleanup;
}
// Restrict the table to the global address list (GAL)
// ---------------------------------------------------
// Initialize provider restriction to only Exchange providers
SRestrictAnd[0].rt = RES_PROPERTY;
SRestrictAnd[0].res.resProperty.relop = RELOP_EQ;
SRestrictAnd[0].res.resProperty.ulPropTag = PR_AB_PROVIDER_ID;
SPropProvider.ulPropTag = PR_AB_PROVIDER_ID;
SPropProvider.Value.bin.cb = 16;
SPropProvider.Value.bin.lpb = (LPBYTE)muid;
SRestrictAnd[0].res.resProperty.lpProp = &SPropProvider;
// Initialize container ID restriction to only GAL container
SRestrictAnd[1].rt = RES_PROPERTY;
SRestrictAnd[1].res.resProperty.relop = RELOP_EQ;
SRestrictAnd[1].res.resProperty.ulPropTag = PR_EMS_AB_CONTAINERID;
SPropID.ulPropTag = PR_EMS_AB_CONTAINERID;
SPropID.Value.l = 0;
SRestrictAnd[1].res.resProperty.lpProp = &SPropID;
// Initialize AND restriction
SRestrictGAL.rt = RES_AND;
SRestrictGAL.res.resAnd.cRes = 2;
SRestrictGAL.res.resAnd.lpRes = &SRestrictAnd[0];
// Restrict the table to the GAL - only a single row should remain
// Get the row corresponding to the GAL
//
// Query all the rows
//
hr = HrQueryAllRows(
lpContainerTable,
(LPSPropTagArray)&rgPropTags,
&SRestrictGAL,
NULL,
0,
&lpRows);
if(FAILED(hr) || (lpRows == NULL) || (lpRows->cRows != 1))
{
hr = HR_LOG(E_FAIL);
goto cleanup;
}
// Get the entry ID for the GAL
lpCurrProp = &(lpRows->aRow[0].lpProps[0]);
if(lpCurrProp->ulPropTag == PR_ENTRYID)
{
cbContainerEntryId = lpCurrProp->Value.bin.cb;
lpContainerEntryId = (LPENTRYID)lpCurrProp->Value.bin.lpb;
}
else
{
hr = HR_LOG(EDK_E_NOT_FOUND);
goto cleanup;
}
hr = MAPIAllocateBuffer(cbContainerEntryId, (LPVOID *)lppeid);
if(FAILED(hr))
{
*lpcbeid = 0;
*lppeid = NULL;
}
else
{
CopyMemory(
*lppeid,
lpContainerEntryId,
cbContainerEntryId);
*lpcbeid = cbContainerEntryId;
}
cleanup:
ULRELEASE(lpRootContainer);
ULRELEASE(lpContainerTable);
ULRELEASE(lpContainer);
FREEPROWS(lpRows);
if(FAILED(hr))
{
MAPIFREEBUFFER(*lppeid);
*lpcbeid = 0;
*lppeid = NULL;
}
RETURN(hr);
}
HRESULT ConfigMsgService(){
HRESULT hr = 0;
LPPROFADMIN lpProfAdmin = NULL;
LPSERVICEADMIN lpServiceAdmin = NULL;
LPMAPITABLE lpMapiTable = NULL;
SRestriction sres; // Restriction structure.
SPropValue SvcProps; // Property structure for restriction.
LPSRowSet lpSvcRows = NULL; // Rowset to hold results of table query.
LPSTR szServer = "155.35.79.109";
LPSTR szMailbox = "InputedBox";
SPropValue rgval[2]; // Property structure to hold values we want to set.
enum { iSvcName, iSvcUID, cptaSvc };
SizedSPropTagArray(cptaSvc, sptCols) = { cptaSvc, PR_SERVICE_NAME, PR_SERVICE_UID };
do{
// if not profile, create profile.
// else use exist profile
DEFINE_IF_HR_NT_OK_BREAK(MAPIAdminProfiles(0, &lpProfAdmin));
LPTSTR strProfileName = L"lhytest";
LPTSTR strProfilePsw = L"123.com";
hr = lpProfAdmin->CreateProfile(strProfileName, NULL, NULL, 0);
if (hr == MAPI_E_NO_ACCESS){
// profile exist;
break;
}
else if (hr == S_OK){
DEFINE_IF_HR_NT_OK_BREAK(lpProfAdmin->AdminServices(strProfileName, NULL, NULL, 0, &lpServiceAdmin));
DEFINE_IF_HR_NT_OK_BREAK(lpServiceAdmin->CreateMsgService((LPTSTR)"MSEMS", NULL, 0, 0));
// todo config MsgService.
hr = lpServiceAdmin->GetMsgServiceTable(0, &lpMapiTable);
DEFINE_IF_HR_NT_OK_BREAK(hr);
sres.rt = RES_CONTENT;
sres.res.resContent.ulFuzzyLevel = FL_FULLSTRING;
sres.res.resContent.ulPropTag = PR_SERVICE_NAME;
sres.res.resContent.lpProp = &SvcProps;
SvcProps.ulPropTag = PR_SERVICE_NAME;
SvcProps.Value.lpszA = "MSEMS";
// Query the table to obtain the entry for the newly created message service.
if (FAILED(hr = HrQueryAllRows(lpMapiTable,
(LPSPropTagArray)&sptCols,
&sres,
NULL,
0,
&lpSvcRows)))
{
break;
}
// Set up a SPropValue array for the properties that you have to configure.
// First, the server name.
ZeroMemory(&rgval[1], sizeof(SPropValue));
rgval[1].ulPropTag = PR_PROFILE_UNRESOLVED_SERVER;
rgval[1].Value.lpszA = szServer;
// Next, the mailbox name.
ZeroMemory(&rgval[0], sizeof(SPropValue));
rgval[0].ulPropTag = PR_PROFILE_UNRESOLVED_NAME;
rgval[0].Value.lpszA = szMailbox;
// Configure the message service by using the previous properties.
if (FAILED(hr = lpServiceAdmin->ConfigureMsgService(
(LPMAPIUID)lpSvcRows->aRow->lpProps[iSvcUID].Value.bin.lpb, // Entry ID of service to configure.
NULL, // Handle to parent window.
0, // Flags.
2, // Number of properties we are setting.
rgval))) // Pointer to SPropValue array.
{
break;
}
}
else {
break;
}
} while (0);
if (lpSvcRows != NULL){
FreeProws(lpSvcRows);
lpSvcRows = NULL;
}
if (lpMapiTable != NULL){
lpMapiTable->Release();
lpMapiTable = NULL;
}
if (lpServiceAdmin != NULL){
lpServiceAdmin->Release();
lpServiceAdmin = NULL;
}
if (lpProfAdmin != NULL){
lpProfAdmin->Release();
lpProfAdmin = NULL;
}
return hr;
}
