#include "torture/smbtorture.h"
#include "dsdb/samdb/samdb.h"
#include "dsdb/samdb/ldb_modules/util.h"
-#include "lib/ldb_wrap.h"
+#include "ldb_wrap.h"
#include "lib/ldb/include/ldb_module.h"
#include "torture/rpc/drsuapi.h"
#include "librpc/ndr/libndr.h"
/**
* schemaInfo to init ldb context with
- * Rev: 01
- * GUID: 071c82fd-45c7-4351-a3db-51f75a630a7f
+ * Rev: 0
+ * GUID: 00000000-0000-0000-0000-000000000000
*/
-#define SCHEMA_INFO_INIT_STR "FF0000000100000000000000000000000000000000"
+#define SCHEMA_INFO_INIT_STR "FF0000000000000000000000000000000000000000"
/**
* Default schema_info string to be used for testing
WERROR werr_expected;
bool test_both_ways;
} _schemainfo_test_data[] = {
+ {
+ .schema_info_str = "FF0000000000000000000000000000000000000000",
+ .revision = 0,
+ .guid_str = "00000000-0000-0000-0000-000000000000",
+ .werr_expected = WERR_OK,
+ .test_both_ways = true
+ },
{
.schema_info_str = "FF00000001FD821C07C7455143A3DB51F75A630A7F",
.revision = 1,
.werr_expected = WERR_OK,
.test_both_ways = true
},
- { /* revision > 0 */
- .schema_info_str = "FF00000000FD821C07C7455143A3DB51F75A630A7F",
- .revision = 0,
- .guid_str = "071c82fd-45c7-4351-a3db-51f75a630a7f",
- .werr_expected = WERR_INVALID_PARAMETER,
- .test_both_ways = true
- },
{ /* len == 21 */
.schema_info_str = "FF00000001FD821C07C7455143A3DB51F75A630A7F00",
.revision = 1,
}
+/*
+ * Tests dsdb_schema_info_new() and dsdb_schema_info_blob_new()
+ */
+static bool test_dsdb_schema_info_new(struct torture_context *tctx,
+ struct drsut_schemainfo_data *priv)
+{
+ WERROR werr;
+ DATA_BLOB ndr_blob;
+ DATA_BLOB ndr_blob_expected;
+ struct dsdb_schema_info *schi;
+ TALLOC_CTX *mem_ctx;
+
+ mem_ctx = talloc_new(priv);
+ torture_assert(tctx, mem_ctx, "Not enough memory!");
+ ndr_blob_expected = strhex_to_data_blob(mem_ctx, SCHEMA_INFO_INIT_STR);
+ torture_assert(tctx, ndr_blob_expected.data, "Not enough memory!");
+
+ werr = dsdb_schema_info_new(mem_ctx, &schi);
+ torture_assert_werr_ok(tctx, werr, "dsdb_schema_info_new() failed");
+ torture_assert_int_equal(tctx, schi->revision, 0,
+ "dsdb_schema_info_new() creates schemaInfo with invalid revision");
+ torture_assert(tctx, GUID_all_zero(&schi->invocation_id),
+ "dsdb_schema_info_new() creates schemaInfo with not ZERO GUID");
+
+ werr = dsdb_schema_info_blob_new(mem_ctx, &ndr_blob);
+ torture_assert_werr_ok(tctx, werr, "dsdb_schema_info_blob_new() failed");
+ torture_assert_data_blob_equal(tctx, ndr_blob, ndr_blob_expected,
+ "dsdb_schema_info_blob_new() returned invalid blob");
+
+ talloc_free(mem_ctx);
+ return true;
+}
+
/*
* Tests dsdb_schema_info_from_blob()
*/
return true;
}
+static bool test_dsdb_schema_info_cmp(struct torture_context *tctx,
+ struct drsut_schemainfo_data *priv)
+{
+ DATA_BLOB blob;
+ struct drsuapi_DsReplicaOIDMapping_Ctr *ctr;
+
+ ctr = talloc_zero(priv, struct drsuapi_DsReplicaOIDMapping_Ctr);
+ torture_assert(tctx, ctr, "Not enough memory!");
+
+ /* not enough elements */
+ torture_assert_werr_equal(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ WERR_INVALID_PARAMETER,
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ /* an empty element for schemaInfo */
+ ctr->num_mappings = 1;
+ ctr->mappings = talloc_zero_array(ctr, struct drsuapi_DsReplicaOIDMapping, 1);
+ torture_assert(tctx, ctr->mappings, "Not enough memory!");
+ torture_assert_werr_equal(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ WERR_INVALID_PARAMETER,
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ /* test with invalid schemaInfo - length != 21 */
+ blob = strhex_to_data_blob(ctr, "FF00000001FD821C07C7455143A3DB51F75A630A7F00");
+ torture_assert(tctx, blob.data, "Not enough memory!");
+ ctr->mappings[0].oid.length = blob.length;
+ ctr->mappings[0].oid.binary_oid = blob.data;
+ torture_assert_werr_equal(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ WERR_INVALID_PARAMETER,
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ /* test with invalid schemaInfo - marker != 0xFF */
+ blob = strhex_to_data_blob(ctr, "AA00000001FD821C07C7455143A3DB51F75A630A7F");
+ torture_assert(tctx, blob.data, "Not enough memory!");
+ ctr->mappings[0].oid.length = blob.length;
+ ctr->mappings[0].oid.binary_oid = blob.data;
+ torture_assert_werr_equal(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ WERR_INVALID_PARAMETER,
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ /* test with valid schemaInfo, but not correct one */
+ blob = strhex_to_data_blob(ctr, "FF0000000000000000000000000000000000000000");
+ torture_assert(tctx, blob.data, "Not enough memory!");
+ ctr->mappings[0].oid.length = blob.length;
+ ctr->mappings[0].oid.binary_oid = blob.data;
+ torture_assert_werr_equal(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ WERR_DS_DRA_SCHEMA_MISMATCH,
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ /* test with correct schemaInfo, but invalid ATTID */
+ blob = strhex_to_data_blob(ctr, priv->schema->schema_info);
+ torture_assert(tctx, blob.data, "Not enough memory!");
+ ctr->mappings[0].id_prefix = 1;
+ ctr->mappings[0].oid.length = blob.length;
+ ctr->mappings[0].oid.binary_oid = blob.data;
+ torture_assert_werr_equal(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ WERR_INVALID_PARAMETER,
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ /* test with valid schemaInfo */
+ blob = strhex_to_data_blob(ctr, priv->schema->schema_info);
+ ctr->mappings[0].id_prefix = 0;
+ torture_assert_werr_ok(tctx,
+ dsdb_schema_info_cmp(priv->schema, ctr),
+ "dsdb_schema_info_cmp(): unexpected result");
+
+ talloc_free(ctr);
+ return true;
+}
+
/*
* Tests dsdb_module_schema_info_blob_read()
* and dsdb_module_schema_info_blob_write()
static bool test_dsdb_module_schema_info_blob_rw(struct torture_context *tctx,
struct drsut_schemainfo_data *priv)
{
- WERROR werr;
+ int ldb_err;
DATA_BLOB blob_write;
DATA_BLOB blob_read;
blob_write = strhex_to_data_blob(priv, SCHEMA_INFO_DEFAULT_STR);
torture_assert(tctx, blob_write.data, "Not enough memory!");
- werr = dsdb_module_schema_info_blob_write(priv->ldb_module,
- DSDB_FLAG_TOP_MODULE,
- &blob_write);
- torture_assert_werr_ok(tctx, werr, "dsdb_module_schema_info_blob_write() failed");
+ ldb_err = dsdb_module_schema_info_blob_write(priv->ldb_module,
+ DSDB_FLAG_TOP_MODULE,
+ &blob_write, NULL);
+ torture_assert_int_equal(tctx, ldb_err, LDB_SUCCESS, "dsdb_module_schema_info_blob_write() failed");
- werr = dsdb_module_schema_info_blob_read(priv->ldb_module, DSDB_FLAG_TOP_MODULE,
- priv, &blob_read);
- torture_assert_werr_ok(tctx, werr, "dsdb_module_schema_info_blob_read() failed");
+ ldb_err = dsdb_module_schema_info_blob_read(priv->ldb_module, DSDB_FLAG_TOP_MODULE,
+ priv, &blob_read, NULL);
+ torture_assert_int_equal(tctx, ldb_err, LDB_SUCCESS, "dsdb_module_schema_info_blob_read() failed");
/* check if we get what we wrote */
torture_assert_data_blob_equal(tctx, blob_read, blob_write,
static bool test_dsdb_module_schema_info_update(struct torture_context *tctx,
struct drsut_schemainfo_data *priv)
{
+ int ldb_err;
WERROR werr;
DATA_BLOB blob;
struct dsdb_schema_info *schema_info;
_drsut_ldb_schema_info_reset(tctx, priv->ldb, SCHEMA_INFO_INIT_STR, false),
"_drsut_ldb_schema_info_reset() failed");
- werr = dsdb_module_schema_info_update(priv->ldb_module,
- priv->schema,
- DSDB_FLAG_TOP_MODULE | DSDB_FLAG_AS_SYSTEM);
- torture_assert_werr_ok(tctx, werr, "dsdb_module_schema_info_update() failed");
+ ldb_err = dsdb_module_schema_info_update(priv->ldb_module,
+ priv->schema,
+ DSDB_FLAG_TOP_MODULE | DSDB_FLAG_AS_SYSTEM, NULL);
+ torture_assert_int_equal(tctx, ldb_err, LDB_SUCCESS, "dsdb_module_schema_info_update() failed");
/* get updated schemaInfo */
- werr = dsdb_module_schema_info_blob_read(priv->ldb_module, DSDB_FLAG_TOP_MODULE,
- priv, &blob);
- torture_assert_werr_ok(tctx, werr, "dsdb_module_schema_info_blob_read() failed");
+ ldb_err = dsdb_module_schema_info_blob_read(priv->ldb_module, DSDB_FLAG_TOP_MODULE,
+ priv, &blob, NULL);
+ torture_assert_int_equal(tctx, ldb_err, LDB_SUCCESS, "dsdb_module_schema_info_blob_read() failed");
werr = dsdb_schema_info_from_blob(&blob, priv, &schema_info);
torture_assert_werr_ok(tctx, werr, "dsdb_schema_info_from_blob() failed");
- /* decrement revision to be able to compare
- * against default schemaInfo later */
- schema_info->revision--;
-
/* check against default schema_info */
torture_assert_schema_info_equal(tctx, schema_info, priv->schema_info,
"schemaInfo attribute no updated correctly");
return true;
}
-/*
- * Tests dsdb_schema_info_create()
- */
-static bool test_dsdb_schema_info_create(struct torture_context *tctx,
- struct drsut_schemainfo_data *priv)
-{
- WERROR werr;
- struct dsdb_schema_info *schema_info = NULL;
-
- werr = dsdb_schema_info_create(priv->ldb, priv, &schema_info);
- torture_assert_werr_ok(tctx, werr, "dsdb_schema_info_create() failed");
-
- torture_assert(tctx, schema_info, "schema_info is NULL after dsdb_schema_info_create()");
- torture_assert_int_equal(tctx, schema_info->revision, 1, "Invalid schemaInfo revision");
- torture_assert(tctx,
- GUID_equal(&schema_info->invocation_id, &priv->schema_info->invocation_id),
- "Invalid invocationId returned");
-
- talloc_free(schema_info);
-
- return true;
-}
-
/**
* Reset schemaInfo record to know value
msg = ldb_msg_new(mem_ctx);
torture_assert_goto(tctx, msg, bret, DONE, "Not enough memory!");
- msg->dn = samdb_schema_dn(ldb);
+ msg->dn = ldb_get_schema_basedn(ldb);
ldb_err = ldb_msg_add_value(msg, "schemaInfo", &blob, NULL);
torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE,
"ldb_msg_add_value() failed");
torture_assert(tctx, priv->ldb_module, "Not enough memory!");
/* create schema mockup object */
- priv->schema = dsdb_new_schema(priv, lp_iconv_convenience(tctx->lp_ctx));
+ priv->schema = dsdb_new_schema(priv);
+
+ /* set schema_info in dsdb_schema for testing */
+ priv->schema->schema_info = talloc_strdup(priv->schema, SCHEMA_INFO_DEFAULT_STR);
/* pre-cache invocationId for samdb_ntds_invocation_id()
* to work with our mock ldb */
/**
* Test case initialization for
- * DRS-UNIT.schemaInfo
+ * drs.unit.schemaInfo
*/
struct torture_tcase * torture_drs_unit_schemainfo(struct torture_suite *suite)
{
tc->description = talloc_strdup(tc, "Unit tests for DRSUAPI::schemaInfo implementation");
+ torture_tcase_add_simple_test(tc, "dsdb_schema_info_new",
+ (pfn_run)test_dsdb_schema_info_new);
torture_tcase_add_simple_test(tc, "dsdb_schema_info_from_blob",
(pfn_run)test_dsdb_schema_info_from_blob);
torture_tcase_add_simple_test(tc, "dsdb_blob_from_schema_info",
(pfn_run)test_dsdb_blob_from_schema_info);
+ torture_tcase_add_simple_test(tc, "dsdb_schema_info_cmp",
+ (pfn_run)test_dsdb_schema_info_cmp);
torture_tcase_add_simple_test(tc, "dsdb_module_schema_info_blob read|write",
(pfn_run)test_dsdb_module_schema_info_blob_rw);
- torture_tcase_add_simple_test(tc, "dsdb_schema_info_create",
- (pfn_run)test_dsdb_schema_info_create);
torture_tcase_add_simple_test(tc, "dsdb_module_schema_info_update",
(pfn_run)test_dsdb_module_schema_info_update);
git.samba.org / samba.git / blobdiff