summaryrefslogtreecommitdiff
path: root/source4
diff options
context:
space:
mode:
Diffstat (limited to 'source4')
-rw-r--r--source4/torture/drs/config.mk1
-rw-r--r--source4/torture/drs/drs_init.c2
-rw-r--r--source4/torture/drs/unit/schemainfo_tests.c579
3 files changed, 582 insertions, 0 deletions
diff --git a/source4/torture/drs/config.mk b/source4/torture/drs/config.mk
index 0ce3a3d17a..0fdeb97df1 100644
--- a/source4/torture/drs/config.mk
+++ b/source4/torture/drs/config.mk
@@ -19,6 +19,7 @@ PRIVATE_DEPENDENCIES = \
TORTURE_DRS_OBJ_FILES = \
$(torturesrcdir)/drs/drs_init.o \
$(torturesrcdir)/drs/drs_util.o \
+ $(torturesrcdir)/drs/unit/schemainfo_tests.o \
$(torturesrcdir)/drs/unit/prefixmap_tests.o
$(eval $(call proto_header_template,$(torturesrcdir)/drs/proto.h,$(TORTURE_DRS_OBJ_FILES:.o=.c)))
diff --git a/source4/torture/drs/drs_init.c b/source4/torture/drs/drs_init.c
index 081565fc57..35520ba54a 100644
--- a/source4/torture/drs/drs_init.c
+++ b/source4/torture/drs/drs_init.c
@@ -22,6 +22,7 @@
#include "includes.h"
#include "torture/smbtorture.h"
#include "torture/rpc/drsuapi.h"
+#include "dsdb/samdb/samdb.h"
#include "torture/drs/proto.h"
/**
@@ -46,6 +47,7 @@ static struct torture_suite * torture_drs_unit_suite(TALLOC_CTX *mem_ctx)
"UNIT");
torture_drs_unit_prefixmap(suite);
+ torture_drs_unit_schemainfo(suite);
return suite;
}
diff --git a/source4/torture/drs/unit/schemainfo_tests.c b/source4/torture/drs/unit/schemainfo_tests.c
new file mode 100644
index 0000000000..ab9de87f22
--- /dev/null
+++ b/source4/torture/drs/unit/schemainfo_tests.c
@@ -0,0 +1,579 @@
+/*
+ Unix SMB/CIFS implementation.
+
+ DRSUAPI schemaInfo unit tests
+
+ Copyright (C) Kamen Mazdrashki <kamenim@samba.org> 2010
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "system/filesys.h"
+#include "torture/smbtorture.h"
+#include "dsdb/samdb/samdb.h"
+#include "dsdb/samdb/ldb_modules/util.h"
+#include "lib/ldb_wrap.h"
+#include "lib/ldb/include/ldb_module.h"
+#include "torture/rpc/drsuapi.h"
+#include "librpc/ndr/libndr.h"
+#include "param/param.h"
+
+
+/**
+ * schemaInfo to init ldb context with
+ * Rev: 01
+ * GUID: 071c82fd-45c7-4351-a3db-51f75a630a7f
+ */
+#define SCHEMA_INFO_INIT_STR "FF0000000100000000000000000000000000000000"
+
+/**
+ * Default schema_info string to be used for testing
+ * Rev: 01
+ * GUID: 071c82fd-45c7-4351-a3db-51f75a630a7f
+ */
+#define SCHEMA_INFO_DEFAULT_STR "FF00000001FD821C07C7455143A3DB51F75A630A7F"
+
+/**
+ * Schema info data to test with
+ */
+struct schemainfo_data {
+ DATA_BLOB ndr_blob;
+ struct dsdb_schema_info schi;
+ WERROR werr_expected;
+ bool test_both_ways;
+};
+
+/**
+ * Schema info test data in human-readable format (... kind of)
+ */
+static const struct {
+ const char *schema_info_str;
+ uint32_t revision;
+ const char *guid_str;
+ WERROR werr_expected;
+ bool test_both_ways;
+} _schemainfo_test_data[] = {
+ {
+ .schema_info_str = "FF00000001FD821C07C7455143A3DB51F75A630A7F",
+ .revision = 1,
+ .guid_str = "071c82fd-45c7-4351-a3db-51f75a630a7f",
+ .werr_expected = WERR_OK,
+ .test_both_ways = true
+ },
+ {
+ .schema_info_str = "FFFFFFFFFFFD821C07C7455143A3DB51F75A630A7F",
+ .revision = 0xFFFFFFFF,
+ .guid_str = "071c82fd-45c7-4351-a3db-51f75a630a7f",
+ .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,
+ .guid_str = "071c82fd-45c7-4351-a3db-51f75a630a7f",
+ .werr_expected = WERR_INVALID_PARAMETER,
+ .test_both_ways = false
+ },
+ { /* marker == FF */
+ .schema_info_str = "AA00000001FD821C07C7455143A3DB51F75A630A7F",
+ .revision = 1,
+ .guid_str = "071c82fd-45c7-4351-a3db-51f75a630a7f",
+ .werr_expected = WERR_INVALID_PARAMETER,
+ .test_both_ways = false
+ }
+};
+
+/**
+ * Private data to be shared among all test in Test case
+ */
+struct drsut_schemainfo_data {
+ struct ldb_context *ldb;
+ struct ldb_module *ldb_module;
+ struct dsdb_schema *schema;
+
+ /* Initial schemaInfo set in ldb to test with */
+ struct dsdb_schema_info *schema_info;
+
+ uint32_t test_data_count;
+ struct schemainfo_data *test_data;
+};
+
+/**
+ * torture macro to assert for equal dsdb_schema_info's
+ */
+#define torture_assert_schema_info_equal(torture_ctx,got,expected,cmt)\
+ do { const struct dsdb_schema_info *__got = (got), *__expected = (expected); \
+ if (__got->revision != __expected->revision) { \
+ torture_result(torture_ctx, TORTURE_FAIL, \
+ __location__": "#got".revision %d did not match "#expected".revision %d: %s", \
+ (int)__got->revision, (int)__expected->revision, cmt); \
+ return false; \
+ } \
+ if (!GUID_equal(&__got->invocation_id, &__expected->invocation_id)) { \
+ torture_result(torture_ctx, TORTURE_FAIL, \
+ __location__": "#got".invocation_id did not match "#expected".invocation_id: %s", cmt); \
+ return false; \
+ } \
+ } while(0)
+
+/*
+ * forward declaration for internal functions
+ */
+static bool _drsut_ldb_schema_info_reset(struct torture_context *tctx,
+ struct ldb_context *ldb,
+ const char *schema_info_str,
+ bool in_setup);
+
+
+/**
+ * Creates dsdb_schema_info object based on NDR data
+ * passed as hex string
+ */
+static bool _drsut_schemainfo_new(struct torture_context *tctx,
+ const char *schema_info_str, struct dsdb_schema_info **_si)
+{
+ WERROR werr;
+ DATA_BLOB blob;
+
+ blob = strhex_to_data_blob(tctx, schema_info_str);
+ if (!blob.data) {
+ torture_comment(tctx, "Not enough memory!\n");
+ return false;
+ }
+
+ werr = dsdb_schema_info_from_blob(&blob, tctx, _si);
+ if (!W_ERROR_IS_OK(werr)) {
+ torture_comment(tctx,
+ "Failed to create dsdb_schema_info object for %s: %s",
+ schema_info_str,
+ win_errstr(werr));
+ return false;
+ }
+
+ data_blob_free(&blob);
+
+ return true;
+}
+
+/**
+ * Creates dsdb_schema_info object based on predefined data
+ * Function is public as it is intended to be used by other
+ * tests (e.g. prefixMap tests)
+ */
+bool drsut_schemainfo_new(struct torture_context *tctx, struct dsdb_schema_info **_si)
+{
+ return _drsut_schemainfo_new(tctx, SCHEMA_INFO_DEFAULT_STR, _si);
+}
+
+
+/*
+ * Tests dsdb_schema_info_from_blob()
+ */
+static bool test_dsdb_schema_info_from_blob(struct torture_context *tctx,
+ struct drsut_schemainfo_data *priv)
+{
+ int i;
+ WERROR werr;
+ char *msg;
+ struct dsdb_schema_info *schema_info;
+ TALLOC_CTX *mem_ctx;
+
+ mem_ctx = talloc_new(priv);
+ torture_assert(tctx, mem_ctx, "Not enough memory!");
+
+ for (i = 0; i < priv->test_data_count; i++) {
+ struct schemainfo_data *data = &priv->test_data[i];
+
+ msg = talloc_asprintf(tctx, "dsdb_schema_info_from_blob() [%d]-[%s]",
+ i, _schemainfo_test_data[i].schema_info_str);
+
+ werr = dsdb_schema_info_from_blob(&data->ndr_blob, mem_ctx, &schema_info);
+ torture_assert_werr_equal(tctx, werr, data->werr_expected, msg);
+
+ /* test returned data */
+ if (W_ERROR_IS_OK(werr)) {
+ torture_assert_schema_info_equal(tctx,
+ schema_info, &data->schi,
+ "after dsdb_schema_info_from_blob() call");
+ }
+ }
+
+ talloc_free(mem_ctx);
+
+ return true;
+}
+
+/*
+ * Tests dsdb_blob_from_schema_info()
+ */
+static bool test_dsdb_blob_from_schema_info(struct torture_context *tctx,
+ struct drsut_schemainfo_data *priv)
+{
+ int i;
+ WERROR werr;
+ char *msg;
+ DATA_BLOB ndr_blob;
+ TALLOC_CTX *mem_ctx;
+
+ mem_ctx = talloc_new(priv);
+ torture_assert(tctx, mem_ctx, "Not enough memory!");
+
+ for (i = 0; i < priv->test_data_count; i++) {
+ struct schemainfo_data *data = &priv->test_data[i];
+
+ /* not all test are valid reverse type of conversion */
+ if (!data->test_both_ways) {
+ continue;
+ }
+
+ msg = talloc_asprintf(tctx, "dsdb_blob_from_schema_info() [%d]-[%s]",
+ i, _schemainfo_test_data[i].schema_info_str);
+
+ werr = dsdb_blob_from_schema_info(&data->schi, mem_ctx, &ndr_blob);
+ torture_assert_werr_equal(tctx, werr, data->werr_expected, msg);
+
+ /* test returned data */
+ if (W_ERROR_IS_OK(werr)) {
+ torture_assert_data_blob_equal(tctx,
+ ndr_blob, data->ndr_blob,
+ "dsdb_blob_from_schema_info()");
+ }
+ }
+
+ talloc_free(mem_ctx);
+
+ 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;
+ DATA_BLOB blob_write;
+ DATA_BLOB blob_read;
+
+ /* reset schmeInfo to know value */
+ torture_assert(tctx,
+ _drsut_ldb_schema_info_reset(tctx, priv->ldb, SCHEMA_INFO_INIT_STR, false),
+ "_drsut_ldb_schema_info_reset() failed");
+
+ /* write tests' default schemaInfo */
+ 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");
+
+ 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");
+
+ /* check if we get what we wrote */
+ torture_assert_data_blob_equal(tctx, blob_read, blob_write,
+ "Write/Read of schemeInfo blob failed");
+
+ return true;
+}
+
+/*
+ * Tests dsdb_schema_update_schema_info()
+ */
+static bool test_dsdb_module_schema_info_update(struct torture_context *tctx,
+ struct drsut_schemainfo_data *priv)
+{
+ WERROR werr;
+ DATA_BLOB blob;
+ struct dsdb_schema_info *schema_info;
+
+ /* reset schmeInfo to know value */
+ torture_assert(tctx,
+ _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");
+
+ /* 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");
+
+ 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
+ */
+static bool _drsut_ldb_schema_info_reset(struct torture_context *tctx,
+ struct ldb_context *ldb,
+ const char *schema_info_str,
+ bool in_setup)
+{
+ bool bret = true;
+ int ldb_err;
+ DATA_BLOB blob;
+ struct ldb_message *msg;
+ TALLOC_CTX *mem_ctx = talloc_new(tctx);
+
+ blob = strhex_to_data_blob(mem_ctx, schema_info_str);
+ torture_assert_goto(tctx, blob.data, bret, DONE, "Not enough memory!");
+
+ msg = ldb_msg_new(mem_ctx);
+ torture_assert_goto(tctx, msg, bret, DONE, "Not enough memory!");
+
+ msg->dn = samdb_schema_dn(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");
+
+ if (in_setup) {
+ ldb_err = ldb_add(ldb, msg);
+ } else {
+ ldb_err = dsdb_replace(ldb, msg, DSDB_MODIFY_PERMISSIVE);
+ }
+ torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE,
+ "dsdb_replace() failed");
+
+DONE:
+ talloc_free(mem_ctx);
+ return bret;
+}
+
+/**
+ * Prepare temporary LDB and opens it
+ */
+static bool _drsut_ldb_setup(struct torture_context *tctx, struct drsut_schemainfo_data *priv)
+{
+ int ldb_err;
+ char *ldb_url;
+ bool bret = true;
+ char *tempdir = NULL;
+ NTSTATUS status;
+ TALLOC_CTX* mem_ctx;
+
+ mem_ctx = talloc_new(priv);
+ torture_assert(tctx, mem_ctx, "Not enough memory!");
+
+ status = torture_temp_dir(tctx, "drs_", &tempdir);
+ torture_assert_ntstatus_ok_goto(tctx, status, bret, DONE, "creating temp dir");
+
+ ldb_url = talloc_asprintf(priv, "%s/drs_schemainfo.ldb", tempdir);
+ torture_assert_goto(tctx, ldb_url, bret, DONE, "Not enough memory!");
+
+ /* create LDB */
+ priv->ldb = ldb_wrap_connect(priv, tctx->ev, tctx->lp_ctx,
+ ldb_url, NULL, NULL, 0);
+ torture_assert_goto(tctx, priv->ldb, bret, DONE, "ldb_wrap_connect() failed");
+
+ /* set some schemaNamingContext */
+ ldb_err = ldb_set_opaque(priv->ldb,
+ "schemaNamingContext",
+ ldb_dn_new(priv->ldb, priv->ldb, "CN=Schema,CN=Config"));
+ torture_assert_int_equal_goto(tctx, ldb_err, LDB_SUCCESS, bret, DONE,
+ "ldb_set_opaque() failed");
+
+ /* add schemaInfo attribute so tested layer could work properly */
+ torture_assert_goto(tctx,
+ _drsut_ldb_schema_info_reset(tctx, priv->ldb, SCHEMA_INFO_INIT_STR, true),
+ bret, DONE,
+ "_drsut_ldb_schema_info_reset() failed");
+
+DONE:
+ talloc_free(tempdir);
+ talloc_free(mem_ctx);
+ return bret;
+}
+
+/*
+ * Setup/Teardown for test case
+ */
+static bool torture_drs_unit_schemainfo_setup(struct torture_context *tctx,
+ struct drsut_schemainfo_data **_priv)
+{
+ int i;
+ int ldb_err;
+ NTSTATUS status;
+ DATA_BLOB ndr_blob;
+ struct GUID guid;
+ struct drsut_schemainfo_data *priv;
+
+ priv = talloc_zero(tctx, struct drsut_schemainfo_data);
+ torture_assert(tctx, priv, "Not enough memory!");
+
+ /* returned allocated pointer here
+ * teardown() will be called even in case of failure,
+ * so we'll get a changes to clean up */
+ *_priv = priv;
+
+ /* create initial schemaInfo */
+ torture_assert(tctx,
+ _drsut_schemainfo_new(tctx, SCHEMA_INFO_DEFAULT_STR, &priv->schema_info),
+ "Failed to create schema_info test object");
+
+ /* create data to test with */
+ priv->test_data_count = ARRAY_SIZE(_schemainfo_test_data);
+ priv->test_data = talloc_array(tctx, struct schemainfo_data, priv->test_data_count);
+
+ for (i = 0; i < ARRAY_SIZE(_schemainfo_test_data); i++) {
+ struct schemainfo_data *data = &priv->test_data[i];
+
+ ndr_blob = strhex_to_data_blob(priv,
+ _schemainfo_test_data[i].schema_info_str);
+ torture_assert(tctx, ndr_blob.data, "Not enough memory!");
+
+ status = GUID_from_string(_schemainfo_test_data[i].guid_str, &guid);
+ torture_assert_ntstatus_ok(tctx, status,
+ talloc_asprintf(tctx,
+ "GUID_from_string() failed for %s",
+ _schemainfo_test_data[i].guid_str));
+
+ data->ndr_blob = ndr_blob;
+ data->schi.invocation_id = guid;
+ data->schi.revision = _schemainfo_test_data[i].revision;
+ data->werr_expected = _schemainfo_test_data[i].werr_expected;
+ data->test_both_ways = _schemainfo_test_data[i].test_both_ways;
+
+ }
+
+ /* create temporary LDB and populate with data */
+ if (!_drsut_ldb_setup(tctx, priv)) {
+ return false;
+ }
+
+ /* create ldb_module mockup object */
+ priv->ldb_module = ldb_module_new(priv, priv->ldb, "schemaInfo_test_module", NULL);
+ 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));
+
+ /* pre-cache invocationId for samdb_ntds_invocation_id()
+ * to work with our mock ldb */
+ ldb_err = ldb_set_opaque(priv->ldb, "cache.invocation_id",
+ &priv->schema_info->invocation_id);
+ torture_assert_int_equal(tctx, ldb_err, LDB_SUCCESS, "ldb_set_opaque() failed");
+
+ /* Perform all tests in transactions so that
+ * underlying modify calls not to fail */
+ ldb_err = ldb_transaction_start(priv->ldb);
+ torture_assert_int_equal(tctx,
+ ldb_err,
+ LDB_SUCCESS,
+ "ldb_transaction_start() failed");
+
+ return true;
+}
+
+static bool torture_drs_unit_schemainfo_teardown(struct torture_context *tctx,
+ struct drsut_schemainfo_data *priv)
+{
+ int ldb_err;
+
+ /* commit pending transaction so we will
+ * be able to check what LDB state is */
+ ldb_err = ldb_transaction_commit(priv->ldb);
+ if (ldb_err != LDB_SUCCESS) {
+ torture_comment(tctx, "ldb_transaction_commit() - %s (%s)",
+ ldb_strerror(ldb_err),
+ ldb_errstring(priv->ldb));
+ }
+
+ talloc_free(priv);
+
+ return true;
+}
+
+/**
+ * Test case initialization for
+ * DRS-UNIT.schemaInfo
+ */
+struct torture_tcase * torture_drs_unit_schemainfo(struct torture_suite *suite)
+{
+ typedef bool (*pfn_setup)(struct torture_context *, void **);
+ typedef bool (*pfn_teardown)(struct torture_context *, void *);
+ typedef bool (*pfn_run)(struct torture_context *, void *);
+
+ struct torture_tcase * tc = torture_suite_add_tcase(suite, "schemaInfo");
+
+ torture_tcase_set_fixture(tc,
+ (pfn_setup)torture_drs_unit_schemainfo_setup,
+ (pfn_teardown)torture_drs_unit_schemainfo_teardown);
+
+ tc->description = talloc_strdup(tc, "Unit tests for DRSUAPI::schemaInfo implementation");
+
+ 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_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);
+
+
+ return tc;
+}
generated by cgit (git 2.34.1) at 2024-11-24 19:58:38 +0000