bool tldap_pull_guid(struct tldap_message *msg, const char *attribute,
struct GUID *guid)
{
DATA_BLOB val;
if (!tldap_get_single_valueblob(msg, attribute, &val)) {
return false;
}
return NT_STATUS_IS_OK(GUID_from_data_blob(&val, guid));
}
static int handle_dereference(struct ldb_dn *dn,
struct dsdb_openldap_dereference_result **dereference_attrs,
const char *attr, const DATA_BLOB *val)
{
const struct ldb_val *entryUUIDblob, *sid_blob;
struct ldb_message fake_msg; /* easier to use routines that expect an ldb_message */
int j;
fake_msg.num_elements = 0;
/* Look for this attribute in the returned control */
for (j = 0; dereference_attrs && dereference_attrs[j]; j++) {
struct ldb_val source_dn = data_blob_string_const(dereference_attrs[j]->dereferenced_dn);
if (ldb_attr_cmp(dereference_attrs[j]->source_attribute, attr) == 0
&& data_blob_cmp(&source_dn, val) == 0) {
fake_msg.num_elements = dereference_attrs[j]->num_attributes;
fake_msg.elements = dereference_attrs[j]->attributes;
break;
}
}
if (!fake_msg.num_elements) {
return LDB_SUCCESS;
}
/* Look for an OpenLDAP entryUUID */
entryUUIDblob = ldb_msg_find_ldb_val(&fake_msg, "entryUUID");
if (entryUUIDblob) {
NTSTATUS status;
enum ndr_err_code ndr_err;
struct ldb_val guid_blob;
struct GUID guid;
status = GUID_from_data_blob(entryUUIDblob, &guid);
if (!NT_STATUS_IS_OK(status)) {
return LDB_ERR_INVALID_DN_SYNTAX;
}
ndr_err = ndr_push_struct_blob(&guid_blob, NULL, NULL, &guid,
(ndr_push_flags_fn_t)ndr_push_GUID);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return LDB_ERR_INVALID_DN_SYNTAX;
}
ldb_dn_set_extended_component(dn, "GUID", &guid_blob);
}
sid_blob = ldb_msg_find_ldb_val(&fake_msg, "objectSID");
/* Look for the objectSID */
if (sid_blob) {
ldb_dn_set_extended_component(dn, "SID", sid_blob);
}
return LDB_SUCCESS;
}
/*
* Certs used for this protocol have a GUID in the issuer_uniq_id field.
* This function fetch it.
*/
static struct GUID *get_cert_guid(struct torture_context *tctx,
TALLOC_CTX *mem_ctx,
uint8_t *cert_data,
uint32_t cert_len)
{
hx509_context hctx;
hx509_cert cert;
heim_bit_string subjectuniqid;
DATA_BLOB data;
int hret;
uint32_t size;
struct GUID *guid = talloc_zero(mem_ctx, struct GUID);
NTSTATUS status;
hx509_context_init(&hctx);
hret = hx509_cert_init_data(hctx, cert_data, cert_len, &cert);
if (hret) {
torture_comment(tctx, "error while loading the cert\n");
hx509_context_free(&hctx);
return NULL;
}
hret = hx509_cert_get_issuer_unique_id(hctx, cert, &subjectuniqid);
if (hret) {
torture_comment(tctx, "error while getting the issuer_uniq_id\n");
hx509_cert_free(cert);
hx509_context_free(&hctx);
return NULL;
}
/* The subjectuniqid is a bit string,
* which means that the real size has to be divided by 8
* to have the number of bytes
*/
hx509_cert_free(cert);
hx509_context_free(&hctx);
size = subjectuniqid.length / 8;
data = data_blob_const(subjectuniqid.data, size);
status = GUID_from_data_blob(&data, guid);
der_free_bit_string(&subjectuniqid);
if (!NT_STATUS_IS_OK(status)) {
return NULL;
}
return guid;
}
/*
convert a ldif formatted objectGUID to a NDR formatted blob
*/
static int ldif_read_objectGUID(struct ldb_context *ldb, void *mem_ctx,
const struct ldb_val *in, struct ldb_val *out)
{
struct GUID guid;
NTSTATUS status;
status = GUID_from_data_blob(in, &guid);
if (!NT_STATUS_IS_OK(status)) {
return -1;
}
status = GUID_to_ndr_blob(&guid, mem_ctx, out);
if (!NT_STATUS_IS_OK(status)) {
return -1;
}
return 0;
}
/**
\details Build a PermanentEntryID structure
\param emsabp_ctx pointer to the EMSABP context
\param DisplayType the AB object display type
\param msg pointer to the LDB message
\param permEntryID pointer to the PermanentEntryID returned by the
function
\note This function only covers DT_CONTAINER AddressBook
objects. It should be extended in the future to support more
containers.
\return MAPI_E_SUCCESS on success, otherwise
MAPI_E_NOT_ENOUGH_RESOURCES or MAPI_E_CORRUPT_STORE
*/
_PUBLIC_ enum MAPISTATUS emsabp_set_PermanentEntryID(struct emsabp_context *emsabp_ctx,
uint32_t DisplayType, struct ldb_message *msg,
struct PermanentEntryID *permEntryID)
{
struct GUID *guid = (struct GUID *) NULL;
const struct ldb_val *ldb_value = NULL;
const char *dn_str;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!permEntryID, MAPI_E_NOT_ENOUGH_RESOURCES, NULL);
permEntryID->ID_type = 0x0;
permEntryID->R1 = 0x0;
permEntryID->R2 = 0x0;
permEntryID->R3 = 0x0;
memcpy(permEntryID->ProviderUID.ab, GUID_NSPI, 16);
permEntryID->R4 = 0x1;
permEntryID->DisplayType = DisplayType;
permEntryID->dn = NULL;
if (!msg) {
permEntryID->dn = talloc_strdup(emsabp_ctx->mem_ctx, "/");
OPENCHANGE_RETVAL_IF(!permEntryID->dn, MAPI_E_NOT_ENOUGH_MEMORY, NULL);
} else if (DisplayType == DT_CONTAINER) {
ldb_value = ldb_msg_find_ldb_val(msg, "objectGUID");
OPENCHANGE_RETVAL_IF(!ldb_value, MAPI_E_CORRUPT_STORE, NULL);
guid = talloc_zero(emsabp_ctx->mem_ctx, struct GUID);
GUID_from_data_blob(ldb_value, guid);
permEntryID->dn = talloc_asprintf(emsabp_ctx->mem_ctx, EMSABP_DN,
guid->time_low, guid->time_mid,
guid->time_hi_and_version,
guid->clock_seq[0],
guid->clock_seq[1],
guid->node[0], guid->node[1],
guid->node[2], guid->node[3],
guid->node[4], guid->node[5]);
OPENCHANGE_RETVAL_IF(!permEntryID->dn, MAPI_E_NOT_ENOUGH_RESOURCES, guid);
talloc_free(guid);
} else {
/*
parse a binding string into a dcerpc_binding structure
*/
_PUBLIC_ NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding **b_out)
{
struct dcerpc_binding *b;
char *options;
char *p;
int i, j, comma_count;
b = talloc_zero(mem_ctx, struct dcerpc_binding);
if (!b) {
return NT_STATUS_NO_MEMORY;
}
p = strchr(s, '@');
if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
NTSTATUS status;
DATA_BLOB blob = data_blob(s, 36);
status = GUID_from_data_blob(&blob, &b->object.uuid);
if (NT_STATUS_IS_ERR(status)) {
DEBUG(0, ("Failed parsing UUID\n"));
return status;
}
s = p + 1;
} else {
ZERO_STRUCT(b->object);
}
b->object.if_version = 0;
p = strchr(s, ':');
if (p == NULL) {
b->transport = NCA_UNKNOWN;
} else {
char *type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
if (!type) {
return NT_STATUS_NO_MEMORY;
}
for (i=0;i<ARRAY_SIZE(transports);i++) {
if (strcasecmp(type, transports[i].name) == 0) {
b->transport = transports[i].transport;
break;
}
}
if (i==ARRAY_SIZE(transports)) {
DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
return NT_STATUS_INVALID_PARAMETER;
}
talloc_free(type);
s = p+1;
}
p = strchr(s, '[');
if (p) {
b->host = talloc_strndup(b, s, PTR_DIFF(p, s));
options = talloc_strdup(mem_ctx, p+1);
if (options[strlen(options)-1] != ']') {
return NT_STATUS_INVALID_PARAMETER;
}
options[strlen(options)-1] = 0;
} else {
b->host = talloc_strdup(b, s);
options = NULL;
}
if (!b->host) {
return NT_STATUS_NO_MEMORY;
}
b->target_hostname = b->host;
b->options = NULL;
b->flags = 0;
b->assoc_group_id = 0;
b->endpoint = NULL;
b->localaddress = NULL;
if (!options) {
*b_out = b;
return NT_STATUS_OK;
}
comma_count = count_chars(options, ',');
b->options = talloc_array(b, const char *, comma_count+2);
if (!b->options) {
return NT_STATUS_NO_MEMORY;
}
for (i=0; (p = strchr(options, ',')); i++) {
b->options[i] = talloc_strndup(b, options, PTR_DIFF(p, options));
if (!b->options[i]) {
return NT_STATUS_NO_MEMORY;
}
options = p+1;
}
b->options[i] = options;
b->options[i+1] = NULL;
/* some options are pre-parsed for convenience */
for (i=0;b->options[i];i++) {
for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
size_t opt_len = strlen(ncacn_options[j].name);
if (strncasecmp(ncacn_options[j].name, b->options[i], opt_len) == 0) {
int k;
char c = b->options[i][opt_len];
if (ncacn_options[j].flag == DCERPC_LOCALADDRESS && c == '=') {
b->localaddress = talloc_strdup(b, &b->options[i][opt_len+1]);
} else if (c != 0) {
continue;
}
b->flags |= ncacn_options[j].flag;
for (k=i;b->options[k];k++) {
b->options[k] = b->options[k+1];
}
i--;
break;
}
}
}
if (b->options[0]) {
/* Endpoint is first option */
b->endpoint = b->options[0];
if (strlen(b->endpoint) == 0) b->endpoint = NULL;
for (i=0;b->options[i];i++) {
b->options[i] = b->options[i+1];
}
}
if (b->options[0] == NULL)
b->options = NULL;
*b_out = b;
return NT_STATUS_OK;
}
/**
build a GUID from a string
*/
_PUBLIC_ NTSTATUS GUID_from_string(const char *s, struct GUID *guid)
{
DATA_BLOB blob = data_blob_string_const(s);
return GUID_from_data_blob(&blob, guid);
}
