_PUBLIC_ NTSTATUS ndr_push_WbemQualifier(struct ndr_push *ndr, int ndr_flags, const struct WbemQualifier *r)
{
if (ndr_flags & NDR_SCALARS) {
NDR_CHECK(ndr_push_align(ndr, 4));
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
NDR_CHECK(ndr_push_WBEM_FLAVOR_TYPE(ndr, NDR_SCALARS, r->flavors));
NDR_CHECK(ndr_push_CIMTYPE_ENUMERATION(ndr, NDR_SCALARS, r->cimtype));
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->value, r->cimtype & CIM_TYPEMASK));
NDR_CHECK(ndr_push_CIMVAR(ndr, NDR_SCALARS, &r->value));
}
if (ndr_flags & NDR_BUFFERS) {
if (r->name) {
uint32_t ofs;
int32_t i;
for (i = 0; i < arr_sizeof(qualifier_keys); ++i)
if (qualifier_keys[i] && !strcmp(r->name, qualifier_keys[i])) break;
if (i == arr_sizeof(qualifier_keys)) {
if (!strncmp(qn_unknown, r->name, sizeof(qn_unknown) - 1))
i = atoi(r->name + sizeof(qn_unknown) - 1);
else
i = -1;
}
if (i >= 0) {
ofs = ndr->offset;
NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, r->name, &ndr->offset));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x80000000 | i));
ndr->offset = ofs;
} else {
NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
NDR_CHECK(ndr_push_CIMSTRING(ndr, NDR_SCALARS, &r->name));
}
}
NDR_CHECK(ndr_push_CIMVAR(ndr, NDR_BUFFERS, &r->value));
}
return NT_STATUS_OK;
}
/*
push a relative object - stage2
this is called during buffers processing
*/
static enum ndr_err_code ndr_push_relative_ptr2(struct ndr_push *ndr, const void *p)
{
uint32_t save_offset;
uint32_t ptr_offset = 0xFFFFFFFF;
if (p == NULL) {
return NDR_ERR_SUCCESS;
}
save_offset = ndr->offset;
NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, p, &ptr_offset));
if (ptr_offset > ndr->offset) {
return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
"ndr_push_relative_ptr2 ptr_offset(%u) > ndr->offset(%u)",
ptr_offset, ndr->offset);
}
ndr->offset = ptr_offset;
if (save_offset < ndr->relative_base_offset) {
return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
"ndr_push_relative_ptr2 save_offset(%u) < ndr->relative_base_offset(%u)",
save_offset, ndr->relative_base_offset);
}
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, save_offset - ndr->relative_base_offset));
ndr->offset = save_offset;
return NDR_ERR_SUCCESS;
}
_PUBLIC_ enum ndr_err_code ndr_push_PERF_INSTANCE_DEFINITION(struct ndr_push *ndr, int ndr_flags, const struct PERF_INSTANCE_DEFINITION *r)
{
if (ndr_flags & NDR_SCALARS) {
NDR_CHECK(ndr_push_align(ndr, 5));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ByteLength));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ParentObjectTitleIndex));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ParentObjectTitlePointer));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->UniqueID));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NameOffset));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NameLength));
NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
NDR_CHECK(ndr_push_PERF_COUNTER_BLOCK(ndr, NDR_SCALARS, &r->counter_data));
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
}
if (ndr_flags & NDR_BUFFERS) {
if (r->data) {
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->data));
}
}
return NDR_ERR_SUCCESS;
}
/*
push a subcontext header
*/
_PUBLIC_ enum ndr_err_code ndr_push_subcontext_end(struct ndr_push *ndr,
struct ndr_push *subndr,
size_t header_size,
ssize_t size_is)
{
ssize_t padding_len;
if (size_is >= 0) {
padding_len = size_is - subndr->offset;
if (padding_len < 0) {
return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PUSH) content_size %d is larger than size_is(%d)",
(int)subndr->offset, (int)size_is);
}
subndr->offset = size_is;
}
switch (header_size) {
case 0:
break;
case 2:
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, subndr->offset));
break;
case 4:
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, subndr->offset));
break;
case 0xFFFFFC01:
/*
* Common Type Header for the Serialization Stream
* See [MS-RPCE] 2.2.6 Type Serialization Version 1
*/
padding_len = NDR_ROUND(subndr->offset, 8) - subndr->offset;
if (padding_len > 0) {
NDR_CHECK(ndr_push_zero(subndr, padding_len));
}
/* version */
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 1));
/*
* 0x10 little endian
* 0x00 big endian
*/
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, NDR_BE(ndr)?0x00:0x10));
/* length of the "Private Header for Constructed Type" */
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 8));
/* filler */
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0xCCCCCCCC));
/*
* Private Header for Constructed Type
*/
/* length - will be updated latter */
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, subndr->offset));
/* reserved */
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
break;
default:
return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext header size %d",
(int)header_size);
}
NDR_CHECK(ndr_push_bytes(ndr, subndr->data, subndr->offset));
return NDR_ERR_SUCCESS;
}
_PUBLIC_ enum ndr_err_code ndr_push_PERF_OBJECT_TYPE(struct ndr_push *ndr, int ndr_flags, const struct PERF_OBJECT_TYPE *r)
{
uint32_t cntr_counters_0;
uint32_t cntr_instances_0;
if (ndr_flags & NDR_SCALARS) {
NDR_CHECK(ndr_push_align(ndr, 8));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->TotalByteLength));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DefinitionLength));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->HeaderLength));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectNameTitleIndex));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectNameTitlePointer));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectHelpTitleIndex));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ObjectHelpTitlePointer));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DetailLevel));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NumCounters));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DefaultCounter));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->NumInstances));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CodePage));
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfTime));
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->PerfFreq));
for (cntr_counters_0 = 0; cntr_counters_0 < r->NumCounters; cntr_counters_0++) {
NDR_CHECK(ndr_push_PERF_COUNTER_DEFINITION(ndr, NDR_SCALARS, &r->counters[cntr_counters_0]));
}
for (cntr_instances_0 = 0; cntr_instances_0 < r->NumInstances; cntr_instances_0++) {
NDR_CHECK(ndr_push_PERF_INSTANCE_DEFINITION(ndr, NDR_SCALARS, &r->instances[cntr_instances_0]));
}
NDR_CHECK(ndr_push_PERF_COUNTER_BLOCK(ndr, NDR_SCALARS, &r->counter_data));
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
}
if (ndr_flags & NDR_BUFFERS) {
for (cntr_instances_0 = 0; cntr_instances_0 < r->NumInstances; cntr_instances_0++) {
NDR_CHECK(ndr_push_PERF_INSTANCE_DEFINITION(ndr, NDR_BUFFERS, &r->instances[cntr_instances_0]));
}
}
return NDR_ERR_SUCCESS;
}
/*
push always a 0, if a pointer is NULL it's a fatal error
*/
_PUBLIC_ enum ndr_err_code ndr_push_ref_ptr(struct ndr_push *ndr)
{
return ndr_push_uint32(ndr, NDR_SCALARS, 0xAEF1AEF1);
}
/*
push a NTSTATUS
*/
_PUBLIC_ enum ndr_err_code ndr_push_NTSTATUS(struct ndr_push *ndr, int ndr_flags, NTSTATUS status)
{
return ndr_push_uint32(ndr, ndr_flags, NT_STATUS_V(status));
}
_PUBLIC_ enum ndr_err_code ndr_push_security_autoinherit(struct ndr_push *ndr, int ndr_flags, uint32_t r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
/*
push a uint32_t enum
*/
_PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
{
return ndr_push_uint32(ndr, ndr_flags, v);
}
static enum ndr_err_code ndr_push_dssetup_DsRoleFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
/*
push a HRESULT
*/
_PUBLIC_ enum ndr_err_code ndr_push_HRESULT(struct ndr_push *ndr, int ndr_flags, HRESULT status)
{
return ndr_push_uint32(ndr, NDR_SCALARS, HRES_ERROR_V(status));
}
NTSTATUS ndr_push_security_secinfo(struct ndr_push *ndr, int ndr_flags, uint32_t r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NT_STATUS_OK;
}
static NTSTATUS ndr_push_security_ace_object_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NT_STATUS_OK;
}
static enum ndr_err_code ndr_push_RemoteActivation(struct ndr_push *ndr, int flags, const struct RemoteActivation *r)
{
uint32_t cntr_pIIDs_1;
uint32_t cntr_protseq_0;
uint32_t cntr_ifaces_0;
uint32_t cntr_results_0;
if (flags & NDR_IN) {
NDR_CHECK(ndr_push_ORPCTHIS(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.this_object));
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.Clsid));
if (r->in.pwszObjectName == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.pwszObjectName, CH_UTF16)));
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.pwszObjectName, CH_UTF16)));
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.pwszObjectName, ndr_charset_length(r->in.pwszObjectName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
if (r->in.pObjectStorage == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_MInterfacePointer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.pObjectStorage));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.ClientImpLevel));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Mode));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.Interfaces));
if (r->in.pIIDs == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.Interfaces));
for (cntr_pIIDs_1 = 0; cntr_pIIDs_1 < r->in.Interfaces; cntr_pIIDs_1++) {
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.pIIDs[cntr_pIIDs_1]));
}
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_protseqs));
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_protseqs));
for (cntr_protseq_0 = 0; cntr_protseq_0 < r->in.num_protseqs; cntr_protseq_0++) {
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.protseq[cntr_protseq_0]));
}
}
if (flags & NDR_OUT) {
if (r->out.that == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_ORPCTHAT(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.that));
if (r->out.pOxid == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.pOxid));
if (r->out.pdsaOxidBindings == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_DUALSTRINGARRAY(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.pdsaOxidBindings));
if (r->out.ipidRemUnknown == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->out.ipidRemUnknown));
if (r->out.AuthnHint == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.AuthnHint));
if (r->out.ServerVersion == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_COMVERSION(ndr, NDR_SCALARS, r->out.ServerVersion));
if (r->out.hr == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, *r->out.hr));
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.Interfaces));
for (cntr_ifaces_0 = 0; cntr_ifaces_0 < r->in.Interfaces; cntr_ifaces_0++) {
if (r->out.ifaces[cntr_ifaces_0] == NULL) {
return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
}
}
for (cntr_ifaces_0 = 0; cntr_ifaces_0 < r->in.Interfaces; cntr_ifaces_0++) {
NDR_CHECK(ndr_push_MInterfacePointer(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ifaces[cntr_ifaces_0]));
}
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.Interfaces));
for (cntr_results_0 = 0; cntr_results_0 < r->in.Interfaces; cntr_results_0++) {
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.results[cntr_results_0]));
}
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
}
return NDR_ERR_SUCCESS;
}
/**
\details Add a property value to a DATA blob. This convenient
function should be used when creating a GetPropertiesSpecific reply
response blob.
\param mem_ctx pointer to the memory context
\param property the property tag which value is meant to be
appended to the blob
\param value generic pointer on the property value
\param blob the data blob the function uses to return the blob
\param layout whether values should be prefixed by a layout
\param flagged define if the properties are flagged or not
\note blob.length must be set to 0 before this function is called
the first time. Also the function only supports a limited set of
property types at the moment.
\return 0 on success;
*/
_PUBLIC_ int libmapiserver_push_property(TALLOC_CTX *mem_ctx,
uint32_t property,
const void *value,
DATA_BLOB *blob,
uint8_t layout,
uint8_t flagged,
uint8_t untyped)
{
struct ndr_push *ndr;
struct SBinary_short bin;
struct BinaryArray_r *bin_array;
uint32_t i;
ndr = ndr_push_init_ctx(mem_ctx);
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
ndr->offset = 0;
if (blob->length) {
talloc_free(ndr->data);
ndr->data = blob->data;
ndr->offset = blob->length;
}
/* Step 1. Is the property typed */
if (untyped) {
ndr_push_uint16(ndr, NDR_SCALARS, property & 0xFFFF);
}
/* Step 2. Is the property flagged */
if (flagged) {
switch (property & 0xFFFF) {
case PT_ERROR:
switch (layout) {
case 0x1:
ndr_push_uint8(ndr, NDR_SCALARS, layout);
goto end;
case PT_ERROR:
ndr_push_uint8(ndr, NDR_SCALARS, PT_ERROR);
break;
}
break;
default:
ndr_push_uint8(ndr, NDR_SCALARS, 0x0);
break;
}
} else {
/* Step 3. Set the layout */
if (layout) {
switch (property & 0xFFFF) {
case PT_ERROR:
ndr_push_uint8(ndr, NDR_SCALARS, PT_ERROR);
break;
default:
ndr_push_uint8(ndr, NDR_SCALARS, 0x0);
}
}
}
/* Step 3. Push property data if supported */
switch (property & 0xFFFF) {
case PT_I2:
ndr_push_uint16(ndr, NDR_SCALARS, *(uint16_t *) value);
break;
case PT_LONG:
case PT_ERROR:
case PT_OBJECT:
ndr_push_uint32(ndr, NDR_SCALARS, *(uint32_t *) value);
break;
case PT_DOUBLE:
ndr_push_double(ndr, NDR_SCALARS, *(double *) value);
break;
case PT_I8:
ndr_push_dlong(ndr, NDR_SCALARS, *(uint64_t *) value);
break;
case PT_BOOLEAN:
ndr_push_uint8(ndr, NDR_SCALARS, *(uint8_t *) value);
break;
case PT_STRING8:
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_STR_ASCII);
ndr_push_string(ndr, NDR_SCALARS, (char *) value);
break;
case PT_UNICODE:
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
ndr_push_string(ndr, NDR_SCALARS, (char *) value);
break;
case PT_BINARY:
case PT_SVREID:
/* PropertyRow expect a 16 bit header for BLOB in RopQueryRows and RopGetPropertiesSpecific */
bin.cb = ((struct Binary_r *) value)->cb;
bin.lpb = ((struct Binary_r *) value)->lpb;
ndr_push_SBinary_short(ndr, NDR_SCALARS, &bin);
break;
case PT_CLSID:
ndr_push_GUID(ndr, NDR_SCALARS, (struct GUID *) value);
break;
case PT_SYSTIME:
ndr_push_FILETIME(ndr, NDR_SCALARS, (struct FILETIME *) value);
break;
case PT_MV_LONG:
ndr_push_mapi_MV_LONG_STRUCT(ndr, NDR_SCALARS, (struct mapi_MV_LONG_STRUCT *) value);
break;
case PT_MV_UNICODE:
ndr_push_mapi_SLPSTRArrayW(ndr, NDR_SCALARS, (struct mapi_SLPSTRArrayW *) value);
break;
case PT_MV_BINARY:
bin_array = (struct BinaryArray_r *) value;
ndr_push_uint32(ndr, NDR_SCALARS, bin_array->cValues);
for (i = 0; i < bin_array->cValues; i++) {
bin.cb = bin_array->lpbin[i].cb;
bin.lpb = bin_array->lpbin[i].lpb;
ndr_push_SBinary_short(ndr, NDR_SCALARS, &bin);
}
break;
default:
if (property != 0) {
OC_DEBUG(5, "unsupported type: %.4x", (property & 0xffff));
abort();
}
break;
}
end:
/* Step 4. Steal ndr context */
blob->data = ndr->data;
talloc_steal(mem_ctx, blob->data);
blob->length = ndr->offset;
talloc_free(ndr);
return 0;
}
_PUBLIC_ enum ndr_err_code ndr_push_PAC_TYPE(struct ndr_push *ndr, int ndr_flags, enum PAC_TYPE r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
_PUBLIC_ enum ndr_err_code ndr_push_kerb_EncTypes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
/**
\details Build an EntryID for message from folder and message source ID
*/
_PUBLIC_ enum MAPISTATUS EntryIDFromSourceIDForMessage(TALLOC_CTX *mem_ctx,
mapi_object_t *obj_store,
mapi_object_t *obj_folder,
mapi_object_t *obj_message,
struct SBinary_short *entryID)
{
enum MAPISTATUS retval;
struct ndr_push *ndr;
mapi_object_store_t *store;
const struct SBinary_short *FolderSourceKey;
const struct SBinary_short *MessageSourceKey;
struct SPropTagArray *SPropTagArray;
struct SPropValue *lpPropsf;
struct SPropValue *lpPropsm;
uint32_t count;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!obj_store, MAPI_E_INVALID_PARAMETER, NULL);
OPENCHANGE_RETVAL_IF(!obj_folder, MAPI_E_INVALID_PARAMETER, NULL);
OPENCHANGE_RETVAL_IF(!obj_message, MAPI_E_INVALID_PARAMETER, NULL);
OPENCHANGE_RETVAL_IF(!entryID, MAPI_E_INVALID_PARAMETER, NULL);
store = (mapi_object_store_t *)obj_store->private_data;
/* Step 1. Retrieve folder Source Key */
SPropTagArray = set_SPropTagArray(mem_ctx, 0x1, PidTagSourceKey);
retval = GetProps(obj_folder, 0, SPropTagArray, &lpPropsf, &count);
MAPIFreeBuffer(SPropTagArray);
if (retval != MAPI_E_SUCCESS) return MAPI_E_NOT_FOUND;
FolderSourceKey = (const struct SBinary_short *)get_SPropValue(lpPropsf, PidTagSourceKey);
if (FolderSourceKey == NULL) return MAPI_E_NOT_FOUND;
/* Step 2. Retrieve message Source Key */
SPropTagArray = set_SPropTagArray(mem_ctx, 0x1, PidTagSourceKey);
retval = GetProps(obj_message, 0, SPropTagArray, &lpPropsm, &count);
MAPIFreeBuffer(SPropTagArray);
if (retval != MAPI_E_SUCCESS) return MAPI_E_NOT_FOUND;
MessageSourceKey = (const struct SBinary_short *)get_SPropValue(lpPropsm, PidTagSourceKey);
if (MessageSourceKey == NULL) return MAPI_E_NOT_FOUND;
/* Step 3. Fill PidTagEntryID */
/* PidTagEntryId size for message is 70 bytes */
/* Flags (4 bytes) + store guid (16 bytes) + object type (2
* bytes) + Folder SourceKey (22 bytes) + Pad (2 bytes) +
* Message Source (22 bytes) + Pad (2 bytes) == 70 bytes */
ndr = ndr_push_init_ctx(NULL);
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
ndr->offset = 0;
ndr_push_uint32(ndr, NDR_SCALARS, 0x0);
if (store->store_type == PublicFolder) {
const uint8_t ProviderUID[16] = { 0x1A, 0x44, 0x73, 0x90, 0xAA, 0x66, 0x11, 0xCD, 0x9B, 0xC8, 0x00, 0xAA, 0x00, 0x2F, 0xC4, 0x5A };
ndr_push_array_uint8(ndr, NDR_SCALARS, ProviderUID, 16);
ndr_push_uint16(ndr, NDR_SCALARS, 0x0009);
} else {
ndr_push_GUID(ndr, NDR_SCALARS, &store->guid);
ndr_push_uint16(ndr, NDR_SCALARS, 0x0007);
}
ndr_push_array_uint8(ndr, NDR_SCALARS, FolderSourceKey->lpb, FolderSourceKey->cb);
ndr_push_uint16(ndr, NDR_SCALARS, 0x0);
ndr_push_array_uint8(ndr, NDR_SCALARS, MessageSourceKey->lpb, MessageSourceKey->cb);
ndr_push_uint16(ndr, NDR_SCALARS, 0x0);
entryID->cb = ndr->offset;
entryID->lpb = talloc_steal(mem_ctx, ndr->data);
talloc_free(ndr);
return MAPI_E_SUCCESS;
}
static enum ndr_err_code ndr_push_security_ace_object_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
static enum ndr_err_code ndr_push_echo_Enum1_32(struct ndr_push *ndr, int ndr_flags, enum echo_Enum1_32 r)
{
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
return NDR_ERR_SUCCESS;
}
/*
push a WERROR
*/
_PUBLIC_ enum ndr_err_code ndr_push_WERROR(struct ndr_push *ndr, int ndr_flags, WERROR status)
{
return ndr_push_uint32(ndr, NDR_SCALARS, W_ERROR_V(status));
}
/**
push a general string onto the wire
*/
NTSTATUS ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
{
ssize_t s_len, c_len, d_len;
charset_t chset = CH_UTF16LE;
unsigned flags = ndr->flags;
unsigned byte_mul = 2;
uint8_t *dest = NULL;
if (!(ndr_flags & NDR_SCALARS)) {
return NT_STATUS_OK;
}
if (NDR_BE(ndr)) {
chset = CH_UTF16BE;
}
s_len = s?strlen(s):0;
if (flags & LIBNDR_FLAG_STR_ASCII) {
chset = CH_DOS;
byte_mul = 1;
flags &= ~LIBNDR_FLAG_STR_ASCII;
}
if (flags & LIBNDR_FLAG_STR_UTF8) {
chset = CH_UTF8;
byte_mul = 1;
flags &= ~LIBNDR_FLAG_STR_UTF8;
}
flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
if (!(flags &
(LIBNDR_FLAG_STR_NOTERM |
LIBNDR_FLAG_STR_FIXLEN15 |
LIBNDR_FLAG_STR_FIXLEN32))) {
s_len++;
}
d_len = convert_string_talloc(ndr, CH_UNIX, chset, s, s_len, &dest,
False);
if (d_len == -1) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion");
}
if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
c_len = d_len;
flags &= ~LIBNDR_FLAG_STR_BYTESIZE;
} else if (flags & LIBNDR_FLAG_STR_CHARLEN) {
c_len = (d_len / byte_mul)-1;
flags &= ~LIBNDR_FLAG_STR_CHARLEN;
} else {
c_len = d_len / byte_mul;
}
switch ((flags & LIBNDR_STRING_FLAGS) & ~LIBNDR_FLAG_STR_NOTERM) {
case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
break;
case LIBNDR_FLAG_STR_LEN4:
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
break;
case LIBNDR_FLAG_STR_SIZE4:
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
break;
case LIBNDR_FLAG_STR_SIZE2:
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, c_len));
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
break;
case LIBNDR_FLAG_STR_NULLTERM:
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
break;
case LIBNDR_FLAG_STR_FIXLEN15:
case LIBNDR_FLAG_STR_FIXLEN32: {
ssize_t fix_len = (flags & LIBNDR_FLAG_STR_FIXLEN32)?32:15;
uint32_t pad_len = fix_len - d_len;
if (d_len > fix_len) {
return ndr_push_error(ndr, NDR_ERR_CHARCNV,
"Bad character conversion");
}
NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
if (pad_len != 0) {
NDR_CHECK(ndr_push_zero(ndr, pad_len));
}
break;
}
default:
return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
ndr->flags & LIBNDR_STRING_FLAGS);
}
talloc_free(dest);
return NT_STATUS_OK;
}
/*
push a time_t
*/
_PUBLIC_ enum ndr_err_code ndr_push_time_t(struct ndr_push *ndr, int ndr_flags, time_t t)
{
return ndr_push_uint32(ndr, ndr_flags, t);
}
_PUBLIC_ enum ndr_err_code ndr_push_winreg_Data(struct ndr_push *ndr, int ndr_flags, const union winreg_Data *r)
{
{
uint32_t _flags_save_UNION = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
if (ndr_flags & NDR_SCALARS) {
int level = ndr_push_get_switch_value(ndr, r);
NDR_CHECK(ndr_push_union_align(ndr, 4));
switch (level) {
case REG_NONE: {
break; }
case REG_SZ: {
{
uint32_t _flags_save_string = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
ndr->flags = _flags_save_string;
}
break; }
case REG_EXPAND_SZ: {
{
uint32_t _flags_save_string = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
ndr->flags = _flags_save_string;
}
break; }
case REG_BINARY: {
{
uint32_t _flags_save_DATA_BLOB = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
ndr->flags = _flags_save_DATA_BLOB;
}
break; }
case REG_DWORD: {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
break; }
case REG_DWORD_BIG_ENDIAN: {
{
uint32_t _flags_save_uint32 = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
ndr->flags = _flags_save_uint32;
}
break; }
case REG_MULTI_SZ: {
{
uint32_t _flags_save_string_array = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
ndr->flags = _flags_save_string_array;
}
break; }
default: {
{
uint32_t _flags_save_DATA_BLOB = ndr->flags;
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
ndr->flags = _flags_save_DATA_BLOB;
}
break; }
}
}
if (ndr_flags & NDR_BUFFERS) {
int level = ndr_push_get_switch_value(ndr, r);
switch (level) {
case REG_NONE:
break;
case REG_SZ:
break;
case REG_EXPAND_SZ:
break;
case REG_BINARY:
break;
case REG_DWORD:
break;
case REG_DWORD_BIG_ENDIAN:
break;
case REG_MULTI_SZ:
break;
default:
break;
}
}
ndr->flags = _flags_save_UNION;
}
return NDR_ERR_SUCCESS;
}
