LPSPropValue CMapiApi::GetMapiProperty( LPMAPIPROP pProp, ULONG tag)
{
if (!pProp)
return( NULL);
int sz = CbNewSPropTagArray( 1);
SPropTagArray *pTag = (SPropTagArray *) new char[sz];
pTag->cValues = 1;
pTag->aulPropTag[0] = tag;
LPSPropValue lpProp = NULL;
ULONG cValues = 0;
HRESULT hr = pProp->GetProps( pTag, 0, &cValues, &lpProp);
delete [] pTag;
if (HR_FAILED( hr) || (cValues != 1)) {
if (lpProp)
MAPIFreeBuffer( lpProp);
return( NULL);
}
else {
if (PROP_TYPE( lpProp->ulPropTag) == PT_ERROR) {
if (lpProp->Value.l == MAPI_E_NOT_FOUND) {
MAPIFreeBuffer( lpProp);
lpProp = NULL;
}
}
}
return( lpProp);
}
LPSPropValue Workshare::Mail::Mapi::GetMessageTag(LPMESSAGE lpMessage, const std::tstring& sTag)
{
LPSPropValue pPropVal = 0;
IMAPIPropPtr spMapiProp;
HRESULT hr = lpMessage->QueryInterface(IID_IMAPIProp, (void**) &spMapiProp);
if(SUCCEEDED(hr))
{
LPMAPINAMEID pTagName = 0;
hr = MAPIAllocateBuffer(sizeof(MAPINAMEID), (LPVOID*)&pTagName);
if(SUCCEEDED(hr))
{
pTagName[0].lpguid = (LPGUID)&PS_PUBLIC_STRINGS;
pTagName[0].ulKind = MNID_STRING;
_bstr_t bsTag(sTag.c_str());
pTagName[0].Kind.lpwstrName = bsTag;
LPSPropTagArray pPropTag = 0;
hr = spMapiProp->GetIDsFromNames(1, &pTagName, 0, &pPropTag);
if (!FAILED(hr))
{
if(1 == pPropTag->cValues && PT_ERROR != PROP_TYPE(pPropTag->aulPropTag[0]))
{
ULONG ulCount = 0;
spMapiProp->GetProps(pPropTag, 0, &ulCount, &pPropVal);
}
MAPIFreeBuffer(pPropTag);
}
MAPIFreeBuffer(pTagName);
}
}
return pPropVal;
}
void CMapiApi::ListProperties( LPMAPIPROP lpProp, BOOL getValues)
{
LPSPropTagArray pArray;
HRESULT hr = lpProp->GetPropList( 0, &pArray);
if (FAILED(hr)) {
MAPI_TRACE0( " Unable to retrieve property list\n");
return;
}
ULONG count = 0;
LPMAPINAMEID FAR * lppPropNames;
SPropTagArray tagArray;
LPSPropTagArray lpTagArray = &tagArray;
tagArray.cValues = (ULONG)1;
nsCString desc;
for (ULONG i = 0; i < pArray->cValues; i++) {
GetPropTagName( pArray->aulPropTag[i], desc);
if (getValues) {
tagArray.aulPropTag[0] = pArray->aulPropTag[i];
hr = lpProp->GetNamesFromIDs(&lpTagArray, nsnull, 0, &count, &lppPropNames);
if (hr == S_OK)
MAPIFreeBuffer(lppPropNames);
LPSPropValue pVal = GetMapiProperty( lpProp, pArray->aulPropTag[i]);
if (pVal) {
desc += ", ";
ListPropertyValue( pVal, desc);
MAPIFreeBuffer( pVal);
}
}
MAPI_TRACE2( " Tag #%d: %s\n", (int)i, (const char *)desc);
}
MAPIFreeBuffer( pArray);
}
// uses the built in outlook email fields, OUTLOOK_EMAIL1 etc, minus 1 for ADDR_TYPE and +1 for EmailOriginalDisplayName
BOOL CMAPIContact::GetEmail(CString& strEmail,int nIndex)
{
strEmail = "";
ULONG nID=GetOutlookEmailID(nIndex);
if(!nID) return FALSE;
LPSPropValue pProp;
CMAPINamedProperty prop(m_pUser);
if(prop.GetOutlookProperty(OUTLOOK_DATA1,nID-1,pProp)) {
CString strAddrType=CMAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
if(prop.GetOutlookProperty(OUTLOOK_DATA1,nID,pProp)) {
strEmail=CMAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
if(strAddrType==_T("EX")) {
// for EX types we use the original display name (seems to contain the appropriate data)
if(prop.GetOutlookProperty(OUTLOOK_DATA1,nID+1,pProp)) {
strEmail=CMAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
}
}
return TRUE;
}
}
return FALSE;
}
/**
\details Test the NspiGetNamesFromIDs RPC operation (0x11)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_GetNamesFromIDs(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct SPropTagArray *ppReturnedPropTags;
struct PropertyNameSet_r *ppNames;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_GetNamesFromIDs");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
ppReturnedPropTags = talloc_zero(mem_ctx, struct SPropTagArray);
ppNames = talloc_zero(mem_ctx, struct PropertyNameSet_r);
retval = nspi_GetNamesFromIDs(nspi_ctx, mem_ctx, NULL, NULL, &ppReturnedPropTags, &ppNames);
mapitest_print_retval_clean(mt, "NspiGetNamesFromIDs", retval);
MAPIFreeBuffer(ppReturnedPropTags);
MAPIFreeBuffer(ppNames);
talloc_free(mem_ctx);
if (retval == MAPI_E_SUCCESS) {
return true;
} else {
return false;
}
}
// uses the built in outlook email fields, OUTLOOK_EMAIL1 etc, minus 1 for ADDRt_YPE and +1 for EmailOriginalDisplayName
String MAPIContact::GetEmail(int nIndex) {
String strEmail;
ULONG nID = GetOutlookEmailID(nIndex);
if(!nID)
return String();
#ifdef _WIN32_WCE
return GetPropertyString(nID, strEmail);
#else
LPSPropValue pProp;
if(GetOutlookProperty(OUTLOOK_DATA1, nID-1, pProp)) {
String strAddrType = MAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
if(GetOutlookProperty(OUTLOOK_DATA1, nID, pProp)) {
strEmail = MAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
if(strAddrType == "EX") {
// for EX types we use the original display name (seems to contain the appropriate data)
if(GetOutlookProperty(OUTLOOK_DATA1, nID+1, pProp)) {
strEmail = MAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
}
}
return strEmail;
}
}
return String();
#endif
}
// @object PySPropValueArray|A sequence of <o PySPropValue>, as passed to many MAPI functions.
BOOL PyMAPIObject_AsSPropValueArray(PyObject *obs, SPropValue **ppv, ULONG *pcValues)
{
int seqLen = PySequence_Length(obs);
SPropValue *pPV;
HRESULT hr;
if (S_OK != (hr=MAPIAllocateBuffer(sizeof(SPropValue) * seqLen, (void **)&pPV))) {
OleSetOleError(hr);
return FALSE;
}
for (ULONG i=0; i<(ULONG)seqLen; i++) {
PyObject *myob = PySequence_GetItem(obs, i);
if (myob==NULL) {
MAPIFreeBuffer(pPV);
return FALSE;
}
BOOL rc = PyMAPIObject_AsSPropValue(myob, pPV+i, pPV);
Py_DECREF(myob);
if (!rc) {
MAPIFreeBuffer(pPV);
return FALSE;
}
}
*pcValues = seqLen;
*ppv = pPV;
return TRUE;
}
/**
\details Test the NspiQueryColumns RPC operation (0x10)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_QueryColumns(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct SPropTagArray *SPropTagArray = NULL;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_QueryColumns");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
SPropTagArray = talloc_zero(mem_ctx, struct SPropTagArray);
retval = nspi_QueryColumns(nspi_ctx, mem_ctx, true, &SPropTagArray);
if (retval != MAPI_E_SUCCESS) {
mapitest_print_retval_clean(mt, "NspiQueryColumns", retval);
MAPIFreeBuffer(SPropTagArray);
talloc_free(mem_ctx);
return false;
}
if (SPropTagArray) {
mapitest_print(mt, "* %d columns returned\n", SPropTagArray->cValues);
mapitest_print_retval_clean(mt, "NspiQueryColumns", retval);
MAPIFreeBuffer(SPropTagArray);
}
talloc_free(mem_ctx);
return true;
}
/**
\details Test the NspiGetSpecialTable RPC operation (0x0c)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_GetSpecialTable(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct PropertyRowSet_r *RowSet;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_GetSpecialTable");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_GetSpecialTable(nspi_ctx, mem_ctx, 0x0, &RowSet);
MAPIFreeBuffer(RowSet);
mapitest_print_retval_clean(mt, "NspiGetSpecialTable (Hierarchy Table)", retval);
if (retval != MAPI_E_SUCCESS) {
talloc_free(mem_ctx);
return false;
}
RowSet = talloc_zero(mt->mem_ctx, struct PropertyRowSet_r);
retval = nspi_GetSpecialTable(nspi_ctx, mem_ctx, 0x2, &RowSet);
MAPIFreeBuffer(RowSet);
mapitest_print_retval_clean(mt, "NspiGetSpecialTable (Address Creation Template)", retval);
talloc_free(mem_ctx);
if (retval == MAPI_E_SUCCESS) {
return true;
} else {
return false;
}
}
/**
\details Test the NspiDNToMId RPC operation (0x7)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_DNToMId(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct StringsArray_r pNames;
struct PropertyTagArray_r *MId;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_DNToMId");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
pNames.Count = 0x1;
pNames.Strings = (const char **) talloc_array(mem_ctx, char *, 1);
pNames.Strings[0] = mt->mapi_ctx->session->profile->homemdb;
MId = talloc_zero(mem_ctx, struct PropertyTagArray_r);
retval = nspi_DNToMId(nspi_ctx, mem_ctx, &pNames, &MId);
MAPIFreeBuffer((char **)pNames.Strings);
MAPIFreeBuffer(MId);
talloc_free(mem_ctx);
mapitest_print_retval_clean(mt, "NspiDNToMId", retval);
if (retval == MAPI_E_SUCCESS) {
return true;
} else {
return false;
}
}
void PyMAPIObject_FreeSRowSet(SRowSet *pResult)
{
if (pResult) {
for (ULONG i=0; i<pResult->cRows; i++)
MAPIFreeBuffer( pResult->aRow[i].lpProps );
MAPIFreeBuffer(pResult);
}
}
void CMapiApi::FreeProws( LPSRowSet prows)
{
ULONG irow;
if (!prows)
return;
for (irow = 0; irow < prows->cRows; ++irow)
MAPIFreeBuffer( prows->aRow[irow].lpProps);
MAPIFreeBuffer( prows);
}
/**
\details Test the GetGALTable function
\param mt pointer to the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_GetGALTable(struct mapitest *mt)
{
struct SPropTagArray *SPropTagArray;
struct PropertyRowSet_r *RowSet;
enum MAPISTATUS retval;
uint32_t i;
uint32_t count;
uint8_t ulFlags;
uint32_t rowsFetched = 0;
uint32_t totalRowsFetched = 0;
bool ret = true;
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0xc,
PR_INSTANCE_KEY,
PR_ENTRYID,
PR_DISPLAY_NAME_UNICODE,
PR_EMAIL_ADDRESS_UNICODE,
PR_DISPLAY_TYPE,
PR_OBJECT_TYPE,
PR_ADDRTYPE_UNICODE,
PR_OFFICE_TELEPHONE_NUMBER_UNICODE,
PR_OFFICE_LOCATION_UNICODE,
PR_TITLE_UNICODE,
PR_COMPANY_NAME_UNICODE,
PR_ACCOUNT_UNICODE);
count = 0x20;
ulFlags = TABLE_START;
do {
retval = GetGALTable(mt->session, SPropTagArray, &RowSet, count, ulFlags);
mapitest_print_retval_clean(mt, "GetGALTable", retval);
if ((!RowSet) || (!(RowSet->aRow))) {
ret = false;
goto cleanup;
}
rowsFetched = RowSet->cRows;
totalRowsFetched += rowsFetched;
if (rowsFetched) {
for (i = 0; i < rowsFetched; i++) {
mapitest_print_PAB_entry(mt, &RowSet->aRow[i]);
}
}
ulFlags = TABLE_CUR;
MAPIFreeBuffer(RowSet);
} while (rowsFetched == count);
if (totalRowsFetched < 1) {
/* We should always have at least ourselves in the list */
/* So if we got no rows at all, there is a problem */
ret = false;
}
cleanup:
MAPIFreeBuffer(SPropTagArray);
return ret;
}
/* free rows */
void Mapix::freeRows(LPSRowSet nRows)
{
if(nRows)
{
for(ULONG i=0;i<nRows->cRows;i++)
{
MAPIFreeBuffer(nRows->aRow[i].lpProps);
}
MAPIFreeBuffer(nRows);
}
}
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
// utility function to release ADRLIST entries
void CMAPIEx::ReleaseAddressList(LPADRLIST pAddressList)
{
#ifndef _WIN32_WCE
FreePadrlist(pAddressList);
#else
if(pAddressList)
{
for(ULONG i=0;i<pAddressList->cEntries;i++) MAPIFreeBuffer(pAddressList->aEntries[i].rgPropVals);
MAPIFreeBuffer(pAddressList);
}
#endif
}
// @object PySBinaryArray|A sequence of strings containing binary data.
BOOL PyMAPIObject_AsSBinaryArray(PyObject *ob, SBinaryArray *pba)
{
BOOL bSeq = TRUE;
int seqLen;
if (PyString_Check(ob)) {
seqLen = 1;
bSeq = FALSE;
} else if (PySequence_Check(ob)) {
seqLen = PySequence_Length(ob);
} else {
PyErr_SetString(PyExc_TypeError, "SBinaryArray must be a sequence of strings");
return FALSE;
}
DWORD cBytes = (seqLen * sizeof(SBinary));
SBinary *pBin;
HRESULT hr = MAPIAllocateBuffer(cBytes, (void **)&pBin);
pba->lpbin = pBin;
if (FAILED(hr)) {
OleSetOleError(hr);
return FALSE;
}
pba->cValues = seqLen;
if (bSeq) {
for (ULONG i=0; i<(ULONG)seqLen; i++) {
PyObject *obItem = PySequence_GetItem(ob, i);
if (obItem==NULL) {
MAPIFreeBuffer(pba);
return FALSE;
}
if (!PyString_Check(obItem)) {
PyErr_SetString(PyExc_TypeError, "SBinary must be a string");
Py_DECREF(obItem);
MAPIFreeBuffer(pba);
return FALSE;
}
pBin[i].cb = PyString_Size(obItem);
pBin[i].lpb = (LPBYTE )PyString_AsString(obItem);
Py_DECREF(obItem);
}
} else {
if (!PyString_Check(ob)) {
PyErr_SetString(PyExc_TypeError, "SBinary must be a string");
MAPIFreeBuffer(pba);
return FALSE;
}
// Simple string
pBin[0].cb = PyString_Size(ob);
pBin[0].lpb = (LPBYTE)PyString_AsString(ob);
}
return TRUE;
}
/**
\details Test the NspiSeekEntries RPC operation (0x04)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_SeekEntries(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct PropertyValue_r pTarget;
struct SPropTagArray *pPropTags;
struct PropertyRowSet_r *RowSet;
struct emsmdb_context *emsmdb;
bool ret = true;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_SeekEntries");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
emsmdb = (struct emsmdb_context *) mt->session->emsmdb->ctx;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
pTarget.ulPropTag = PR_DISPLAY_NAME;
pTarget.dwAlignPad = 0x0;
pTarget.value.lpszA = emsmdb->info.szDisplayName;
pPropTags = set_SPropTagArray(mem_ctx, 0x1, PR_ACCOUNT);
retval = nspi_SeekEntries(nspi_ctx, mem_ctx, SortTypeDisplayName, &pTarget, pPropTags, NULL, &RowSet);
if (retval != MAPI_E_SUCCESS) {
ret = false;
}
mapitest_print_retval_clean(mt, "NspiSeekEntries", retval);
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(pPropTags);
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
pTarget.ulPropTag = PR_DISPLAY_NAME_UNICODE;
pTarget.dwAlignPad = 0x0;
pTarget.value.lpszA = emsmdb->info.szDisplayName;
pPropTags = set_SPropTagArray(mem_ctx, 0x1, PR_ACCOUNT);
retval = nspi_SeekEntries(nspi_ctx, mem_ctx, SortTypeDisplayName, &pTarget, pPropTags, NULL, &RowSet);
if (retval != MAPI_E_SUCCESS) {
ret = false;
}
mapitest_print_retval_clean(mt, "NspiSeekEntries", retval);
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(pPropTags);
talloc_free(mem_ctx);
return ret;
}
BOOL CMAPIContact::GetPropertyString(CString& strProperty,ULONG ulProperty)
{
LPSPropValue pProp=NULL;
if(GetProperty(ulProperty,pProp)==S_OK) {
strProperty=CMAPIEx::GetValidString(*pProp);
MAPIFreeBuffer(pProp);
return TRUE;
} else {
strProperty=_T("");
if (pProp)
MAPIFreeBuffer(pProp);
return FALSE;
}
}
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;
}
// @object PySPropTagArray|A sequence of integers
BOOL PyMAPIObject_AsSPropTagArray(PyObject *obta, SPropTagArray **ppta)
{
if (obta==Py_None) {
*ppta = NULL;
return TRUE;
}
BOOL bSeq = TRUE;
int seqLen;
if (PySequence_Check(obta)) {
seqLen = PySequence_Length(obta);
} else if (PyInt_Check(obta)) {
seqLen = 1;
bSeq = FALSE;
} else {
PyErr_SetString(PyExc_TypeError, "SPropTagArray must be a sequence of integers");
return FALSE;
}
DWORD cBytes = (seqLen * sizeof(ULONG)) + sizeof(ULONG);
SPropTagArray *pta;
HRESULT hr = MAPIAllocateBuffer(cBytes, (void **)&pta);
if (FAILED(hr)) {
OleSetOleError(hr);
return FALSE;
}
pta->cValues = seqLen;
if (bSeq) {
for (ULONG i=0; i<(ULONG)seqLen; i++) {
PyObject *obItem = PySequence_GetItem(obta, i);
if (obItem==NULL) {
MAPIFreeBuffer(pta);
return FALSE;
}
pta->aulPropTag[i] = PyInt_AsLong(obItem);
if (PyErr_Occurred()) {
Py_DECREF(obItem);
MAPIFreeBuffer(pta);
return FALSE;
}
Py_DECREF(obItem);
}
} else {
// Simple int.
pta->aulPropTag[0] = PyInt_AsLong(obta);
}
*ppta = pta;
return TRUE;
}
/**
\details Test the SetColumns (0x12) operation
This function:
-# Opens the Inbox folder and gets the hierarchy table
-# Calls the SetColumns operation
-# Cleans up
\param mt pointer to the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxctable_SetColumns(struct mapitest *mt)
{
mapi_object_t obj_htable;
struct SPropTagArray *SPropTagArray;
/* Step 1. Logon */
if (! mapitest_common_setup(mt, &obj_htable, NULL)) {
return false;
}
/* Step 2. SetColumns */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0x3,
PR_DISPLAY_NAME,
PR_FID,
PR_FOLDER_CHILD_COUNT);
SetColumns(&obj_htable, SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
mapitest_print_retval(mt, "SetColumns");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 3. Release */
mapi_object_release(&obj_htable);
mapitest_common_cleanup(mt);
return true;
}
// Categories are stored under the multi-value named property CATEGORIES_PROPERTY
String MAPIContact::GetCategories() {
String strCategories;
#ifdef _WIN32_WCE
return GetPropertyString(OUTLOOK_CATEGORIES, strCategories);
#else
LPSPropValue pProp;
if(GetNamedProperty(CATEGORIES_PROPERTY, pProp)) {
strCategories = "";
ULONG i;
String strCategory;
for(i = 0; i < pProp->Value.MVi.cValues; i++) {
strCategory = MAPIEx::GetValidMVString(*pProp, i);
if(strCategory.GetLength()) {
if(strCategories.GetLength())
strCategories += ';';
strCategories += strCategory;
}
}
MAPIFreeBuffer(pProp);
return strCategories;
}
return String();
#endif
}
CMAPIFolder* CMAPIEx::OpenFolder(unsigned long ulFolderID, BOOL bInternal)
{
if(!m_pMsgStore) return NULL;
LPSPropValue props=NULL;
ULONG cValues=0;
DWORD dwObjType;
ULONG rgTags[]={ 1, ulFolderID };
LPMAPIFOLDER pFolder;
if(m_pMsgStore->GetProps((LPSPropTagArray) rgTags, cm_nMAPICode, &cValues, &props)!=S_OK) return NULL;
if(m_pMsgStore->OpenEntry(props[0].Value.bin.cb, (LPENTRYID)props[0].Value.bin.lpb, NULL, m_ulMDBFlags, &dwObjType, (LPUNKNOWN*)&pFolder)!=S_OK) return NULL;
MAPIFreeBuffer(props);
if(pFolder)
{
CMAPIFolder* pMAPIFolder=new CMAPIFolder(this, pFolder);
if(bInternal)
{
delete m_pFolder;
m_pFolder=pMAPIFolder;
}
return pMAPIFolder;
}
return NULL;
}
void CMapiApi::ReportLongProp( const char *pTag, LPSPropValue pVal)
{
if ( pVal && (PROP_TYPE( pVal->ulPropTag) == PT_LONG)) {
nsCString num;
nsCString num2;
num.AppendInt( (PRInt32) pVal->Value.l);
num2.AppendInt( (PRInt32) pVal->Value.l, 16);
MAPI_TRACE3( "%s %s, 0x%s\n", pTag, num, num2);
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_NULL)) {
MAPI_TRACE1( "%s {NULL}\n", pTag);
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_ERROR)) {
MAPI_TRACE1( "%s {Error retrieving property}\n", pTag);
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_ERROR)) {
MAPI_TRACE1( "%s {Error retrieving property}\n", pTag);
}
else {
MAPI_TRACE1( "%s invalid value, expecting long\n", pTag);
}
if (pVal)
MAPIFreeBuffer( pVal);
}
void CMapiApi::ReportUIDProp( const char *pTag, LPSPropValue pVal)
{
if ( pVal && (PROP_TYPE( pVal->ulPropTag) == PT_BINARY)) {
if (pVal->Value.bin.cb != 16) {
MAPI_TRACE1( "%s - INVALID, expecting 16 bytes of binary data for UID\n", pTag);
}
else {
nsIID uid;
memcpy( &uid, pVal->Value.bin.lpb, 16);
char * pStr = uid.ToString();
if (pStr) {
MAPI_TRACE2( "%s %s\n", pTag, (const char *)pStr);
NS_Free( pStr);
}
}
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_NULL)) {
MAPI_TRACE1( "%s {NULL}\n", pTag);
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_ERROR)) {
MAPI_TRACE1( "%s {Error retrieving property}\n", pTag);
}
else {
MAPI_TRACE1( "%s invalid value, expecting binary\n", pTag);
}
if (pVal)
MAPIFreeBuffer( pVal);
}
BOOL CMapiApi::GetStringFromProp( LPSPropValue pVal, nsString& val, BOOL delVal)
{
BOOL bResult = TRUE;
if ( pVal && (PROP_TYPE( pVal->ulPropTag) == PT_STRING8)) {
CStrToUnicode( (const char *)pVal->Value.lpszA, val);
}
else if ( pVal && (PROP_TYPE( pVal->ulPropTag) == PT_UNICODE)) {
val = (PRUnichar *) pVal->Value.lpszW;
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_NULL)) {
val.Truncate();
}
else if (pVal && (PROP_TYPE( pVal->ulPropTag) == PT_ERROR)) {
val.Truncate();
bResult = FALSE;
}
else {
if (pVal) {
MAPI_TRACE1( "GetStringFromProp: invalid value, expecting string - %d\n", (int) PROP_TYPE( pVal->ulPropTag));
}
else {
MAPI_TRACE0( "GetStringFromProp: invalid value, expecting string, got null pointer\n");
}
val.Truncate();
bResult = FALSE;
}
if (pVal && delVal)
MAPIFreeBuffer( pVal);
return( bResult);
}
CMAPIFolder* CMAPIEx::OpenInbox(BOOL bInternal)
{
#ifdef _WIN32_WCE
return OpenFolder(PR_CE_IPM_INBOX_ENTRYID, bInternal);
#else
if(!m_pMsgStore) return NULL;
ULONG cbEntryID;
LPENTRYID pEntryID;
DWORD dwObjType;
LPMAPIFOLDER pFolder;
if(m_pMsgStore->GetReceiveFolder(NULL, 0, &cbEntryID, &pEntryID, NULL)!=S_OK) return NULL;
HRESULT hr=m_pMsgStore->OpenEntry(cbEntryID, pEntryID, NULL, m_ulMDBFlags, &dwObjType, (LPUNKNOWN*)&pFolder);
MAPIFreeBuffer(pEntryID);
if(hr==S_OK && pFolder)
{
CMAPIFolder* pMAPIFolder=new CMAPIFolder(this, pFolder);
if(bInternal)
{
delete m_pFolder;
m_pFolder=pMAPIFolder;
}
return pMAPIFolder;
}
return NULL;
#endif
}
LPMAPIFOLDER CExMapi::GetNextSubFolder(CString& strFolderName,LPMAPIFOLDER pFolder)
{
if(!m_pHierarchy) return NULL;
if(!pFolder) {
pFolder=m_pFolder;
if(!pFolder) return FALSE;
}
DWORD dwObjType;
LPSRowSet pRows=NULL;
LPMAPIFOLDER pSubFolder=NULL;
if(m_pHierarchy->QueryRows(1,0,&pRows)==S_OK)
{
if(pRows->cRows)
{
if(pFolder->OpenEntry(pRows->aRow[0].lpProps[PROP_ENTRYID].Value.bin.cb,(LPENTRYID)pRows->aRow[0].lpProps[PROP_ENTRYID].Value.bin.lpb, NULL, MAPI_MODIFY, &dwObjType,(LPUNKNOWN*)&pSubFolder)==S_OK)
{
strFolderName=CString(GetValidString(pRows->aRow[0].lpProps[0]));
}
}
FreeProws(pRows);
MAPIFreeBuffer(pRows);
}
return pSubFolder;
}
// 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;
}
