/**
\details Logoff an Exchange store
This function uninitializes the MAPI session associated to the
object.
\param obj_store pointer to the store object
\return MAPI_E_SUCCESS on success, otherwise MAPI_E_NOT_FOUND
*/
_PUBLIC_ enum MAPISTATUS Logoff(mapi_object_t *obj_store)
{
struct mapi_context *mapi_ctx;
struct mapi_session *session;
struct mapi_session *el;
bool found = false;
/* Sanity checks */
session = mapi_object_get_session(obj_store);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_INVALID_PARAMETER, NULL);
mapi_ctx = session->mapi_ctx;
OPENCHANGE_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
for (el = mapi_ctx->session; el; el = el->next) {
if (session == el) {
found = true;
mapi_object_release(obj_store);
DLIST_REMOVE(mapi_ctx->session, el);
MAPIFreeBuffer(session);
break;
}
}
return (found == true) ? MAPI_E_SUCCESS : MAPI_E_NOT_FOUND;
}
/**
\details Test the RegisterNotification (0x29) operation
This function:
-#
\param mt pointer on the top-level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_oxcnotif_RegisterNotification(struct mapitest *mt)
{
enum MAPISTATUS retval;
bool ret;
mapi_object_t obj_store;
mapi_object_t obj_folder;
struct mapi_session *session;
uint32_t tcon;
/* Step 1. Logon */
mapi_object_init(&obj_store);
retval = OpenMsgStore(mt->session, &obj_store);
mapitest_print_retval(mt, "OpenMsgStore");
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 2. Open Inbox folder */
mapi_object_init(&obj_folder);
ret = mapitest_common_folder_open(mt, &obj_store, &obj_folder, olFolderInbox);
if (!ret) {
return ret;
}
/* Step 3. Register notification */
session = mapi_object_get_session(&obj_store);
retval = RegisterNotification(session);
mapitest_print_retval(mt, "RegisterNotification");
if ( retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 4. Subscribe for notifications */
retval = Subscribe(&obj_store, &tcon, fnevObjectCopied, true, cb, NULL);
mapitest_print_retval(mt, "Subscribe");
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 5. Unsubscribe for notifications */
retval = Unsubscribe(mt->session, tcon);
mapitest_print_retval(mt, "Unsubscribe");
if (retval != MAPI_E_SUCCESS) {
return false;
}
/* Step 6. Cleanup */
mapi_object_release(&obj_folder);
mapi_object_release(&obj_store);
return true;
}
/**
\details Release an object on the server
The function releases the object \a obj on the server.
\param obj the object to release
\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_CALL_FAILED: A network problem was encountered during the
transaction
\sa GetLastError
*/
_PUBLIC_ enum MAPISTATUS Release(mapi_object_t *obj)
{
struct mapi_request *mapi_request;
struct mapi_response *mapi_response;
struct EcDoRpc_MAPI_REQ *mapi_req;
struct mapi_session *session;
NTSTATUS status;
TALLOC_CTX *mem_ctx;
uint32_t size = 0;
enum MAPISTATUS retval;
uint8_t logon_id = 0;
mapi_response = 0;
/* Sanity checks */
session = mapi_object_get_session(obj);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_INVALID_PARAMETER, NULL);
if ((retval = mapi_object_get_logon_id(obj, &logon_id)) != MAPI_E_SUCCESS)
return retval;
mem_ctx = talloc_named(session, 0, "Release");
/* Fill the MAPI_REQ request */
mapi_req = talloc_zero(mem_ctx, struct EcDoRpc_MAPI_REQ);
mapi_req->opnum = op_MAPI_Release;
mapi_req->logon_id = logon_id;
mapi_req->handle_idx = 0;
size += 5;
/* Fill the mapi_request structure */
mapi_request = talloc_zero(mem_ctx, struct mapi_request);
mapi_request->mapi_len = size + sizeof (uint32_t);
mapi_request->length = (uint16_t)size;
mapi_request->mapi_req = mapi_req;
mapi_request->handles = talloc_array(mem_ctx, uint32_t, 1);
mapi_request->handles[0] = mapi_object_get_handle(obj);
status = emsmdb_transaction_wrapper(session, mem_ctx, mapi_request, &mapi_response);
OPENCHANGE_RETVAL_IF(!NT_STATUS_IS_OK(status), MAPI_E_CALL_FAILED, mem_ctx);
if (mapi_response->mapi_repl) {
OPENCHANGE_CHECK_NOTIFICATION(session, mapi_response);
}
talloc_free(mapi_response);
talloc_free(mem_ctx);
errno = 0;
return MAPI_E_SUCCESS;
}
/**
\details Returns values of one or more properties for an object
The function takes a pointer on the object obj, a MAPITAGS array
specified in mapitags, and the count of properties. The function
returns associated values within the SPropValue values pointer.
The array of MAPI property tags can be filled with both known and
named properties.
\param obj the object to get properties on
\param flags Flags for behaviour; can be bit-OR of MAPI_UNICODE and
MAPI_PROPS_SKIP_NAMEDID_CHECK constants
\param SPropTagArray an array of MAPI property tags
\param lpProps the result of the query
\param PropCount the count of property tags
\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_INVALID_PARAMETER: obj or SPropTagArray are null, or the
session context could not be obtained
- MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
\sa SetProps, GetPropList, GetPropsAll, DeleteProps, GetLastError
*/
_PUBLIC_ enum MAPISTATUS GetProps(mapi_object_t *obj,
uint32_t flags,
struct SPropTagArray *SPropTagArray,
struct SPropValue **lpProps,
uint32_t *PropCount)
{
struct mapi_context *mapi_ctx;
struct mapi_request *mapi_request;
struct mapi_response *mapi_response;
struct EcDoRpc_MAPI_REQ *mapi_req;
struct GetProps_req request;
struct mapi_session *session;
struct mapi_nameid *nameid;
struct SPropTagArray properties;
struct SPropTagArray *SPropTagArray2 = NULL;
NTSTATUS status;
enum MAPISTATUS retval;
enum MAPISTATUS mapistatus;
uint32_t size;
TALLOC_CTX *mem_ctx;
bool named = false;
uint8_t logon_id;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!obj, MAPI_E_INVALID_PARAMETER, NULL);
OPENCHANGE_RETVAL_IF(!SPropTagArray, MAPI_E_INVALID_PARAMETER, NULL);
session = mapi_object_get_session(obj);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_INVALID_PARAMETER, NULL);
mapi_ctx = session->mapi_ctx;
OPENCHANGE_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
if ((retval = mapi_object_get_logon_id(obj, &logon_id)) != MAPI_E_SUCCESS)
return retval;
mem_ctx = talloc_named(session, 0, "GetProps");
/* Named property mapping */
nameid = mapi_nameid_new(mem_ctx);
if (!(flags & MAPI_PROPS_SKIP_NAMEDID_CHECK)) {
retval = mapi_nameid_lookup_SPropTagArray(nameid, SPropTagArray);
if (retval == MAPI_E_SUCCESS) {
named = true;
SPropTagArray2 = talloc_zero(mem_ctx, struct SPropTagArray);
retval = GetIDsFromNames(obj, nameid->count, nameid->nameid, 0, &SPropTagArray2);
OPENCHANGE_RETVAL_IF(retval, retval, mem_ctx);
mapi_nameid_map_SPropTagArray(nameid, SPropTagArray, SPropTagArray2);
MAPIFreeBuffer(SPropTagArray2);
}
void _IcalEvent2Exchange(mapi_object_t *obj_folder, icalcomponent *vevent)
{
struct ical2exchange ical2exchange;
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
mapi_object_t obj_message;
ical2exchange.obj_message = &obj_message;
ical2exchange.method=ICAL_METHOD_PUBLISH;
mapi_object_init(&obj_message);
/*sanity check*/
if(icalcomponent_isa(vevent) != ICAL_VEVENT_COMPONENT) return;
mem_ctx = talloc_named(mapi_object_get_session(obj_folder), 0, "ical2exchange");
ical2exchange.lpProps = talloc_array(mem_ctx, struct SPropValue, 2);
ical2exchange_init(&ical2exchange, mem_ctx);
ical2exchange_get_properties(&ical2exchange, vevent);
ical2exchange_convert_event(&ical2exchange);
retval = CreateMessage(obj_folder, &obj_message);
if (retval != MAPI_E_SUCCESS){
mapi_errstr("CreateMessage", GetLastError());
} else {
retval = SetProps(&obj_message, 0, ical2exchange.lpProps, ical2exchange.cValues);
if (retval != MAPI_E_SUCCESS){
mapi_errstr("SetProps", GetLastError());
} else {
retval = SaveChangesMessage(obj_folder, &obj_message, KeepOpenReadOnly);
if (retval != MAPI_E_SUCCESS){
mapi_errstr("SaveChangesMessage", GetLastError());
}
}
}
MAPIFreeBuffer(ical2exchange.lpProps);
ical2exchange_reset(&ical2exchange);
talloc_free(mem_ctx);
}
/**
\details creates a DATA_BLOB in uncompressed Rich Text Format (RTF)
from the compressed format used in the PR_RTF_COMPRESSED property
opened in the stream.
\param obj_stream stream object with RTF stream content
\param rtf the output blob with uncompressed content
\return MAPI_E_SUCCESS on success, otherwise MAPI error. Possible
MAPI error codes are:
- MAPI_E_NOT_INITIALIZED: MAPI subsystem has not been initialized
- MAPI_E_INVALID_PARAMETER: obj_stream is not a valid pointer
- MAPI_E_CORRUPT_DATA: a problem was encountered while
decompressing the RTF compressed data
- MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
\note Developers may also call GetLastError() to retrieve the last
MAPI error code.
\note rtf->data needs to be freed with MAPIFreeBuffer
\sa OpenStream
*/
_PUBLIC_ enum MAPISTATUS WrapCompressedRTFStream(mapi_object_t *obj_stream,
DATA_BLOB *rtf)
{
enum MAPISTATUS retval;
struct mapi_context *mapi_ctx;
struct mapi_session *session;
TALLOC_CTX *mem_ctx;
uint32_t in_size;
uint8_t *rtfcomp;
uint16_t read_size;
unsigned char buf[0x1000];
/* sanity check and init */
OPENCHANGE_RETVAL_IF(!obj_stream, MAPI_E_INVALID_PARAMETER, NULL);
session = mapi_object_get_session(obj_stream);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_NOT_INITIALIZED, NULL);
mapi_ctx = session->mapi_ctx;
OPENCHANGE_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
mem_ctx = mapi_ctx->mem_ctx;
/* Read the stream pointed by obj_stream */
read_size = 0;
in_size = 0;
rtfcomp = talloc_zero(mem_ctx, uint8_t);
do {
retval = ReadStream(obj_stream, buf, 0x1000, &read_size);
OPENCHANGE_RETVAL_IF(retval, GetLastError(), rtf->data);
if (read_size) {
rtfcomp = talloc_realloc(mem_ctx, rtfcomp, uint8_t,
in_size + read_size);
memcpy(&(rtfcomp[in_size]), buf, read_size);
in_size += read_size;
}
} while (read_size);
return uncompress_rtf(mem_ctx, rtfcomp, in_size, rtf);
}
/**
\details Opens a specific message and retrieves a MAPI object that
can be used to get or set message properties.
This function opens a specific message defined by a combination of
object store, folder ID, and message ID and which read/write access
is defined by ulFlags.
\param obj_store the store to read from
\param id_folder the folder ID
\param id_message the message ID
\param obj_message the resulting message object
\param ulFlags
Possible ulFlags values:
- 0x0: read only access
- 0x1: ReadWrite
- 0x3: Create
- 0x4: OpenSoftDeleted
\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_INVALID_PARAMETER: obj_store is undefined
- MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
\sa MAPIInitialize, GetLastError
*/
_PUBLIC_ enum MAPISTATUS OpenMessage(mapi_object_t *obj_store,
mapi_id_t id_folder,
mapi_id_t id_message,
mapi_object_t *obj_message,
uint8_t ulFlags)
{
struct mapi_context *mapi_ctx;
struct mapi_request *mapi_request;
struct mapi_response *mapi_response;
struct EcDoRpc_MAPI_REQ *mapi_req;
struct OpenMessage_req request;
struct OpenMessage_repl *reply;
struct mapi_session *session;
mapi_object_message_t *message;
struct SPropValue lpProp;
const char *tstring;
NTSTATUS status;
enum MAPISTATUS retval;
uint32_t size = 0;
TALLOC_CTX *mem_ctx;
uint32_t i = 0;
uint8_t logon_id;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!obj_store, MAPI_E_INVALID_PARAMETER, NULL);
session = mapi_object_get_session(obj_store);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_INVALID_PARAMETER, NULL);
mapi_ctx = session->mapi_ctx;
OPENCHANGE_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
if ((retval = mapi_object_get_logon_id(obj_store, &logon_id)) != MAPI_E_SUCCESS)
return retval;
mem_ctx = talloc_named(session, 0, "OpenMessage");
/* Fill the OpenMessage operation */
request.handle_idx = 0x1;
request.CodePageId = 0xfff;
request.FolderId = id_folder;
request.OpenModeFlags = (enum OpenMessage_OpenModeFlags)ulFlags;
request.MessageId = id_message;
size = sizeof (uint8_t) + sizeof(uint16_t) + sizeof(mapi_id_t) + sizeof(uint8_t) + sizeof(mapi_id_t);
/* Fill the MAPI_REQ request */
mapi_req = talloc_zero(mem_ctx, struct EcDoRpc_MAPI_REQ);
mapi_req->opnum = op_MAPI_OpenMessage;
mapi_req->logon_id = logon_id;
mapi_req->handle_idx = 0;
mapi_req->u.mapi_OpenMessage = request;
size += 5;
/* Fill the mapi_request structure */
mapi_request = talloc_zero(mem_ctx, struct mapi_request);
mapi_request->mapi_len = size + sizeof (uint32_t) * 2;
mapi_request->length = size;
mapi_request->mapi_req = mapi_req;
mapi_request->handles = talloc_array(mem_ctx, uint32_t, 2);
mapi_request->handles[0] = mapi_object_get_handle(obj_store);
mapi_request->handles[1] = 0xffffffff;
status = emsmdb_transaction_wrapper(session, mem_ctx, mapi_request, &mapi_response);
OPENCHANGE_RETVAL_IF(!NT_STATUS_IS_OK(status), MAPI_E_CALL_FAILED, mem_ctx);
OPENCHANGE_RETVAL_IF(!mapi_response->mapi_repl, MAPI_E_CALL_FAILED, mem_ctx);
retval = mapi_response->mapi_repl->error_code;
OPENCHANGE_RETVAL_IF(retval, retval, mem_ctx);
OPENCHANGE_CHECK_NOTIFICATION(session, mapi_response);
/* Set object session and handle */
mapi_object_set_session(obj_message, session);
mapi_object_set_handle(obj_message, mapi_response->handles[1]);
mapi_object_set_logon_id(obj_message, logon_id);
/* Store OpenMessage reply data */
reply = &mapi_response->mapi_repl->u.mapi_OpenMessage;
message = talloc_zero((TALLOC_CTX *)session, mapi_object_message_t);
tstring = get_TypedString(&reply->SubjectPrefix);
if (tstring) {
message->SubjectPrefix = talloc_strdup((TALLOC_CTX *)message, tstring);
}
tstring = get_TypedString(&reply->NormalizedSubject);
if (tstring) {
message->NormalizedSubject = talloc_strdup((TALLOC_CTX *)message, tstring);
}
message->cValues = reply->RecipientColumns.cValues;
message->SRowSet.cRows = reply->RowCount;
message->SRowSet.aRow = talloc_array((TALLOC_CTX *)message, struct SRow, reply->RowCount + 1);
message->SPropTagArray.cValues = reply->RecipientColumns.cValues;
message->SPropTagArray.aulPropTag = talloc_steal(message, reply->RecipientColumns.aulPropTag);
for (i = 0; i < reply->RowCount; i++) {
emsmdb_get_SRow((TALLOC_CTX *)message,
&(message->SRowSet.aRow[i]), &message->SPropTagArray,
reply->RecipientRows[i].RecipientRow.prop_count,
&reply->RecipientRows[i].RecipientRow.prop_values,
reply->RecipientRows[i].RecipientRow.layout, 1);
lpProp.ulPropTag = PR_RECIPIENT_TYPE;
lpProp.value.l = reply->RecipientRows[i].RecipientType;
SRow_addprop(&(message->SRowSet.aRow[i]), lpProp);
lpProp.ulPropTag = PR_INTERNET_CPID;
lpProp.value.l = reply->RecipientRows[i].CodePageId;
SRow_addprop(&(message->SRowSet.aRow[i]), lpProp);
}
/* add SPropTagArray elements we automatically append to SRow */
SPropTagArray_add((TALLOC_CTX *)message, &message->SPropTagArray, PR_RECIPIENT_TYPE);
SPropTagArray_add((TALLOC_CTX *)message, &message->SPropTagArray, PR_INTERNET_CPID);
obj_message->private_data = (void *) message;
talloc_free(mapi_response);
talloc_free(mem_ctx);
return MAPI_E_SUCCESS;
}
/**
\details Retrieve the message properties for an already open message.
This function is very similar to OpenMessage, but works on an already
open message object.
\param obj_message the message object to retrieve the properties for.
\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_INVALID_PARAMETER: obj_store is undefined
- MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
\sa OpenMessage
*/
_PUBLIC_ enum MAPISTATUS ReloadCachedInformation(mapi_object_t *obj_message)
{
struct mapi_context *mapi_ctx;
struct mapi_request *mapi_request;
struct mapi_response *mapi_response;
struct EcDoRpc_MAPI_REQ *mapi_req;
struct ReloadCachedInformation_req request;
struct ReloadCachedInformation_repl *reply;
struct mapi_session *session;
mapi_object_message_t *message;
struct SPropValue lpProp;
NTSTATUS status;
enum MAPISTATUS retval;
uint32_t size = 0;
TALLOC_CTX *mem_ctx;
uint32_t i = 0;
uint8_t logon_id;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!obj_message, MAPI_E_INVALID_PARAMETER, NULL);
session = mapi_object_get_session(obj_message);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_INVALID_PARAMETER, NULL);
mapi_ctx = session->mapi_ctx;
OPENCHANGE_RETVAL_IF(!mapi_ctx, MAPI_E_NOT_INITIALIZED, NULL);
if ((retval = mapi_object_get_logon_id(obj_message, &logon_id)) != MAPI_E_SUCCESS)
return retval;
mem_ctx = talloc_named(session, 0, "ReloadCachedInformation");
/* Fill the ReloadCachedInformation operation */
request.Reserved = 0x0000;
size += sizeof (uint16_t);
/* Fill the MAPI_REQ request */
mapi_req = talloc_zero(mem_ctx, struct EcDoRpc_MAPI_REQ);
mapi_req->opnum = op_MAPI_ReloadCachedInformation;
mapi_req->logon_id = logon_id;
mapi_req->handle_idx = 0;
mapi_req->u.mapi_ReloadCachedInformation = request;
size += 5;
/* Fill the mapi_request structure */
mapi_request = talloc_zero(mem_ctx, struct mapi_request);
mapi_request->mapi_len = size + sizeof (uint32_t);
mapi_request->length = size;
mapi_request->mapi_req = mapi_req;
mapi_request->handles = talloc_array(mem_ctx, uint32_t, 1);
mapi_request->handles[0] = mapi_object_get_handle(obj_message);
status = emsmdb_transaction_wrapper(session, mem_ctx, mapi_request, &mapi_response);
OPENCHANGE_RETVAL_IF(!NT_STATUS_IS_OK(status), MAPI_E_CALL_FAILED, mem_ctx);
OPENCHANGE_RETVAL_IF(!mapi_response->mapi_repl, MAPI_E_CALL_FAILED, mem_ctx);
retval = mapi_response->mapi_repl->error_code;
OPENCHANGE_RETVAL_IF(retval, retval, mem_ctx);
OPENCHANGE_CHECK_NOTIFICATION(session, mapi_response);
/* Store ReloadCachedInformation reply data */
reply = &mapi_response->mapi_repl->u.mapi_ReloadCachedInformation;
message = talloc_zero((TALLOC_CTX *)session, mapi_object_message_t);
message->cValues = reply->RecipientColumns.cValues;
message->SRowSet.cRows = reply->RowCount;
message->SRowSet.aRow = talloc_array((TALLOC_CTX *)message, struct SRow, reply->RowCount + 1);
message->SPropTagArray.cValues = reply->RecipientColumns.cValues;
message->SPropTagArray.aulPropTag = talloc_steal(message, reply->RecipientColumns.aulPropTag);
for (i = 0; i < reply->RowCount; i++) {
emsmdb_get_SRow((TALLOC_CTX *)message,
&(message->SRowSet.aRow[i]), &message->SPropTagArray,
reply->RecipientRows[i].RecipientRow.prop_count,
&reply->RecipientRows[i].RecipientRow.prop_values,
reply->RecipientRows[i].RecipientRow.layout, 1);
lpProp.ulPropTag = PR_RECIPIENT_TYPE;
lpProp.value.l = reply->RecipientRows[i].RecipientType;
SRow_addprop(&(message->SRowSet.aRow[i]), lpProp);
lpProp.ulPropTag = PR_INTERNET_CPID;
lpProp.value.l = reply->RecipientRows[i].CodePageId;
SRow_addprop(&(message->SRowSet.aRow[i]), lpProp);
}
/* add SPropTagArray elements we automatically append to SRow */
SPropTagArray_add((TALLOC_CTX *)message, &message->SPropTagArray, PR_RECIPIENT_TYPE);
SPropTagArray_add((TALLOC_CTX *)message, &message->SPropTagArray, PR_INTERNET_CPID);
talloc_free(obj_message->private_data);
obj_message->private_data = (void *) message;
talloc_free(mapi_response);
talloc_free(mem_ctx);
errno = 0;
return MAPI_E_SUCCESS;
}
icalcomponent * _Exchange2Ical(mapi_object_t *obj_folder, struct exchange2ical_check *exchange2ical_check)
{
TALLOC_CTX *mem_ctx;
enum MAPISTATUS retval;
int ret;
struct SRowSet SRowSet;
struct SRow aRow;
struct SRow aRowT;
struct SPropValue *lpProps;
struct SPropTagArray *SPropTagArray = NULL;
struct exchange2ical exchange2ical;
mapi_object_t obj_table;
uint32_t count;
int i;
mem_ctx = talloc_named(mapi_object_get_session(obj_folder), 0, "exchange2ical");
exchange2ical_init(mem_ctx, &exchange2ical);
/* Open the contents table */
mapi_object_init(&obj_table);
retval = GetContentsTable(obj_folder, &obj_table, 0, &count);
if (retval != MAPI_E_SUCCESS){
talloc_free(mem_ctx);
return NULL;
}
OC_DEBUG(0, "MAILBOX (%d appointments)", count);
if (count == 0) {
talloc_free(mem_ctx);
return NULL;
}
SPropTagArray = set_SPropTagArray(mem_ctx, 0x2,
PR_FID,
PR_MID);
retval = SetColumns(&obj_table, SPropTagArray);
MAPIFreeBuffer(SPropTagArray);
if (retval != MAPI_E_SUCCESS) {
mapi_errstr("SetColumns", retval);
talloc_free(mem_ctx);
return NULL;
}
while ((retval = QueryRows(&obj_table, count, TBL_ADVANCE, TBL_FORWARD_READ, &SRowSet)) != MAPI_E_NOT_FOUND && SRowSet.cRows) {
count -= SRowSet.cRows;
for (i = (SRowSet.cRows-1); i >= 0; i--) {
mapi_object_init(&exchange2ical.obj_message);
retval = OpenMessage(obj_folder,
SRowSet.aRow[i].lpProps[0].value.d,
SRowSet.aRow[i].lpProps[1].value.d,
&exchange2ical.obj_message, 0);
if (retval != MAPI_E_NOT_FOUND) {
SPropTagArray = set_SPropTagArray(mem_ctx, 0x30,
PidLidGlobalObjectId,
PidNameKeywords,
PidLidRecurring,
PidLidAppointmentRecur,
PidLidAppointmentStateFlags,
PidLidTimeZoneDescription,
PidLidTimeZoneStruct,
PidLidContacts,
PidLidAppointmentStartWhole,
PidLidAppointmentEndWhole,
PidLidAppointmentSubType,
PidLidOwnerCriticalChange,
PidLidLocation,
PidLidNonSendableBcc,
PidLidAppointmentSequence,
PidLidBusyStatus,
PidLidIntendedBusyStatus,
PidLidAttendeeCriticalChange,
PidLidAppointmentReplyTime,
PidLidAppointmentNotAllowPropose,
PidLidAllowExternalCheck,
PidLidAppointmentLastSequence,
PidLidAppointmentSequenceTime,
PidLidAutoFillLocation,
PidLidAutoStartCheck,
PidLidCollaborateDoc,
PidLidConferencingCheck,
PidLidConferencingType,
PidLidDirectory,
PidLidMeetingWorkspaceUrl,
PidLidNetShowUrl,
PidLidOnlinePassword,
PidLidOrganizerAlias,
PidLidReminderSet,
PidLidReminderDelta,
PidLidResponseStatus,
PR_MESSAGE_CLASS_UNICODE,
PR_SENSITIVITY,
PR_BODY_UNICODE,
PR_CREATION_TIME,
PR_LAST_MODIFICATION_TIME,
PR_IMPORTANCE,
PR_RESPONSE_REQUESTED,
PR_SUBJECT_UNICODE,
PR_OWNER_APPT_ID,
PR_SENDER_NAME,
PR_SENDER_EMAIL_ADDRESS,
PR_MESSAGE_LOCALE_ID
);
retval = GetProps(&exchange2ical.obj_message, MAPI_UNICODE, SPropTagArray, &lpProps, &count);
MAPIFreeBuffer(SPropTagArray);
if (retval == MAPI_E_SUCCESS) {
aRow.ulAdrEntryPad = 0;
aRow.cValues = count;
aRow.lpProps = lpProps;
/*Get Vcal info if first event*/
if(i==(SRowSet.cRows-1)){
ret = exchange2ical_get_properties(mem_ctx, &aRow, &exchange2ical, VcalFlag);
/*TODO: exit nicely*/
ical_component_VCALENDAR(&exchange2ical);
}
/*Get required properties to check if right event*/
ret = exchange2ical_get_properties(mem_ctx, &aRow, &exchange2ical, exchange2ical_check->eFlags);
/*Check to see if event is acceptable*/
if (!checkEvent(&exchange2ical, exchange2ical_check, get_tm_from_FILETIME(exchange2ical.apptStartWhole))){
continue;
}
/*Set RecipientTable*/
retval = GetRecipientTable(&exchange2ical.obj_message,
&exchange2ical.Recipients.SRowSet,
&exchange2ical.Recipients.SPropTagArray);
/*Set PR_BODY_HTML for x_alt_desc property*/
SPropTagArray = set_SPropTagArray(mem_ctx, 0x1, PR_BODY_HTML_UNICODE);
retval = GetProps(&exchange2ical.obj_message, MAPI_UNICODE, SPropTagArray, &lpProps, &count);
MAPIFreeBuffer(SPropTagArray);
if (retval == MAPI_E_SUCCESS) {
aRowT.ulAdrEntryPad = 0;
aRowT.cValues = count;
aRowT.lpProps = lpProps;
exchange2ical.bodyHTML = (const char *)octool_get_propval(&aRowT, PR_BODY_HTML_UNICODE);
}
/*Get rest of properties*/
ret = exchange2ical_get_properties(mem_ctx, &aRow, &exchange2ical, (exchange2ical_check->eFlags | EntireFlag));
/*add new vevent*/
ical_component_VEVENT(&exchange2ical);
/*Exceptions to event*/
if(exchange2ical_check->eFlags != EventFlag){
ret = exchange2ical_exception_from_EmbeddedObj(&exchange2ical, exchange2ical_check);
if (ret){
ret=exchange2ical_exception_from_ExceptionInfo(&exchange2ical, exchange2ical_check);
}
}
/*REMOVE once globalobjid is fixed*/
exchange2ical.idx++;
MAPIFreeBuffer(lpProps);
exchange2ical_reset(&exchange2ical);
}
}
mapi_object_release(&exchange2ical.obj_message);
}
}
icalcomponent *icalendar = exchange2ical.vcalendar;
exchange2ical_clear(&exchange2ical);
/* Uninitialize MAPI subsystem */
mapi_object_release(&obj_table);
talloc_free(mem_ctx);
return icalendar;
}
/**
\details Convert an Long Term Id into an Id
The function looks up the Id for a specified Long Term Id value.
\param obj the object to look up on
\param long_term_id the id to look up
\param id the id returned by the server
\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_INVALID_PARAMETER: obj is null
- MAPI_E_CALL_FAILED: A network problem was encountered during the
transaction
\sa GetLongTermIdFromId
*/
_PUBLIC_ enum MAPISTATUS GetIdFromLongTermId(mapi_object_t *obj, struct LongTermId long_term_id,
mapi_id_t *id)
{
struct mapi_request *mapi_request;
struct mapi_response *mapi_response;
struct EcDoRpc_MAPI_REQ *mapi_req;
struct IdFromLongTermId_req request;
struct mapi_session *session;
NTSTATUS status;
TALLOC_CTX *mem_ctx;
uint32_t size = 0;
enum MAPISTATUS retval;
uint8_t logon_id = 0;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!obj, MAPI_E_INVALID_PARAMETER, NULL);
session = mapi_object_get_session(obj);
OPENCHANGE_RETVAL_IF(!session, MAPI_E_INVALID_PARAMETER, NULL);
if ((retval = mapi_object_get_logon_id(obj, &logon_id)) != MAPI_E_SUCCESS)
return retval;
mem_ctx = talloc_named(session, 0, "IdFromLongTermId");
size = 0;
/* Fill the IdFromLongTermId operation */
request.LongTermId = long_term_id;
size += sizeof(struct LongTermId);
/* Fill the MAPI_REQ request */
mapi_req = talloc_zero(mem_ctx, struct EcDoRpc_MAPI_REQ);
mapi_req->opnum = op_MAPI_IdFromLongTermId;
mapi_req->logon_id = logon_id;
mapi_req->handle_idx = 0;
mapi_req->u.mapi_IdFromLongTermId = request;
size += 5;
/* Fill the mapi_request structure */
mapi_request = talloc_zero(mem_ctx, struct mapi_request);
mapi_request->mapi_len = size + sizeof (uint32_t);
mapi_request->length = (uint16_t)size;
mapi_request->mapi_req = mapi_req;
mapi_request->handles = talloc_array(mem_ctx, uint32_t, 1);
mapi_request->handles[0] = mapi_object_get_handle(obj);
status = emsmdb_transaction_wrapper(session, mem_ctx, mapi_request, &mapi_response);
OPENCHANGE_RETVAL_IF(!NT_STATUS_IS_OK(status), MAPI_E_CALL_FAILED, mem_ctx);
OPENCHANGE_RETVAL_IF(!mapi_response->mapi_repl, MAPI_E_CALL_FAILED, mem_ctx);
retval = mapi_response->mapi_repl->error_code;
OPENCHANGE_RETVAL_IF(retval, retval, mem_ctx);
OPENCHANGE_CHECK_NOTIFICATION(session, mapi_response);
*id = mapi_response->mapi_repl->u.mapi_IdFromLongTermId.Id;
talloc_free(mapi_response);
talloc_free(mem_ctx);
errno = 0;
return MAPI_E_SUCCESS;
}
/**
\details Test #1804 ModifyRecipients and try to build RecipientRow
with multi-value properties (e.g. PidTagUserX509Certificate)
\param mt pointer to the top level mapitest structure
\return true on success, otherwise false
*/
_PUBLIC_ bool mapitest_zentyal_1804(struct mapitest *mt)
{
enum MAPISTATUS retval;
mapi_object_t obj_store;
mapi_object_t obj_folder;
mapi_object_t obj_message;
mapi_id_t id_folder;
char **username = NULL;
struct SPropTagArray *SPropTagArray = NULL;
struct PropertyValue_r value;
struct PropertyRowSet_r *RowSet = NULL;
struct SRowSet *SRowSet = NULL;
struct PropertyTagArray_r *flaglist = NULL;
mapi_id_t id_msgs[1];
/* Step 1. Logon */
mapi_object_init(&obj_store);
retval = OpenMsgStore(mt->session, &obj_store);
mapitest_print_retval(mt, "OpenMsgStore");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 2. Open Outbox folder */
retval = GetDefaultFolder(&obj_store, &id_folder, olFolderOutbox);
mapitest_print_retval(mt, "GetDefaultFolder");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
mapi_object_init(&obj_folder);
retval = OpenFolder(&obj_store, id_folder, &obj_folder);
mapitest_print_retval(mt, "OpenFolder");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 3. Create the message */
mapi_object_init(&obj_message);
retval = CreateMessage(&obj_folder, &obj_message);
mapitest_print_retval(mt, "CreateMessage");
if (GetLastError() != MAPI_E_SUCCESS) {
return false;
}
/* Step 4. Resolve the recipients and call ModifyRecipients */
SPropTagArray = set_SPropTagArray(mt->mem_ctx, 0xA,
PR_ENTRYID,
PR_DISPLAY_NAME_UNICODE,
PR_OBJECT_TYPE,
PR_DISPLAY_TYPE,
PR_TRANSMITTABLE_DISPLAY_NAME_UNICODE,
PR_EMAIL_ADDRESS_UNICODE,
PR_ADDRTYPE_UNICODE,
PR_SEND_RICH_INFO,
PR_7BIT_DISPLAY_NAME_UNICODE,
PR_SMTP_ADDRESS_UNICODE);
username = talloc_array(mt->mem_ctx, char *, 2);
username[0] = (char *)mt->profile->username;
username[1] = NULL;
retval = ResolveNames(mapi_object_get_session(&obj_message),
(const char **)username, SPropTagArray,
&RowSet, &flaglist, MAPI_UNICODE);
mapitest_print_retval_clean(mt, "ResolveNames", retval);
if (retval != MAPI_E_SUCCESS) {
return false;
}
if (!RowSet) {
mapitest_print(mt, "Null RowSet\n");
return false;
}
if (!RowSet->cRows) {
mapitest_print(mt, "No values in RowSet\n");
MAPIFreeBuffer(RowSet);
return false;
}
value.ulPropTag = PR_SEND_INTERNET_ENCODING;
value.value.l = 0;
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
/* Fake multi-value property on RecipientRow */
/* PT_MV_STRING8 */
value.ulPropTag = PR_EMS_AB_PROXY_ADDRESSES;
value.value.MVszA.cValues = 2;
value.value.MVszA.lppszA = talloc_array(mt->mem_ctx, const char *, value.value.MVszA.cValues);
value.value.MVszA.lppszA[0] = "smtp:[email protected]";
value.value.MVszA.lppszA[1] = "X400:c=US;a= ;p=First Organizati;o=Exchange;s=test";
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
/* PT_MV_UNICODE - same layout as PT_MV_STRING8 */
value.ulPropTag = PR_EMS_AB_PROXY_ADDRESSES_UNICODE;
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
/* PT_MV_BINARY */
value.ulPropTag = PidTagUserX509Certificate;
value.value.MVbin.cValues = 2;
value.value.MVbin.lpbin = talloc_array(mt->mem_ctx, struct Binary_r, value.value.MVbin.cValues);
value.value.MVbin.lpbin[0].cb = 9;
value.value.MVbin.lpbin[0].lpb = (uint8_t *)"string 1";
value.value.MVbin.lpbin[1].cb = 9;
value.value.MVbin.lpbin[1].lpb = (uint8_t *)"string 2";
PropertyRowSet_propcpy(mt->mem_ctx, RowSet, value);
SRowSet = talloc_zero(RowSet, struct SRowSet);
cast_PropertyRowSet_to_SRowSet(SRowSet, RowSet, SRowSet);
SetRecipientType(&(SRowSet->aRow[0]), MAPI_TO);
mapitest_print_retval(mt, "SetRecipientType");
retval = ModifyRecipients(&obj_message, SRowSet);
mapitest_print_retval_fmt(mt, "ModifyRecipients", "(%s)", "MAPI_TO");
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(flaglist);
return false;
}
/* Step 5. Delete the message */
id_msgs[0] = mapi_object_get_id(&obj_message);
retval = DeleteMessage(&obj_folder, id_msgs, 1);
mapitest_print_retval(mt, "DeleteMessage");
if (retval != MAPI_E_SUCCESS) {
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(flaglist);
return false;
}
/* Release */
MAPIFreeBuffer(RowSet);
MAPIFreeBuffer(flaglist);
mapi_object_release(&obj_message);
mapi_object_release(&obj_folder);
mapi_object_release(&obj_store);
return true;
}
