/**
\details Retrieve the total number of records in the global address
list
The Global Address List is the full list of email addresses (and other
account-type things, such as "rooms" and distribution lists) accessible
on the server. A user will usually have access to both a personal
address book, and to the Global Address List. Public Address Book is
another name for Global Address List.
\param session pointer to the MAPI session context
\param totalRecs pointers to the total number of records in the
global address list returned
\return MAPI_E_SUCCESS on success, otherwise MAPI error.
\note Developers may also call GetLastError() to retrieve the last
MAPI error code. Possible MAPI error codes are:
-# MAPI_E_NOT_INITIALIZED: MAPI subsystem has not been initialized
-# MAPI_E_SESSION_LIMIT: No session has been opened on the provider
-# MAPI_E_INVALID_PARAMETER: if a function parameter is invalid
-# MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
*/
_PUBLIC_ enum MAPISTATUS GetGALTableCount(struct mapi_session *session,
uint32_t *totalRecs)
{
TALLOC_CTX *mem_ctx;
struct nspi_context *nspi;
enum MAPISTATUS retval;
struct PropertyRowSet_r *rowset;
/* Sanity Checks */
OPENCHANGE_RETVAL_IF(!session, MAPI_E_SESSION_LIMIT, NULL);
OPENCHANGE_RETVAL_IF(!session->nspi, MAPI_E_SESSION_LIMIT, NULL);
OPENCHANGE_RETVAL_IF(!session->nspi->ctx, MAPI_E_SESSION_LIMIT, NULL);
mem_ctx = talloc_named(session, 0, "GetGALTableCount");
nspi = (struct nspi_context *) session->nspi->ctx;
nspi->pStat->CurrentRec = 0;
nspi->pStat->Delta = 0;
nspi->pStat->NumPos = 0;
nspi->pStat->TotalRecs = 0xffffffff;
rowset = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_QueryRows(nspi, mem_ctx, NULL, NULL, 0, &rowset);
*totalRecs = nspi->pStat->TotalRecs;
OPENCHANGE_RETVAL_IF(retval, retval, mem_ctx);
talloc_free(mem_ctx);
return MAPI_E_SUCCESS;
}
/**
\details Test #1863 NspiQueryRows and try to build PR_ENTRYID for
AD user which is not part of OpenChange.
\param mt pointer to the top level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_zentyal_1863(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct PropertyTagArray_r *MIds;
struct PropertyRowSet_r *RowSet;
struct SPropTagArray *SPropTagArray;
struct PropertyValue_r *lpProp;
struct Restriction_r Filter;
mem_ctx = talloc_named(NULL, 0, "mapitest_zentyal_1863");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
/* Build the array of columns we want to retrieve */
SPropTagArray = set_SPropTagArray(mem_ctx, 0x2, PR_DISPLAY_NAME,
PR_DISPLAY_TYPE);
/* Build the restriction we want for NspiGetMatches on
* existing AD user but not OpenChange one
*/
lpProp = talloc_zero(mem_ctx, struct PropertyValue_r);
lpProp->ulPropTag = PR_ACCOUNT;
lpProp->dwAlignPad = 0;
lpProp->value.lpszA = talloc_strdup(lpProp, mt->profile->username);
Filter.rt = RES_PROPERTY;
Filter.res.resProperty.relop = RES_PROPERTY;
Filter.res.resProperty.ulPropTag = PR_ACCOUNT;
Filter.res.resProperty.lpProp = lpProp;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
MIds = talloc_zero(mem_ctx, struct PropertyTagArray_r);
retval = nspi_GetMatches(nspi_ctx, mem_ctx, SPropTagArray, &Filter, 5000, &RowSet, &MIds);
MAPIFreeBuffer(lpProp);
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(SPropTagArray);
mapitest_print_retval_clean(mt, "NspiGetMatches", retval);
if (retval != MAPI_E_SUCCESS) {
talloc_free(mem_ctx);
return false;
}
/* Query the rows */
SPropTagArray = set_SPropTagArray(mem_ctx, 0x1, PR_ENTRYID);
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_QueryRows(nspi_ctx, mem_ctx, SPropTagArray, MIds, 1, &RowSet);
MAPIFreeBuffer(SPropTagArray);
MAPIFreeBuffer(RowSet);
mapitest_print_retval_clean(mt, "NspiQueryRows", retval);
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MIds);
talloc_free(mem_ctx);
return false;
}
talloc_free(mem_ctx);
return true;
}
/**
\details Retrieve the global address list
The Global Address List is the full list of email addresses (and other
account-type things, such as "rooms" and distribution lists) accessible
on the server. A user will usually have access to both a personal
address book, and to the Global Address List. Public Address Book is
another name for Global Address List.
You access the Global Address List by setting the list of things that
you want to retrieve from the Global Address List as property names
in the SPropTagArray argument, and then calling this function. The
results are returned in SRowSet.
You can get a convenient output of the results using mapidump_PAB_entry()
for each row returned.
\param session pointer to the MAPI session context
\param SPropTagArray pointer to an array of MAPI properties we want
to fetch
\param rowsetp pointer to the rows of the table returned
\param count the number of rows we want to fetch
\param ulFlags specify the table cursor location
Possible value for ulFlags:
-# TABLE_START: Fetch rows from the beginning of the table
-# TABLE_CUR: Fetch rows from current table location
The Global Address List may be quite large (tens of thousands of
entries in a large deployment), so you usually call this function
with ulFlags set to TABLE_START the first time, and then subsequent
calls will be made with TABLE_CUR to progress through the table.
\return MAPI_E_SUCCESS on success, otherwise MAPI error.
\note Developers may also call GetLastError() to retrieve the last
MAPI error code. Possible MAPI error codes are:
-# MAPI_E_NOT_INITIALIZED: MAPI subsystem has not been initialized
-# MAPI_E_SESSION_LIMIT: No session has been opened on the provider
-# MAPI_E_INVALID_PARAMETER: if a function parameter is invalid
-# MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
\sa MapiLogonEx, MapiLogonProvider, mapidump_PAB_entry
*/
_PUBLIC_ enum MAPISTATUS GetGALTable(struct mapi_session *session,
struct SPropTagArray *SPropTagArray,
struct PropertyRowSet_r **rowsetp,
uint32_t count,
uint8_t ulFlags)
{
TALLOC_CTX *mem_ctx;
struct nspi_context *nspi;
struct PropertyRowSet_r *rowset;
enum MAPISTATUS retval;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!session, MAPI_E_SESSION_LIMIT, NULL);
OPENCHANGE_RETVAL_IF(!session->nspi, MAPI_E_SESSION_LIMIT, NULL);
OPENCHANGE_RETVAL_IF(!session->nspi->ctx, MAPI_E_SESSION_LIMIT, NULL);
OPENCHANGE_RETVAL_IF(!rowsetp, MAPI_E_INVALID_PARAMETER, NULL);
OPENCHANGE_RETVAL_IF(!SPropTagArray, MAPI_E_INVALID_PARAMETER, NULL);
mem_ctx = talloc_named(session, 0, "GetGALTable");
nspi = (struct nspi_context *)session->nspi->ctx;
if (ulFlags == TABLE_START) {
nspi->pStat->CurrentRec = 0;
nspi->pStat->Delta = 0;
nspi->pStat->NumPos = 0;
nspi->pStat->TotalRecs = 0xffffffff;
}
rowset = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_QueryRows(nspi, mem_ctx, SPropTagArray, NULL, count, &rowset);
rowset = talloc_steal(session, rowset);
*rowsetp = rowset;
OPENCHANGE_RETVAL_IF(retval, retval, mem_ctx);
talloc_free(mem_ctx);
return MAPI_E_SUCCESS;
}
/**
\details Test #1872 NspiQueryRows
\param mt pointer to the top level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_zentyal_1872(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
struct nspi_context *nspi_ctx;
struct PropertyRowSet_r *RowSet;
struct PropertyTagArray_r *MIds;
enum MAPISTATUS retval;
/* Sanity checks */
mem_ctx = talloc_named(NULL, 0, "mapitest_zentyal_1872");
if (!mem_ctx) return false;
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
if (!nspi_ctx) return false;
MIds = talloc_zero(mem_ctx, struct PropertyTagArray_r);
if (!MIds) return false;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
if (!RowSet) return false;
/* Update pStat with incorrect data */
nspi_ctx->pStat->NumPos = 99;
retval = nspi_QueryRows(nspi_ctx, mem_ctx, NULL, MIds, 1, &RowSet);
MAPIFreeBuffer(RowSet);
mapitest_print_retval_clean(mt, "1872", retval);
if (retval != MAPI_E_INVALID_PARAMETER) {
MAPIFreeBuffer(MIds);
talloc_free(mem_ctx);
return false;
}
talloc_free(mem_ctx);
return true;
}
/**
\details Test the NspiModProps RPC operation (0xb)
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_nspi_ModProps(struct mapitest *mt)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
struct nspi_context *nspi_ctx;
struct PropertyRow_r *pRow;
struct SPropTagArray *pPropTags;
struct PropertyValue_r modProp;
struct PropertyTagArray_r *MIds;
struct PropertyRowSet_r *RowSet;
struct SPropTagArray *SPropTagArray;
struct PropertyValue_r *lpProp;
struct Restriction_r Filter;
const char *original_office_location;
bool ret = true;
mem_ctx = talloc_named(NULL, 0, "mapitest_nspi_ModProps");
nspi_ctx = (struct nspi_context *) mt->session->nspi->ctx;
/* Build the array of columns we want to retrieve */
SPropTagArray = set_SPropTagArray(mem_ctx, 0x2, PR_DISPLAY_NAME,
PR_DISPLAY_TYPE);
/* Build the restriction we want for NspiGetMatches */
lpProp = talloc_zero(mem_ctx, struct PropertyValue_r);
lpProp->ulPropTag = PR_ACCOUNT;
lpProp->dwAlignPad = 0;
lpProp->value.lpszA = mt->mapi_ctx->session->profile->username;
Filter.rt = RES_PROPERTY;
Filter.res.resProperty.relop = RES_PROPERTY;
Filter.res.resProperty.ulPropTag = PR_ACCOUNT;
Filter.res.resProperty.lpProp = lpProp;
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
MIds = talloc_zero(mem_ctx, struct PropertyTagArray_r);
retval = nspi_GetMatches(nspi_ctx, mem_ctx, SPropTagArray, &Filter, 5000, &RowSet, &MIds);
MAPIFreeBuffer(lpProp);
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(SPropTagArray);
mapitest_print_retval_clean(mt, "nspi_GetMatches", retval);
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MIds);
talloc_free(mem_ctx);
return false;
}
/* Query the rows */
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_QueryRows(nspi_ctx, mem_ctx, NULL, MIds, 1, &RowSet);
mapitest_print_retval_clean(mt, "nspi_QueryRows", retval);
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MIds);
MAPIFreeBuffer(RowSet);
talloc_free(mem_ctx);
return false;
}
if (RowSet->cRows != 1) {
mapitest_print(mem_ctx, "unexpected number of rows: %i\n", RowSet->cRows);
MAPIFreeBuffer(MIds);
MAPIFreeBuffer(RowSet);
talloc_free(mem_ctx);
return false;
}
original_office_location = (const char *)find_PropertyValue_data(&(RowSet->aRow[0]), PR_OFFICE_LOCATION);
mapitest_print(mt, "original PR_OFFICE_LOCATION value: %s\n", original_office_location);
/* Build the SRow and SPropTagArray for NspiModProps */
pRow = talloc_zero(mem_ctx, struct PropertyRow_r);
modProp.ulPropTag = PR_OFFICE_LOCATION;
modProp.value.lpszA = "MT office location";
PropertyRow_addprop(pRow, modProp);
pPropTags = set_SPropTagArray(mem_ctx, 0x1, PR_OFFICE_LOCATION);
retval = nspi_ModProps(nspi_ctx, mem_ctx, MIds->aulPropTag[0], pPropTags, pRow);
mapitest_print_retval_clean(mt, "nspi_ModProps", retval);
MAPIFreeBuffer(pRow);
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MIds);
MAPIFreeBuffer(pPropTags);
talloc_free(mem_ctx);
return false;
}
/* Check that the property was set correctly */
RowSet = talloc_zero(mem_ctx, struct PropertyRowSet_r);
retval = nspi_QueryRows(nspi_ctx, mem_ctx, NULL, MIds, 1, &RowSet);
mapitest_print_retval_clean(mt, "nspi_QueryRows", retval);
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(MIds);
MAPIFreeBuffer(RowSet);
talloc_free(mem_ctx);
return false;
}
if (RowSet->cRows != 1) {
mapitest_print(mem_ctx, "unexpected number of rows: %i\n", RowSet->cRows);
MAPIFreeBuffer(MIds);
MAPIFreeBuffer(RowSet);
talloc_free(mem_ctx);
return false;
}
if (strcmp((const char *)find_PropertyValue_data(&(RowSet->aRow[0]), PR_OFFICE_LOCATION), "MT office location") != 0) {
mapitest_print(mt, "PR_OFFICE_LOCATION string value mismatch: %s", (const char *)find_PropertyValue_data(&(RowSet->aRow[0]), PR_OFFICE_LOCATION));
ret = false;
} else {
mapitest_print(mt, "correctly set PR_OFFICE_LOCATION\n");
}
/* try to reset the office location back to the original value */
pRow = talloc_zero(mem_ctx, struct PropertyRow_r);
modProp.ulPropTag = PR_OFFICE_LOCATION;
modProp.value.lpszA = original_office_location;
PropertyRow_addprop(pRow, modProp);
retval = nspi_ModProps(nspi_ctx, mem_ctx, MIds->aulPropTag[0], pPropTags, pRow);
mapitest_print_retval_clean(mt, "nspi_ModProps (reset original value)", retval);
if (retval != MAPI_E_SUCCESS) {
ret = false;
}
MAPIFreeBuffer(MIds);
MAPIFreeBuffer(pPropTags);
MAPIFreeBuffer(pRow);
talloc_free(mem_ctx);
return ret;
}
