#include "lib/events/events.h"
#include "dsdb/samdb/samdb.h"
#include "lib/util/dlinklist.h"
+#include "lib/ldb/include/ldb.h"
+#include "lib/ldb/include/ldb_errors.h"
+#include "librpc/ndr/libndr.h"
+#include "librpc/gen_ndr/ndr_drsuapi.h"
+#include "librpc/gen_ndr/ndr_drsblobs.h"
+#include "librpc/gen_ndr/ndr_misc.h"
+#include "system/time.h"
+#include "auth/auth.h"
+#include "lib/db_wrap.h"
+#include "lib/appweb/ejs/ejs.h"
+#include "lib/appweb/ejs/ejsInternal.h"
+#include "scripting/ejs/smbcalls.h"
+
+static EjsId eid;
+static int ejs_error;
+
+static void test_ejs_exception(const char *reason)
+{
+ Ejs *ep = ejsPtr(eid);
+ ejsSetErrorMsg(eid, "%s", reason);
+ fprintf(stderr, "%s", ep->error);
+ ejs_error = 127;
+}
+
+static int test_run_ejs(char *script)
+{
+ EjsHandle handle = 0;
+ MprVar result;
+ char *emsg;
+ TALLOC_CTX *mem_ctx = talloc_new(NULL);
+ struct MprVar *return_var;
+
+ mprSetCtx(mem_ctx);
+
+ if (ejsOpen(NULL, NULL, NULL) != 0) {
+ d_printf("ejsOpen(): unable to initialise EJS subsystem\n");
+ ejs_error = 127;
+ goto failed;
+ }
+
+ smb_setup_ejs_functions(test_ejs_exception);
+
+ if ((eid = ejsOpenEngine(handle, 0)) == (EjsId)-1) {
+ d_printf("smbscript: ejsOpenEngine(): unable to initialise an EJS engine\n");
+ ejs_error = 127;
+ goto failed;
+ }
+
+ mprSetVar(ejsGetGlobalObject(eid), "ARGV", mprList("ARGV", NULL));
+
+ /* run the script */
+ if (ejsEvalScript(eid, script, &result, &emsg) == -1) {
+ d_printf("smbscript: ejsEvalScript(): %s\n", emsg);
+ if (ejs_error == 0) ejs_error = 127;
+ goto failed;
+ }
+
+ return_var = ejsGetReturnValue(eid);
+ ejs_error = mprVarToNumber(return_var);
+
+failed:
+ ejsClose();
+ talloc_free(mem_ctx);
+ return ejs_error;
+}
#define TORTURE_NETBIOS_NAME "smbtorturedc"
+#define TORTURE_SAMDB_LDB "test_samdb.ldb"
struct test_become_dc_state {
struct libnet_context *ctx;
const struct libnet_BecomeDC_PrepareDB *p)
{
struct test_become_dc_state *s = talloc_get_type(private_data, struct test_become_dc_state);
+ char *ejs;
+ int ret;
DEBUG(0,("New Server[%s] in Site[%s]\n",
p->dest_dsa->dns_name, p->dest_dsa->site_name));
DEBUG(0,("Domain Partition[%s]\n",
p->domain->dn_str));
+ ejs = talloc_asprintf(s,
+ "libinclude(\"base.js\");\n"
+ "libinclude(\"provision.js\");\n"
+ "\n"
+ "function message() { print(vsprintf(arguments)); }\n"
+ "\n"
+ "var subobj = provision_guess();\n"
+ "subobj.ROOTDN = \"%s\";\n"
+ "subobj.DOMAINDN = \"%s\";\n"
+ "subobj.DOMAINDN_LDB = \"test_domain.ldb\";\n"
+ "subobj.CONFIGDN = \"%s\";\n"
+ "subobj.CONFIGDN_LDB = \"test_config.ldb\";\n"
+ "subobj.SCHEMADN = \"%s\";\n"
+ "subobj.SCHEMADN_LDB = \"test_schema.ldb\";\n"
+ "subobj.HOSTNAME = \"%s\";\n"
+ "subobj.DNSNAME = \"%s\";\n"
+ "subobj.DEFAULTSITE = \"%s\";\n"
+ "\n"
+ "modules_list = new Array(\"rootdse\",\n"
+ " \"kludge_acl\",\n"
+ " \"paged_results\",\n"
+ " \"server_sort\",\n"
+ " \"extended_dn\",\n"
+ " \"asq\",\n"
+ " //\"samldb\",should only handle originating changes...\n"
+ " \"password_hash\",\n"
+ " \"operational\",\n"
+ " \"objectclass\",\n"
+ " \"rdn_name\",\n"
+ " \"partition\");\n"
+ "subobj.MODULES_LIST = join(\",\", modules_list);\n"
+ "subobj.DOMAINDN_MOD = \"objectguid\";\n"
+ "subobj.CONFIGDN_MOD = \"objectguid\";\n"
+ "subobj.SCHEMADN_MOD = \"objectguid\";\n"
+ "\n"
+ "var paths = provision_default_paths(subobj);\n"
+ "paths.samdb = \"%s\";\n"
+ "\n"
+ "var system_session = system_session();\n"
+ "\n"
+ "var ok = provision_become_dc(subobj, message, paths, system_session);\n"
+ "assert(ok);\n"
+ "\n"
+ "return 0;\n",
+ p->forest->root_dn_str,
+ p->domain->dn_str,
+ p->forest->config_dn_str,
+ p->forest->schema_dn_str,
+ p->dest_dsa->netbios_name,
+ p->dest_dsa->dns_name,
+ p->dest_dsa->site_name,
+ TORTURE_SAMDB_LDB);
+ NT_STATUS_HAVE_NO_MEMORY(ejs);
+
+ ret = test_run_ejs(ejs);
+ if (ret != 0) {
+ DEBUG(0,("Failed to run ejs script: %d:\n%s",
+ ret, ejs));
+ talloc_free(ejs);
+ return NT_STATUS_FOOBAR;
+ }
+ talloc_free(ejs);
+
+ talloc_free(s->ldb);
+
+ s->ldb = ldb_wrap_connect(s, TORTURE_SAMDB_LDB,
+ system_session(s),
+ NULL, 0, NULL);
+ if (!s->ldb) {
+ DEBUG(0,("Failed to open '%s'\n",
+ TORTURE_SAMDB_LDB));
+ return NT_STATUS_INTERNAL_DB_ERROR;
+ }
+
+ ret = ldb_transaction_start(s->ldb);
+ if (ret != LDB_SUCCESS) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
return NT_STATUS_OK;
}
TALLOC_CTX *mem_ctx,
struct ldb_message **_msg)
{
+ NTSTATUS nt_status;
WERROR status;
uint32_t i;
struct ldb_message *msg;
+ struct replPropertyMetaDataBlob md;
+ struct ldb_val md_value;
+ struct drsuapi_DsReplicaObjMetaDataCtr mdc;
+ struct ldb_val guid_value;
+ NTTIME whenChanged = 0;
+ time_t whenChanged_t;
+ const char *whenChanged_s;
+ const char *rdn_name;
+ const struct ldb_val *rdn_value;
+ const struct dsdb_attribute *rdn_attr;
+ uint32_t rdn_attid;
+ struct drsuapi_DsReplicaAttribute *name_a;
+ struct drsuapi_DsReplicaMetaData *name_d;
+ struct replPropertyMetaData1 *rdn_m;
+ struct drsuapi_DsReplicaObjMetaData *rdn_mc;
+ int ret;
+
+ if (!obj->object.identifier) {
+ return WERR_FOOBAR;
+ }
+
+ if (!obj->object.identifier->dn || !obj->object.identifier->dn[0]) {
+ return WERR_FOOBAR;
+ }
msg = ldb_msg_new(mem_ctx);
W_ERROR_HAVE_NO_MEMORY(msg);
msg->dn = ldb_dn_new(msg, s->ldb, obj->object.identifier->dn);
W_ERROR_HAVE_NO_MEMORY(msg->dn);
+ rdn_name = ldb_dn_get_rdn_name(msg->dn);
+ rdn_attr = dsdb_attribute_by_lDAPDisplayName(s->schema, rdn_name);
+ if (!rdn_attr) {
+ return WERR_FOOBAR;
+ }
+ rdn_attid = rdn_attr->attributeID_id;
+ rdn_value = ldb_dn_get_rdn_val(msg->dn);
+
msg->num_elements = obj->object.attribute_ctr.num_attributes;
msg->elements = talloc_array(msg, struct ldb_message_element,
msg->num_elements);
W_ERROR_NOT_OK_RETURN(status);
}
+ if (obj->object.attribute_ctr.num_attributes != 0 && !obj->meta_data_ctr) {
+ return WERR_FOOBAR;
+ }
+
+ if (obj->object.attribute_ctr.num_attributes != obj->meta_data_ctr->count) {
+ return WERR_FOOBAR;
+ }
+
+ md.version = 1;
+ md.reserved = 0;
+ md.ctr.ctr1.count = obj->meta_data_ctr->count;
+ md.ctr.ctr1.reserved = 0;
+ md.ctr.ctr1.array = talloc_array(mem_ctx,
+ struct replPropertyMetaData1,
+ md.ctr.ctr1.count + 1);
+ W_ERROR_HAVE_NO_MEMORY(md.ctr.ctr1.array);
+
+ mdc.count = obj->meta_data_ctr->count;
+ mdc.reserved = 0;
+ mdc.array = talloc_array(mem_ctx,
+ struct drsuapi_DsReplicaObjMetaData,
+ mdc.count + 1);
+ W_ERROR_HAVE_NO_MEMORY(mdc.array);
+
+ for (i=0; i < obj->meta_data_ctr->count; i++) {
+ struct drsuapi_DsReplicaAttribute *a;
+ struct drsuapi_DsReplicaMetaData *d;
+ struct replPropertyMetaData1 *m;
+ struct drsuapi_DsReplicaObjMetaData *mc;
+
+ a = &obj->object.attribute_ctr.attributes[i];
+ d = &obj->meta_data_ctr->meta_data[i];
+ m = &md.ctr.ctr1.array[i];
+ mc = &mdc.array[i];
+
+ m->attid = a->attid;
+ m->version = d->version;
+ m->orginating_time = d->orginating_time;
+ m->orginating_invocation_id = d->orginating_invocation_id;
+ m->orginating_usn = d->orginating_usn;
+ m->local_usn = 0;
+
+ mc->attribute_name = dsdb_lDAPDisplayName_by_id(s->schema, a->attid);
+ mc->version = d->version;
+ mc->originating_last_changed = d->orginating_time;
+ mc->originating_dsa_invocation_id= d->orginating_invocation_id;
+ mc->originating_usn = d->orginating_usn;
+ mc->local_usn = 0;
+
+ if (d->orginating_time > whenChanged) {
+ whenChanged = d->orginating_time;
+ }
+
+ if (a->attid == DRSUAPI_ATTRIBUTE_name) {
+ name_a = a;
+ name_d = d;
+ rdn_m = &md.ctr.ctr1.array[md.ctr.ctr1.count];
+ rdn_mc = &mdc.array[mdc.count];
+ }
+ }
+
+ if (!name_d) {
+ return WERR_FOOBAR;
+ }
+
+ ret = ldb_msg_add_value(msg, rdn_attr->lDAPDisplayName, rdn_value, NULL);
+ if (ret != LDB_SUCCESS) {
+ return WERR_FOOBAR;
+ }
+
+ nt_status = ndr_push_struct_blob(&guid_value, msg, &obj->object.identifier->guid,
+ (ndr_push_flags_fn_t)ndr_push_GUID);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ return ntstatus_to_werror(nt_status);
+ }
+ ret = ldb_msg_add_value(msg, "objectGUID", &guid_value, NULL);
+ if (ret != LDB_SUCCESS) {
+ return WERR_FOOBAR;
+ }
+
+ whenChanged_t = nt_time_to_unix(whenChanged);
+ whenChanged_s = ldb_timestring(msg, whenChanged_t);
+ W_ERROR_HAVE_NO_MEMORY(whenChanged_s);
+ ret = ldb_msg_add_string(msg, "whenChanged", whenChanged_s);
+ if (ret != LDB_SUCCESS) {
+ return WERR_FOOBAR;
+ }
+
+ rdn_m->attid = rdn_attid;
+ rdn_m->version = name_d->version;
+ rdn_m->orginating_time = name_d->orginating_time;
+ rdn_m->orginating_invocation_id = name_d->orginating_invocation_id;
+ rdn_m->orginating_usn = name_d->orginating_usn;
+ rdn_m->local_usn = 0;
+ md.ctr.ctr1.count++;
+
+ rdn_mc->attribute_name = rdn_attr->lDAPDisplayName;
+ rdn_mc->version = name_d->version;
+ rdn_mc->originating_last_changed = name_d->orginating_time;
+ rdn_mc->originating_dsa_invocation_id = name_d->orginating_invocation_id;
+ rdn_mc->originating_usn = name_d->orginating_usn;
+ rdn_mc->local_usn = 0;
+ mdc.count++;
+
+ nt_status = ndr_push_struct_blob(&md_value, msg, &md,
+ (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
+ if (!NT_STATUS_IS_OK(nt_status)) {
+ return ntstatus_to_werror(nt_status);
+ }
+ ret = ldb_msg_add_value(msg, "replPropertyMetaData", &md_value, NULL);
+ if (ret != LDB_SUCCESS) {
+ return WERR_FOOBAR;
+ }
+
if (lp_parm_bool(-1, "become dc", "dump objects", False)) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
ldif.changetype = LDB_CHANGETYPE_NONE;
ldif.msg = msg;
ldb_ldif_write_file(s->ldb, stdout, &ldif);
+ NDR_PRINT_DEBUG(drsuapi_DsReplicaObjMetaDataCtr, &mdc);
+ }
+
+ ret = ldb_add(s->ldb, msg);
+ if (ret != LDB_SUCCESS) {
+ if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
+ DEBUG(0,("record exists (ignored): %s: %d\n",
+ obj->object.identifier->dn, ret));
+ } else {
+ DEBUG(0,("Failed to add record: %s: %d\n",
+ obj->object.identifier->dn, ret));
+ return WERR_FOOBAR;
+ }
}
*_msg = msg;
{
WERROR status;
struct drsuapi_DsReplicaObjectListItemEx *cur;
+ int ret;
for (cur = s->schema_part.first_object; cur; cur = cur->next_object) {
uint32_t i;
switch (a->attid) {
case DRSUAPI_ATTRIBUTE_objectClass:
- for (j=0; j < a->value_ctr.data_blob.num_values; j++) {
+ for (j=0; j < a->value_ctr.num_values; j++) {
uint32_t val = 0xFFFFFFFF;
- if (a->value_ctr.data_blob.values[i].data
- && a->value_ctr.data_blob.values[i].data->length == 4) {
- val = IVAL(a->value_ctr.data_blob.values[i].data->data,0);
+ if (a->value_ctr.values[i].blob
+ && a->value_ctr.values[i].blob->length == 4) {
+ val = IVAL(a->value_ctr.values[i].blob->data,0);
}
if (val == DRSUAPI_OBJECTCLASS_attributeSchema) {
}
}
+ ret = ldb_transaction_commit(s->ldb);
+ if (ret != LDB_SUCCESS) {
+ DEBUG(0,("Failed to commit the schema changes: %d\n", ret));
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ ret = ldb_transaction_start(s->ldb);
+ if (ret != LDB_SUCCESS) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
return NT_STATUS_OK;
}
uint32_t object_count;
struct drsuapi_DsReplicaObjectListItemEx *first_object;
struct drsuapi_DsReplicaObjectListItemEx *cur;
+ uint32_t linked_attributes_count;
+ struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
+ uint32_t i;
+ int ret;
switch (c->ctr_level) {
case 1:
total_object_count = c->ctr1->total_object_count;
object_count = c->ctr1->object_count;
first_object = c->ctr1->first_object;
+ linked_attributes_count = 0;
+ linked_attributes = NULL;
break;
case 6:
mapping_ctr = &c->ctr6->mapping_ctr;
total_object_count = c->ctr6->total_object_count;
object_count = c->ctr6->object_count;
first_object = c->ctr6->first_object;
+ linked_attributes_count = c->ctr6->linked_attributes_count;
+ linked_attributes = c->ctr6->linked_attributes;
break;
default:
return NT_STATUS_INVALID_PARAMETER;
}
}
+ for (i=0; i < linked_attributes_count; i++) {
+ const struct dsdb_attribute *sa;
+
+ if (!linked_attributes[i].identifier) {
+ return NT_STATUS_FOOBAR;
+ }
+
+ if (!linked_attributes[i].value.blob) {
+ return NT_STATUS_FOOBAR;
+ }
+
+ sa = dsdb_attribute_by_attributeID_id(s->schema,
+ linked_attributes[i].attid);
+ if (!sa) {
+ return NT_STATUS_FOOBAR;
+ }
+
+ if (lp_parm_bool(-1, "become dc", "dump objects", False)) {
+ DEBUG(0,("# %s\n", sa->lDAPDisplayName));
+ NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]);
+ dump_data(0,
+ linked_attributes[i].value.blob->data,
+ linked_attributes[i].value.blob->length);
+ }
+ }
+
+ ret = ldb_transaction_commit(s->ldb);
+ if (ret != LDB_SUCCESS) {
+ DEBUG(0,("Failed to commit the changes: %d\n", ret));
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
+ ret = ldb_transaction_start(s->ldb);
+ if (ret != LDB_SUCCESS) {
+ return NT_STATUS_INTERNAL_DB_CORRUPTION;
+ }
+
return NT_STATUS_OK;
}
git.samba.org / jra / samba / .git / blobdiff