Mimir, please check.
Guenther
#define TEST_GROUPNAME "libnetgroupinfotest"
-static bool test_groupinfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_groupinfo(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle,
struct dom_sid2 *domain_sid, const char* group_name,
uint32_t *rid)
group.in.sid = dom_sid_string(mem_ctx, group_sid);
group.in.level = level; /* this should be extended */
- printf("Testing sync libnet_rpc_groupinfo (SID argument)\n");
+ torture_comment(tctx, "Testing sync libnet_rpc_groupinfo (SID argument)\n");
status = libnet_rpc_groupinfo(p, mem_ctx, &group);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
return false;
}
printf("Testing sync libnet_rpc_groupinfo (groupname argument)\n");
status = libnet_rpc_groupinfo(p, mem_ctx, &group);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to call sync libnet_rpc_groupinfo - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Failed to call sync libnet_rpc_groupinfo - %s\n", nt_errstr(status));
return false;
}
goto done;
}
- if (!test_group_create(b, mem_ctx, &h, TEST_GROUPNAME, &rid)) {
+ if (!test_group_create(torture, b, mem_ctx, &h, TEST_GROUPNAME, &rid)) {
ret = false;
goto done;
}
- if (!test_groupinfo(p, mem_ctx, &h, &sid, TEST_GROUPNAME, &rid)) {
+ if (!test_groupinfo(torture, p, mem_ctx, &h, &sid, TEST_GROUPNAME, &rid)) {
ret = false;
goto done;
}
- if (!test_group_cleanup(b, mem_ctx, &h, TEST_GROUPNAME)) {
+ if (!test_group_cleanup(torture, b, mem_ctx, &h, TEST_GROUPNAME)) {
ret = false;
goto done;
}
goto done;
}
- if (!test_group_cleanup(b, mem_ctx, &h, name)) {
+ if (!test_group_cleanup(torture, b, mem_ctx, &h, name)) {
ret = false;
goto done;
}
#include "param/param.h"
-static bool test_opendomain_samr(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_opendomain_samr(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, struct lsa_String *domname,
uint32_t *access_mask, struct dom_sid **sid_p)
{
struct dom_sid2 *sid = NULL;
struct samr_OpenDomain r3;
- printf("connecting\n");
+ torture_comment(tctx, "connecting\n");
*access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
status = dcerpc_samr_Connect_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("Connect failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Connect failed - %s\n", nt_errstr(status));
return false;
}
r2.in.domain_name = domname;
r2.out.sid = &sid;
- printf("domain lookup on %s\n", domname->string);
+ torture_comment(tctx, "domain lookup on %s\n", domname->string);
status = dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("LookupDomain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "LookupDomain failed - %s\n", nt_errstr(status));
return false;
}
r3.in.sid = *sid_p = *r2.out.sid;
r3.out.domain_handle = &domain_handle;
- printf("opening domain\n");
+ torture_comment(tctx, "opening domain\n");
status = dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
- printf("OpenDomain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "OpenDomain failed - %s\n", nt_errstr(status));
return false;
} else {
*handle = domain_handle;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
if (ctx == NULL) {
- d_printf("failed to create libnet context\n");
+ torture_comment(torture, "failed to create libnet context\n");
return false;
}
status = libnet_DomainOpen(ctx, torture, &r);
if (!NT_STATUS_IS_OK(status)) {
- d_printf("failed to open domain on lsa service: %s\n", nt_errstr(status));
+ torture_comment(torture, "failed to open domain on lsa service: %s\n", nt_errstr(status));
ret = false;
goto done;
}
status = dcerpc_lsa_Close_r(ctx->lsa.pipe->binding_handle, ctx, &lsa_close);
if (!NT_STATUS_IS_OK(status)) {
- d_printf("failed to close domain on lsa service: %s\n", nt_errstr(status));
+ torture_comment(torture, "failed to close domain on lsa service: %s\n", nt_errstr(status));
ret = false;
}
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
if (ctx == NULL) {
- d_printf("failed to create libnet context\n");
+ torture_comment(torture, "failed to create libnet context\n");
ret = false;
goto done;
}
status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_lsarpc,
cmdline_credentials, torture->ev, torture->lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
- d_printf("failed to connect to server: %s\n", nt_errstr(status));
+ torture_comment(torture, "failed to connect to server: %s\n", nt_errstr(status));
ret = false;
goto done;
}
domain_name.string = lp_workgroup(torture->lp_ctx);
if (!test_opendomain_lsa(p->binding_handle, torture, &h, &domain_name, &access_mask)) {
- d_printf("failed to open domain on lsa service\n");
+ torture_comment(torture, "failed to open domain on lsa service\n");
ret = false;
goto done;
}
/*
* Testing synchronous version
*/
- printf("opening domain\n");
+ torture_comment(torture, "opening domain\n");
io.in.type = DOMAIN_SAMR;
io.in.domain_name = domain_name;
status = libnet_DomainOpen(ctx, mem_ctx, &io);
if (!NT_STATUS_IS_OK(status)) {
- printf("Composite domain open failed - %s\n", nt_errstr(status));
+ torture_comment(torture, "Composite domain open failed - %s\n", nt_errstr(status));
ret = false;
goto done;
}
r.in.handle = &domain_handle;
r.out.handle = &handle;
- printf("closing domain handle\n");
+ torture_comment(torture, "closing domain handle\n");
status = dcerpc_samr_Close_r(ctx->samr.pipe->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("Close failed - %s\n", nt_errstr(status));
+ torture_comment(torture, "Close failed - %s\n", nt_errstr(status));
ret = false;
goto done;
}
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
if (ctx == NULL) {
- d_printf("failed to create libnet context\n");
+ torture_comment(torture, "failed to create libnet context\n");
ret = false;
goto done;
}
status = dcerpc_pipe_connect_b(mem_ctx, &p, binding, &ndr_table_samr,
ctx->cred, torture->ev, torture->lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
- d_printf("failed to connect to server: %s\n", nt_errstr(status));
+ torture_comment(torture, "failed to connect to server: %s\n", nt_errstr(status));
ret = false;
goto done;
}
domain_name.string = talloc_strdup(mem_ctx, lp_workgroup(torture->lp_ctx));
- if (!test_opendomain_samr(p->binding_handle, torture, &h, &domain_name, &access_mask, &sid)) {
- d_printf("failed to open domain on samr service\n");
+ if (!test_opendomain_samr(torture, p->binding_handle, torture, &h, &domain_name, &access_mask, &sid)) {
+ torture_comment(torture, "failed to open domain on samr service\n");
ret = false;
goto done;
}
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
if (ctx == NULL) {
- d_printf("failed to create libnet context\n");
+ torture_comment(torture, "failed to create libnet context\n");
ret = false;
goto done;
}
goto done;
}
- d_printf("Received list or domains (everything in one piece):\n");
+ torture_comment(torture, "Received list or domains (everything in one piece):\n");
for (i = 0; i < r.out.count; i++) {
- d_printf("Name[%d]: %s\n", i, r.out.domains[i].name);
+ torture_comment(torture, "Name[%d]: %s\n", i, r.out.domains[i].name);
}
/*
goto done;
}
- d_printf("Received list or domains (collected in more than one round):\n");
+ torture_comment(torture, "Received list or domains (collected in more than one round):\n");
for (i = 0; i < r.out.count; i++) {
- d_printf("Name[%d]: %s\n", i, r.out.domains[i].name);
+ torture_comment(torture, "Name[%d]: %s\n", i, r.out.domains[i].name);
}
done:
- d_printf("\nStatus: %s\n", nt_errstr(status));
+ torture_comment(torture, "\nStatus: %s\n", nt_errstr(status));
talloc_free(mem_ctx);
talloc_free(ctx);
#define TEST_GROUPNAME "libnetgrouptest"
-static bool test_cleanup(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_cleanup(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle, const char *groupname)
{
NTSTATUS status;
r1.out.rids = &rids;
r1.out.types = &types;
- printf("group account lookup '%s'\n", groupname);
+ torture_comment(tctx, "group account lookup '%s'\n", groupname);
status = dcerpc_samr_LookupNames_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("LookupNames failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "LookupNames failed - %s\n", nt_errstr(status));
return false;
}
r2.in.rid = rid;
r2.out.group_handle = &group_handle;
- printf("opening group account\n");
+ torture_comment(tctx, "opening group account\n");
status = dcerpc_samr_OpenGroup_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("OpenGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "OpenGroup failed - %s\n", nt_errstr(status));
return false;
}
r3.in.group_handle = &group_handle;
r3.out.group_handle = &group_handle;
- printf("deleting group account\n");
+ torture_comment(tctx, "deleting group account\n");
status = dcerpc_samr_DeleteDomainGroup_r(b, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
- printf("DeleteGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "DeleteGroup failed - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_creategroup(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_creategroup(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, const char *name)
{
NTSTATUS status;
r.out.group_handle = &group_handle;
r.out.rid = &group_rid;
- printf("creating group account %s\n", name);
+ torture_comment(tctx, "creating group account %s\n", name);
status = dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateGroup failed - %s\n", nt_errstr(status));
if (NT_STATUS_EQUAL(status, NT_STATUS_GROUP_EXISTS)) {
- printf("Group (%s) already exists - attempting to delete and recreate group again\n", name);
- if (!test_cleanup(b, mem_ctx, handle, TEST_GROUPNAME)) {
+ torture_comment(tctx, "Group (%s) already exists - attempting to delete and recreate group again\n", name);
+ if (!test_cleanup(tctx, b, mem_ctx, handle, TEST_GROUPNAME)) {
return false;
}
- printf("creating group account\n");
+ torture_comment(tctx, "creating group account\n");
status = dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateGroup failed - %s\n", nt_errstr(status));
return false;
}
return true;
}
-static bool test_opendomain(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_opendomain(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, struct lsa_String *domname)
{
NTSTATUS status;
struct dom_sid2 *sid = NULL;
struct samr_OpenDomain r3;
- printf("connecting\n");
+ torture_comment(tctx, "connecting\n");
r1.in.system_name = 0;
r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
status = dcerpc_samr_Connect_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("Connect failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Connect failed - %s\n", nt_errstr(status));
return false;
}
r2.in.domain_name = domname;
r2.out.sid = &sid;
- printf("domain lookup on %s\n", domname->string);
+ torture_comment(tctx, "domain lookup on %s\n", domname->string);
status = dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("LookupDomain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "LookupDomain failed - %s\n", nt_errstr(status));
return false;
}
r3.in.sid = *r2.out.sid;
r3.out.domain_handle = &domain_handle;
- printf("opening domain\n");
+ torture_comment(tctx, "opening domain\n");
status = dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
- printf("OpenDomain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "OpenDomain failed - %s\n", nt_errstr(status));
return false;
} else {
*handle = domain_handle;
}
-static bool test_samr_close(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_samr_close(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle)
{
NTSTATUS status;
status = dcerpc_samr_Close_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("Close samr domain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Close samr domain failed - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_lsa_close(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_lsa_close(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle)
{
NTSTATUS status;
status = dcerpc_lsa_Close_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("Close lsa domain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Close lsa domain failed - %s\n", nt_errstr(status));
return false;
}
}
domain_name.string = lp_workgroup(torture->lp_ctx);
- if (!test_opendomain(p->binding_handle, prep_mem_ctx, &h, &domain_name)) {
+ if (!test_opendomain(torture, p->binding_handle, prep_mem_ctx, &h, &domain_name)) {
ret = false;
goto done;
}
- if (!test_creategroup(p->binding_handle, prep_mem_ctx, &h, name)) {
+ if (!test_creategroup(torture, p->binding_handle, prep_mem_ctx, &h, name)) {
ret = false;
goto done;
}
status = libnet_GroupInfo(ctx, mem_ctx, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_GroupInfo call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_GroupInfo call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
- if (!test_cleanup(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
- printf("cleanup failed\n");
+ if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
+ torture_comment(torture, "cleanup failed\n");
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
- printf("domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+ torture_comment(torture, "domain close failed\n");
ret = false;
}
ZERO_STRUCT(req);
- printf("listing group accounts:\n");
+ torture_comment(torture, "listing group accounts:\n");
do {
req.in.domain_name = domain_name.string;
!NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) break;
for (i = 0; i < req.out.count; i++) {
- printf("\tgroup: %s, sid=%s\n",
+ torture_comment(torture, "\tgroup: %s, sid=%s\n",
req.out.groups[i].groupname, req.out.groups[i].sid);
}
if (!(NT_STATUS_IS_OK(status) ||
NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))) {
- printf("libnet_GroupList call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_GroupList call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
- printf("domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+ torture_comment(torture, "domain close failed\n");
ret = false;
}
- if (!test_lsa_close(ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
- printf("lsa domain close failed\n");
+ if (!test_lsa_close(torture, ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
+ torture_comment(torture, "lsa domain close failed\n");
ret = false;
}
status = libnet_CreateGroup(ctx, mem_ctx, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_CreateGroup call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_CreateGroup call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
- if (!test_cleanup(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
- printf("cleanup failed\n");
+ if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_GROUPNAME)) {
+ torture_comment(torture, "cleanup failed\n");
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
- printf("domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+ torture_comment(torture, "domain close failed\n");
ret = false;
}
status = libnet_Lookup(ctx, mem_ctx, &lookup);
if (!NT_STATUS_IS_OK(status)) {
- printf("Couldn't lookup name %s: %s\n", lookup.in.hostname, nt_errstr(status));
+ torture_comment(torture, "Couldn't lookup name %s: %s\n", lookup.in.hostname, nt_errstr(status));
ret = false;
goto done;
}
ret = true;
- printf("Name [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
+ torture_comment(torture, "Name [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
done:
talloc_free(mem_ctx);
status = libnet_LookupHost(ctx, mem_ctx, &lookup);
if (!NT_STATUS_IS_OK(status)) {
- printf("Couldn't lookup host %s: %s\n", lookup.in.hostname, nt_errstr(status));
+ torture_comment(torture, "Couldn't lookup host %s: %s\n", lookup.in.hostname, nt_errstr(status));
ret = false;
goto done;
}
ret = true;
- printf("Host [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
+ torture_comment(torture, "Host [%s] found at address: %s.\n", lookup.in.hostname, *lookup.out.address);
done:
talloc_free(mem_ctx);
status = libnet_LookupDCs(ctx, mem_ctx, lookup);
if (!NT_STATUS_IS_OK(status)) {
- printf("Couldn't lookup pdc %s: %s\n", lookup->in.domain_name,
+ torture_comment(torture, "Couldn't lookup pdc %s: %s\n", lookup->in.domain_name,
nt_errstr(status));
ret = false;
goto done;
ret = true;
- printf("DCs of domain [%s] found.\n", lookup->in.domain_name);
+ torture_comment(torture, "DCs of domain [%s] found.\n", lookup->in.domain_name);
for (i = 0; i < lookup->out.num_dcs; i++) {
- printf("\tDC[%d]: name=%s, address=%s\n", i, lookup->out.dcs[i].name,
+ torture_comment(torture, "\tDC[%d]: name=%s, address=%s\n", i, lookup->out.dcs[i].name,
lookup->out.dcs[i].address);
}
#include "param/param.h"
-static bool test_connect_service(struct libnet_context *ctx,
+static bool test_connect_service(struct torture_context *tctx,
+ struct libnet_context *ctx,
const struct ndr_interface_table *iface,
const char *binding_string,
const char *hostname,
status = libnet_RpcConnect(ctx, ctx, &connect_r);
if (!NT_STATUS_EQUAL(status, expected_status)) {
- d_printf("Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
+ torture_comment(tctx, "Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
"Received: %s\n",
connect_r.in.dcerpc_iface->name, connect_r.in.binding, nt_errstr(expected_status),
nt_errstr(status));
return false;
}
- d_printf("PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
+ torture_comment(tctx, "PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
nt_errstr(status));
if (connect_r.level == LIBNET_RPC_CONNECT_DC_INFO && NT_STATUS_IS_OK(status)) {
- d_printf("Domain Controller Info:\n");
- d_printf("\tDomain Name:\t %s\n", connect_r.out.domain_name);
- d_printf("\tDomain SID:\t %s\n", dom_sid_string(ctx, connect_r.out.domain_sid));
- d_printf("\tRealm:\t\t %s\n", connect_r.out.realm);
- d_printf("\tGUID:\t\t %s\n", GUID_string(ctx, connect_r.out.guid));
+ torture_comment(tctx, "Domain Controller Info:\n");
+ torture_comment(tctx, "\tDomain Name:\t %s\n", connect_r.out.domain_name);
+ torture_comment(tctx, "\tDomain SID:\t %s\n", dom_sid_string(ctx, connect_r.out.domain_sid));
+ torture_comment(tctx, "\tRealm:\t\t %s\n", connect_r.out.realm);
+ torture_comment(tctx, "\tGUID:\t\t %s\n", GUID_string(ctx, connect_r.out.guid));
} else if (!NT_STATUS_IS_OK(status)) {
- d_printf("Error string: %s\n", connect_r.out.error_string);
+ torture_comment(tctx, "Error string: %s\n", connect_r.out.error_string);
}
return true;
ctx = libnet_context_init(torture->ev, torture->lp_ctx);
ctx->cred = cmdline_credentials;
- d_printf("Testing connection to LSA interface\n");
- if (!test_connect_service(ctx, &ndr_table_lsarpc, bindstr,
+ torture_comment(torture, "Testing connection to LSA interface\n");
+
+ if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
hostname, level, false, NT_STATUS_OK)) {
- d_printf("failed to connect LSA interface\n");
+ torture_comment(torture, "failed to connect LSA interface\n");
return false;
}
- d_printf("Testing connection to SAMR interface\n");
- if (!test_connect_service(ctx, &ndr_table_samr, bindstr,
+ torture_comment(torture, "Testing connection to SAMR interface\n");
+ if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
hostname, level, false, NT_STATUS_OK)) {
- d_printf("failed to connect SAMR interface\n");
+ torture_comment(torture, "failed to connect SAMR interface\n");
return false;
}
- d_printf("Testing connection to SRVSVC interface\n");
- if (!test_connect_service(ctx, &ndr_table_srvsvc, bindstr,
+ torture_comment(torture, "Testing connection to SRVSVC interface\n");
+ if (!test_connect_service(torture, ctx, &ndr_table_srvsvc, bindstr,
hostname, level, false, NT_STATUS_OK)) {
- d_printf("failed to connect SRVSVC interface\n");
+ torture_comment(torture, "failed to connect SRVSVC interface\n");
return false;
}
- d_printf("Testing connection to LSA interface with wrong credentials\n");
- if (!test_connect_service(ctx, &ndr_table_lsarpc, bindstr,
+ torture_comment(torture, "Testing connection to LSA interface with wrong credentials\n");
+ if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
- d_printf("failed to test wrong credentials on LSA interface\n");
+ torture_comment(torture, "failed to test wrong credentials on LSA interface\n");
return false;
}
- d_printf("Testing connection to SAMR interface with wrong credentials\n");
- if (!test_connect_service(ctx, &ndr_table_samr, bindstr,
+ torture_comment(torture, "Testing connection to SAMR interface with wrong credentials\n");
+ if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
- d_printf("failed to test wrong credentials on SAMR interface\n");
+ torture_comment(torture, "failed to test wrong credentials on SAMR interface\n");
return false;
}
#define TEST_SHARENAME "libnetsharetest"
-static void test_displayshares(struct libnet_ListShares s)
+static void test_displayshares(struct torture_context *tctx,
+ struct libnet_ListShares s)
{
int i, j;
case 0:
for (i = 0; i < s.out.ctr.ctr0->count; i++) {
struct srvsvc_NetShareInfo0 *info = &s.out.ctr.ctr0->array[i];
- d_printf("\t[%d] %s\n", i, info->name);
+ torture_comment(tctx, "\t[%d] %s\n", i, info->name);
}
break;
for (j = 0; j < ARRAY_SIZE(share_types); j++) {
if (share_types[j].type == info->type) break;
}
- d_printf("\t[%d] %s (%s)\t%s\n", i, info->name,
+ torture_comment(tctx, "\t[%d] %s (%s)\t%s\n", i, info->name,
info->comment, share_types[j].desc);
}
break;
for (j = 0; j < ARRAY_SIZE(share_types); j++) {
if (share_types[j].type == info->type) break;
}
- d_printf("\t[%d] %s\t%s\n\t %s\n\t [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
+ torture_comment(tctx, "\t[%d] %s\t%s\n\t %s\n\t [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
i, info->name, share_types[j].desc, info->comment,
info->permissions, info->max_users,
info->current_users, info->path,
for (j = 0; j < ARRAY_SIZE(share_types); j++) {
if (share_types[j].type == info->type) break;
}
- d_printf("\t[%d] %s\t%s [csc_policy=0x%08x]\n\t %s\n", i, info->name,
+ torture_comment(tctx, "\t[%d] %s\t%s [csc_policy=0x%08x]\n\t %s\n", i, info->name,
share_types[j].desc, info->csc_policy,
info->comment);
}
for (j = 0; j < ARRAY_SIZE(share_types); j++) {
if (share_types[j].type == info->type) break;
}
- d_printf("\t[%d] %s\t%s\n\t %s\n\t [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
+ torture_comment(tctx, "\t[%d] %s\t%s\n\t %s\n\t [perms=0x%08x, max_usr=%d, cur_usr=%d, path=%s, pass=%s]\n",
i, info->name, share_types[j].desc, info->comment,
info->permissions, info->max_users,
info->current_users, info->path,
libnetctx = libnet_context_init(torture->ev, torture->lp_ctx);
if (!libnetctx) {
- printf("Couldn't allocate libnet context\n");
+ torture_comment(torture, "Couldn't allocate libnet context\n");
ret = false;
goto done;
}
libnetctx->cred = cmdline_credentials;
- printf("Testing libnet_ListShare\n");
+ torture_comment(torture, "Testing libnet_ListShare\n");
share.in.server_name = talloc_asprintf(mem_ctx, "%s", binding->host);
for (i = 0; i < ARRAY_SIZE(levels); i++) {
share.in.level = levels[i];
- printf("testing libnet_ListShare level %u\n", share.in.level);
+ torture_comment(torture, "testing libnet_ListShare level %u\n", share.in.level);
status = libnet_ListShares(libnetctx, mem_ctx, &share);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_ListShare level %u failed - %s\n", share.in.level, share.out.error_string);
+ torture_comment(torture, "libnet_ListShare level %u failed - %s\n", share.in.level, share.out.error_string);
ret = false;
goto done;
}
- printf("listing shares:\n");
- test_displayshares(share);
+ torture_comment(torture, "listing shares:\n");
+ test_displayshares(torture, share);
}
done:
}
-static bool test_addshare(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx, const char *host,
+static bool test_addshare(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx, const char *host,
const char* share)
{
NTSTATUS status;
status = dcerpc_srvsvc_NetShareAdd_r(b, mem_ctx, &add);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to add a new share\n");
+ torture_comment(tctx, "Failed to add a new share\n");
return false;
}
- printf("share added\n");
+ torture_comment(tctx, "share added\n");
return true;
}
torture_assert_ntstatus_ok(torture, status, "Failed to get rpc connection");
- if (!test_addshare(p->binding_handle, torture, host, TEST_SHARENAME)) {
+ if (!test_addshare(torture, p->binding_handle, torture, host, TEST_SHARENAME)) {
return false;
}
#include "param/param.h"
-static bool test_cleanup(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_cleanup(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle, const char *username)
{
NTSTATUS status;
r1.out.rids = &rids;
r1.out.types = &types;
- printf("user account lookup '%s'\n", username);
+ torture_comment(tctx, "user account lookup '%s'\n", username);
status = dcerpc_samr_LookupNames_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("LookupNames failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "LookupNames failed - %s\n", nt_errstr(status));
return false;
}
r2.in.rid = rid;
r2.out.user_handle = &user_handle;
- printf("opening user account\n");
+ torture_comment(tctx, "opening user account\n");
status = dcerpc_samr_OpenUser_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("OpenUser failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "OpenUser failed - %s\n", nt_errstr(status));
return false;
}
r3.in.user_handle = &user_handle;
r3.out.user_handle = &user_handle;
- printf("deleting user account\n");
+ torture_comment(tctx, "deleting user account\n");
status = dcerpc_samr_DeleteUser_r(b, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
- printf("DeleteUser failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "DeleteUser failed - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_opendomain(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_opendomain(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, struct lsa_String *domname)
{
NTSTATUS status;
struct dom_sid2 *sid = NULL;
struct samr_OpenDomain r3;
- printf("connecting\n");
+ torture_comment(tctx, "connecting\n");
r1.in.system_name = 0;
r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
status = dcerpc_samr_Connect_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("Connect failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Connect failed - %s\n", nt_errstr(status));
return false;
}
r2.in.domain_name = domname;
r2.out.sid = &sid;
- printf("domain lookup on %s\n", domname->string);
+ torture_comment(tctx, "domain lookup on %s\n", domname->string);
status = dcerpc_samr_LookupDomain_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("LookupDomain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "LookupDomain failed - %s\n", nt_errstr(status));
return false;
}
r3.in.sid = *r2.out.sid;
r3.out.domain_handle = &domain_handle;
- printf("opening domain\n");
+ torture_comment(tctx, "opening domain\n");
status = dcerpc_samr_OpenDomain_r(b, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
- printf("OpenDomain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "OpenDomain failed - %s\n", nt_errstr(status));
return false;
} else {
*handle = domain_handle;
}
-static bool test_samr_close(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_samr_close(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle)
{
NTSTATUS status;
status = dcerpc_samr_Close_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("Close samr domain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Close samr domain failed - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_lsa_close(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_lsa_close(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle)
{
NTSTATUS status;
status = dcerpc_lsa_Close_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("Close lsa domain failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Close lsa domain failed - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_createuser(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+static bool test_createuser(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, const char* user)
{
NTSTATUS status;
r1.out.user_handle = &user_handle;
r1.out.rid = &user_rid;
- printf("creating user '%s'\n", username.string);
+ torture_comment(tctx, "creating user '%s'\n", username.string);
status = dcerpc_samr_CreateUser_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateUser failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateUser failed - %s\n", nt_errstr(status));
if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
- printf("User (%s) already exists - attempting to delete and recreate account again\n", user);
- if (!test_cleanup(b, mem_ctx, handle, TEST_USERNAME)) {
+ torture_comment(tctx, "User (%s) already exists - attempting to delete and recreate account again\n", user);
+ if (!test_cleanup(tctx, b, mem_ctx, handle, TEST_USERNAME)) {
return false;
}
- printf("creating user account\n");
+ torture_comment(tctx, "creating user account\n");
status = dcerpc_samr_CreateUser_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateUser failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateUser failed - %s\n", nt_errstr(status));
return false;
}
return true;
r2.in.handle = &user_handle;
r2.out.handle = &user_handle;
- printf("closing user '%s'\n", username.string);
+ torture_comment(tctx, "closing user '%s'\n", username.string);
status = dcerpc_samr_Close_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("Close failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Close failed - %s\n", nt_errstr(status));
return false;
}
status = libnet_CreateUser(ctx, mem_ctx, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_CreateUser call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_CreateUser call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
- if (!test_cleanup(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
- printf("cleanup failed\n");
+ if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
+ torture_comment(torture, "cleanup failed\n");
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
- printf("domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+ torture_comment(torture, "domain close failed\n");
ret = false;
}
}
domain_name.string = lp_workgroup(torture->lp_ctx);
- if (!test_opendomain(p->binding_handle, prep_mem_ctx, &h, &domain_name)) {
+ if (!test_opendomain(torture, p->binding_handle, prep_mem_ctx, &h, &domain_name)) {
ret = false;
goto done;
}
- if (!test_createuser(p->binding_handle, prep_mem_ctx, &h, name)) {
+ if (!test_createuser(torture, p->binding_handle, prep_mem_ctx, &h, name)) {
ret = false;
goto done;
}
status = libnet_DeleteUser(ctx, mem_ctx, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_DeleteUser call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_DeleteUser call failed: %s\n", nt_errstr(status));
ret = false;
}
Generate testing set of random changes
*/
-static void set_test_changes(TALLOC_CTX *mem_ctx, struct libnet_ModifyUser *r,
+static void set_test_changes(struct torture_context *tctx,
+ TALLOC_CTX *mem_ctx, struct libnet_ModifyUser *r,
int num_changes, char **user_name, enum test_fields req_change)
{
const char* logon_scripts[] = { "start_login.cmd", "login.bat", "start.cmd" };
struct timeval now;
int i, testfld;
- printf("Fields to change: [");
+ torture_comment(tctx, "Fields to change: [");
for (i = 0; i < num_changes && i < FIELDS_NUM; i++) {
const char *fldname;
fldname = "unknown_field";
}
- printf(((i < num_changes - 1) ? "%s," : "%s"), fldname);
+ torture_comment(tctx, ((i < num_changes - 1) ? "%s," : "%s"), fldname);
/* disable requested field (it's supposed to be the only one used) */
if (req_change != none) req_change = none;
}
- printf("]\n");
+ torture_comment(tctx, "]\n");
}
#define TEST_STR_FLD(fld) \
if (!strequal(req.in.fld, user_req.out.fld)) { \
- printf("failed to change '%s'\n", #fld); \
+ torture_comment(torture, "failed to change '%s'\n", #fld); \
ret = false; \
goto cleanup; \
}
#define TEST_TIME_FLD(fld) \
if (timeval_compare(req.in.fld, user_req.out.fld)) { \
- printf("failed to change '%s'\n", #fld); \
+ torture_comment(torture, "failed to change '%s'\n", #fld); \
ret = false; \
goto cleanup; \
}
#define TEST_NUM_FLD(fld) \
if (req.in.fld != user_req.out.fld) { \
- printf("failed to change '%s'\n", #fld); \
+ torture_comment(torture, "failed to change '%s'\n", #fld); \
ret = false; \
goto cleanup; \
}
name = talloc_strdup(prep_mem_ctx, TEST_USERNAME);
domain_name.string = lp_workgroup(torture->lp_ctx);
- if (!test_opendomain(b, prep_mem_ctx, &h, &domain_name)) {
+ if (!test_opendomain(torture, b, prep_mem_ctx, &h, &domain_name)) {
ret = false;
goto done;
}
- if (!test_createuser(b, prep_mem_ctx, &h, name)) {
+ if (!test_createuser(torture, b, prep_mem_ctx, &h, name)) {
ret = false;
goto done;
}
goto done;
}
- printf("Testing change of all fields - each single one in turn\n");
+ torture_comment(torture, "Testing change of all fields - each single one in turn\n");
for (fld = 1; fld < FIELDS_NUM - 1; fld++) {
ZERO_STRUCT(req);
req.in.domain_name = lp_workgroup(torture->lp_ctx);
req.in.user_name = name;
- set_test_changes(torture, &req, 1, &name, fld);
+ set_test_changes(torture, torture, &req, 1, &name, fld);
status = libnet_ModifyUser(ctx, torture, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_ModifyUser call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_ModifyUser call failed: %s\n", nt_errstr(status));
ret = false;
continue;
}
status = libnet_UserInfo(ctx, torture, &user_req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_UserInfo call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_UserInfo call failed: %s\n", nt_errstr(status));
ret = false;
continue;
}
status = libnet_ModifyUser(ctx, torture, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_ModifyUser call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_ModifyUser call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
}
cleanup:
- if (!test_cleanup(ctx->samr.pipe->binding_handle, torture, &ctx->samr.handle, name)) {
- printf("cleanup failed\n");
+ if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, torture, &ctx->samr.handle, name)) {
+ torture_comment(torture, "cleanup failed\n");
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, torture, &ctx->samr.handle)) {
- printf("domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, torture, &ctx->samr.handle)) {
+ torture_comment(torture, "domain close failed\n");
ret = false;
}
b = p->binding_handle;
domain_name.string = lp_workgroup(torture->lp_ctx);
- if (!test_opendomain(b, prep_mem_ctx, &h, &domain_name)) {
+ if (!test_opendomain(torture, b, prep_mem_ctx, &h, &domain_name)) {
ret = false;
goto done;
}
- if (!test_createuser(b, prep_mem_ctx, &h, name)) {
+ if (!test_createuser(torture, b, prep_mem_ctx, &h, name)) {
ret = false;
goto done;
}
status = libnet_UserInfo(ctx, mem_ctx, &req);
if (!NT_STATUS_IS_OK(status)) {
- printf("libnet_UserInfo call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_UserInfo call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
- if (!test_cleanup(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
- printf("cleanup failed\n");
+ if (!test_cleanup(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle, TEST_USERNAME)) {
+ torture_comment(torture, "cleanup failed\n");
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
- printf("domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+ torture_comment(torture, "domain close failed\n");
ret = false;
}
ZERO_STRUCT(req);
- printf("listing user accounts:\n");
+ torture_comment(torture, "listing user accounts:\n");
do {
!NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) break;
for (i = 0; i < req.out.count; i++) {
- printf("\tuser: %s, sid=%s\n",
+ torture_comment(torture, "\tuser: %s, sid=%s\n",
req.out.users[i].username, req.out.users[i].sid);
}
if (!(NT_STATUS_IS_OK(status) ||
NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))) {
- printf("libnet_UserList call failed: %s\n", nt_errstr(status));
+ torture_comment(torture, "libnet_UserList call failed: %s\n", nt_errstr(status));
ret = false;
goto done;
}
- if (!test_samr_close(ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
- printf("samr domain close failed\n");
+ if (!test_samr_close(torture, ctx->samr.pipe->binding_handle, mem_ctx, &ctx->samr.handle)) {
+ torture_comment(torture, "samr domain close failed\n");
ret = false;
goto done;
}
- if (!test_lsa_close(ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
- printf("lsa domain close failed\n");
+ if (!test_lsa_close(torture, ctx->lsa.pipe->binding_handle, mem_ctx, &ctx->lsa.handle)) {
+ torture_comment(torture, "lsa domain close failed\n");
ret = false;
}
#define TEST_USERNAME "libnetuserinfotest"
-static bool test_userinfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_userinfo(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle,
struct dom_sid2 *domain_sid, const char* user_name,
uint32_t *rid)
user.in.sid = dom_sid_string(mem_ctx, user_sid);
user.in.level = level; /* this should be extended */
- printf("Testing sync libnet_rpc_userinfo (SID argument)\n");
+ torture_comment(tctx, "Testing sync libnet_rpc_userinfo (SID argument)\n");
status = libnet_rpc_userinfo(p, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
return false;
}
user.in.username = TEST_USERNAME;
user.in.level = level;
- printf("Testing sync libnet_rpc_userinfo (username argument)\n");
+ torture_comment(tctx, "Testing sync libnet_rpc_userinfo (username argument)\n");
status = libnet_rpc_userinfo(p, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Failed to call sync libnet_rpc_userinfo - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_userinfo_async(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_userinfo_async(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle,
struct dom_sid2 *domain_sid, const char* user_name,
uint32_t *rid)
user.in.sid = dom_sid_string(mem_ctx, user_sid);
user.in.level = level; /* this should be extended */
- printf("Testing async libnet_rpc_userinfo (SID argument)\n");
+ torture_comment(tctx, "Testing async libnet_rpc_userinfo (SID argument)\n");
c = libnet_rpc_userinfo_send(p, &user, msg_handler);
if (!c) {
- printf("Failed to call sync libnet_rpc_userinfo_send\n");
+ torture_comment(tctx, "Failed to call sync libnet_rpc_userinfo_send\n");
return false;
}
status = libnet_rpc_userinfo_recv(c, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Calling async libnet_rpc_userinfo failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Calling async libnet_rpc_userinfo failed - %s\n", nt_errstr(status));
return false;
}
user.in.username = TEST_USERNAME;
user.in.level = level;
- printf("Testing async libnet_rpc_userinfo (username argument)\n");
+ torture_comment(tctx, "Testing async libnet_rpc_userinfo (username argument)\n");
c = libnet_rpc_userinfo_send(p, &user, msg_handler);
if (!c) {
- printf("Failed to call sync libnet_rpc_userinfo_send\n");
+ torture_comment(tctx, "Failed to call sync libnet_rpc_userinfo_send\n");
return false;
}
status = libnet_rpc_userinfo_recv(c, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Calling async libnet_rpc_userinfo failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Calling async libnet_rpc_userinfo failed - %s\n", nt_errstr(status));
return false;
}
goto done;
}
- if (!test_userinfo(p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
+ if (!test_userinfo(torture, p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
ret = false;
goto done;
}
goto done;
}
- if (!test_userinfo_async(p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
+ if (!test_userinfo_async(torture, p, mem_ctx, &h, &sid, TEST_USERNAME, &rid)) {
ret = false;
goto done;
}
#include "torture/libnet/utils.h"
-static bool test_useradd(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_useradd(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle,
const char *name)
{
user.in.domain_handle = *domain_handle;
user.in.username = name;
- printf("Testing libnet_rpc_useradd\n");
+ torture_comment(tctx, "Testing libnet_rpc_useradd\n");
status = libnet_rpc_useradd(p, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to call libnet_rpc_useradd - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Failed to call libnet_rpc_useradd - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_useradd_async(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_useradd_async(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, const char* username)
{
NTSTATUS status;
user.in.domain_handle = *handle;
user.in.username = username;
- printf("Testing async libnet_rpc_useradd\n");
+ torture_comment(tctx, "Testing async libnet_rpc_useradd\n");
c = libnet_rpc_useradd_send(p, &user, msg_handler);
if (!c) {
- printf("Failed to call async libnet_rpc_useradd\n");
+ torture_comment(tctx, "Failed to call async libnet_rpc_useradd\n");
return false;
}
status = libnet_rpc_useradd_recv(c, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Calling async libnet_rpc_useradd failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Calling async libnet_rpc_useradd failed - %s\n", nt_errstr(status));
return false;
}
}
-static bool test_userdel(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
+static bool test_userdel(struct torture_context *tctx,
+ struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, const char *username)
{
NTSTATUS status;
status = libnet_rpc_userdel(p, mem_ctx, &user);
if (!NT_STATUS_IS_OK(status)) {
- printf("Failed to call sync libnet_rpc_userdel - %s\n", nt_errstr(status));
+ torture_comment(tctx, "Failed to call sync libnet_rpc_userdel - %s\n", nt_errstr(status));
return false;
}
#define CMP_LSA_STRING_FLD(fld, flags) \
if ((mod->in.change.fields & flags) && \
!strequal(i->fld.string, mod->in.change.fld)) { \
- printf("'%s' field does not match\n", #fld); \
- printf("received: '%s'\n", i->fld.string); \
- printf("expected: '%s'\n", mod->in.change.fld); \
+ torture_comment(tctx, "'%s' field does not match\n", #fld); \
+ torture_comment(tctx, "received: '%s'\n", i->fld.string); \
+ torture_comment(tctx, "expected: '%s'\n", mod->in.change.fld); \
return false; \
}
if (mod->in.change.fields & flags) { \
nttime_to_timeval(&t, i->fld); \
if (timeval_compare(&t, mod->in.change.fld)) { \
- printf("'%s' field does not match\n", #fld); \
- printf("received: '%s (+%ld us)'\n", \
+ torture_comment(tctx, "'%s' field does not match\n", #fld); \
+ torture_comment(tctx, "received: '%s (+%ld us)'\n", \
timestring(mem_ctx, t.tv_sec), t.tv_usec); \
- printf("expected: '%s (+%ld us)'\n", \
+ torture_comment(tctx, "expected: '%s (+%ld us)'\n", \
timestring(mem_ctx, mod->in.change.fld->tv_sec), \
mod->in.change.fld->tv_usec); \
return false; \
#define CMP_NUM_FLD(fld, flags) \
if ((mod->in.change.fields & flags) && \
(i->fld != mod->in.change.fld)) { \
- printf("'%s' field does not match\n", #fld); \
- printf("received: '%04x'\n", i->fld); \
- printf("expected: '%04x'\n", mod->in.change.fld); \
+ torture_comment(tctx, "'%s' field does not match\n", #fld); \
+ torture_comment(tctx, "received: '%04x'\n", i->fld); \
+ torture_comment(tctx, "expected: '%04x'\n", mod->in.change.fld); \
return false; \
}
goto done;
}
- if (!test_useradd(p, mem_ctx, &h, name)) {
+ if (!test_useradd(torture, p, mem_ctx, &h, name)) {
ret = false;
goto done;
}
goto done;
}
- if (!test_useradd_async(p, mem_ctx, &h, name)) {
+ if (!test_useradd_async(torture, p, mem_ctx, &h, name)) {
ret = false;
goto done;
}
goto done;
}
- if (!test_userdel(p, mem_ctx, &h, name)) {
+ if (!test_userdel(torture, p, mem_ctx, &h, name)) {
ret = false;
goto done;
}
status = dcerpc_samr_CreateUser_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateUser failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateUser failed - %s\n", nt_errstr(status));
if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
torture_comment(tctx, "User (%s) already exists - attempting to delete and recreate account again\n", name);
}
-bool test_group_cleanup(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+bool test_group_cleanup(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle,
const char *name)
{
r1.out.rids = &rids;
r1.out.types = &types;
- printf("group account lookup '%s'\n", name);
+ torture_comment(tctx, "group account lookup '%s'\n", name);
status = dcerpc_samr_LookupNames_r(b, mem_ctx, &r1);
if (!NT_STATUS_IS_OK(status)) {
- printf("LookupNames failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "LookupNames failed - %s\n", nt_errstr(status));
return false;
}
r2.in.rid = rid;
r2.out.group_handle = &group_handle;
- printf("opening group account\n");
+ torture_comment(tctx, "opening group account\n");
status = dcerpc_samr_OpenGroup_r(b, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
- printf("OpenGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "OpenGroup failed - %s\n", nt_errstr(status));
return false;
}
r3.in.group_handle = &group_handle;
r3.out.group_handle = &group_handle;
- printf("deleting group account\n");
+ torture_comment(tctx, "deleting group account\n");
status = dcerpc_samr_DeleteDomainGroup_r(b, mem_ctx, &r3);
if (!NT_STATUS_IS_OK(status)) {
- printf("DeleteGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "DeleteGroup failed - %s\n", nt_errstr(status));
return false;
}
}
-bool test_group_create(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
+bool test_group_create(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
struct policy_handle *handle, const char *name,
uint32_t *rid)
{
r.out.group_handle = &group_handle;
r.out.rid = rid;
- printf("creating group account %s\n", name);
+ torture_comment(tctx, "creating group account %s\n", name);
status = dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateGroup failed - %s\n", nt_errstr(status));
if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
- printf("Group (%s) already exists - attempting to delete and recreate account again\n", name);
- if (!test_group_cleanup(b, mem_ctx, handle, name)) {
+ torture_comment(tctx, "Group (%s) already exists - attempting to delete and recreate account again\n", name);
+ if (!test_group_cleanup(tctx, b, mem_ctx, handle, name)) {
return false;
}
- printf("creating group account\n");
+ torture_comment(tctx, "creating group account\n");
status = dcerpc_samr_CreateDomainGroup_r(b, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
- printf("CreateGroup failed - %s\n", nt_errstr(status));
+ torture_comment(tctx, "CreateGroup failed - %s\n", nt_errstr(status));
return false;
}
return true;
struct policy_handle *domain_handle,
const char *name);
-bool test_group_create(struct dcerpc_binding_handle *b,
+bool test_group_create(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b,
TALLOC_CTX *mem_ctx,
struct policy_handle *handle, const char *name,
uint32_t *rid);
-bool test_group_cleanup(struct dcerpc_binding_handle *b,
+bool test_group_cleanup(struct torture_context *tctx,
+ struct dcerpc_binding_handle *b,
TALLOC_CTX *mem_ctx,
struct policy_handle *domain_handle,
const char *name);
git.samba.org / gd / samba-autobuild / .git / commitdiff