自学教程：C++ torture_comment函数代码示例

static bool test_netprintdestgetinfo(struct torture_context *tctx,				     struct smbcli_state *cli){	struct rap_NetPrintDestEnum r;	int i;	r.in.level = 2;	r.in.bufsize = 8192;	torture_comment(tctx,		"Testing rap_NetPrintDestEnum level %d/n", r.in.level);	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netprintdestenum(cli->tree, tctx, &r),		"smbcli_rap_netprintdestenum failed");	for (i=0; i < r.out.count; i++) {		torture_assert(tctx,			test_netprintdestgetinfo_bydest(tctx, cli, r.out.info[i].info2.PrinterName),			"failed to get printdest info");	}	return true;}

bool torture_setup_privs(struct torture_context *tctx,			struct dcerpc_pipe *p,			uint32_t num_privs,			const char **privs,			const struct dom_sid *user_sid){	struct dcerpc_binding_handle *b = p->binding_handle;	struct policy_handle *handle;	int i;	torture_assert(tctx,		test_lsa_OpenPolicy2(b, tctx, &handle),		"failed to open policy");	for (i=0; i < num_privs; i++) {		struct lsa_LookupPrivValue r;		struct lsa_LUID luid;		struct lsa_String name;		init_lsa_String(&name, privs[i]);		r.in.handle = handle;		r.in.name = &name;		r.out.luid = &luid;		torture_assert_ntstatus_ok(tctx,			dcerpc_lsa_LookupPrivValue_r(b, tctx, &r),			"lsa_LookupPrivValue failed");		if (!NT_STATUS_IS_OK(r.out.result)) {			torture_comment(tctx, "lsa_LookupPrivValue failed for '%s' with %s/n",				privs[i], nt_errstr(r.out.result));			return false;		}	}	{		struct lsa_AddAccountRights r;		struct lsa_RightSet rights;		rights.count = num_privs;		rights.names = talloc_zero_array(tctx, struct lsa_StringLarge, rights.count);		for (i=0; i < rights.count; i++) {			init_lsa_StringLarge(&rights.names[i], privs[i]);		}		r.in.handle = handle;		r.in.sid = discard_const_p(struct dom_sid, user_sid);		r.in.rights = &rights;		torture_assert_ntstatus_ok(tctx,			dcerpc_lsa_AddAccountRights_r(b, tctx, &r),			"lsa_AddAccountRights failed");		torture_assert_ntstatus_ok(tctx, r.out.result,			"lsa_AddAccountRights failed");	}	test_lsa_Close(b, tctx, handle);	return true;}

static bool test_netprintjobenum_one(struct torture_context *tctx,				     struct smbcli_state *cli,				     const char *PrintQueueName){	struct rap_NetPrintJobEnum r;	int i;	uint16_t levels[] = { 0, 1, 2 };	r.in.PrintQueueName = PrintQueueName;	r.in.bufsize = 8192;	for (i=0; i < ARRAY_SIZE(levels); i++) {		r.in.level = levels[i];		torture_comment(tctx,			"Testing rap_NetPrintJobEnum(%s) level %d/n", r.in.PrintQueueName, r.in.level);		torture_assert_ntstatus_ok(tctx,			smbcli_rap_netprintjobenum(cli->tree, tctx, &r),			"smbcli_rap_netprintjobenum failed");	}	return true;}

static bool test_create_acl_dir(struct torture_context *tctx,    struct smb2_tree *tree){	torture_comment(tctx, "Testing nttrans create with sec_desc on directories/n");	return test_create_acl_ext(tctx, tree, true);}

/*  test SMB2 open with a leading slash on the path.  Trying to create a directory with a leading slash  should give NT_STATUS_INVALID_PARAMETER error*/static bool test_smb2_leading_slash(struct torture_context *tctx,                                    struct smb2_tree *tree){    union smb_open io;    const char *dnameslash = "//"DNAME;    NTSTATUS status;    bool ret = true;    torture_comment(tctx,                    "Trying to create a directory with leading slash on path/n");    smb2_deltree(tree, dnameslash);    ZERO_STRUCT(io.smb2);    io.generic.level = RAW_OPEN_SMB2;    io.smb2.in.oplock_level = 0;    io.smb2.in.desired_access = SEC_RIGHTS_DIR_ALL;    io.smb2.in.file_attributes   = FILE_ATTRIBUTE_DIRECTORY;    io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;    io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |                              NTCREATEX_SHARE_ACCESS_WRITE |                              NTCREATEX_SHARE_ACCESS_DELETE;    io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;    io.smb2.in.fname = dnameslash;    status = smb2_create(tree, tree, &(io.smb2));    CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);    smb2_deltree(tree, dnameslash);    return ret;}

/*  a schannel test suite */bool torture_rpc_schannel(struct torture_context *torture){	bool ret = true;	struct {		uint16_t acct_flags;		uint32_t dcerpc_flags;	} tests[] = {		{ ACB_WSTRUST,   DCERPC_SCHANNEL | DCERPC_SIGN},		{ ACB_WSTRUST,   DCERPC_SCHANNEL | DCERPC_SEAL},		{ ACB_WSTRUST,   DCERPC_SCHANNEL | DCERPC_SIGN | DCERPC_SCHANNEL_128},		{ ACB_WSTRUST,   DCERPC_SCHANNEL | DCERPC_SEAL | DCERPC_SCHANNEL_128 },		{ ACB_SVRTRUST,  DCERPC_SCHANNEL | DCERPC_SIGN },		{ ACB_SVRTRUST,  DCERPC_SCHANNEL | DCERPC_SEAL },		{ ACB_SVRTRUST,  DCERPC_SCHANNEL | DCERPC_SIGN | DCERPC_SCHANNEL_128 },		{ ACB_SVRTRUST,  DCERPC_SCHANNEL | DCERPC_SEAL | DCERPC_SCHANNEL_128 }	};	int i;	for (i=0;i<ARRAY_SIZE(tests);i++) {		if (!test_schannel(torture, 				   tests[i].acct_flags, tests[i].dcerpc_flags,				   i)) {			torture_comment(torture, "Failed with acct_flags=0x%x dcerpc_flags=0x%x /n",			       tests[i].acct_flags, tests[i].dcerpc_flags);			ret = false;		}	}	return ret;}

static bool test_SetPrinter(struct torture_context *tctx,			    struct dcerpc_binding_handle *b,			    struct policy_handle *handle,			    struct spoolss_SetPrinterInfoCtr *info_ctr,			    struct spoolss_DevmodeContainer *devmode_ctr,			    struct sec_desc_buf *secdesc_ctr,			    enum spoolss_PrinterControl command){	struct spoolss_SetPrinter r;	r.in.handle = handle;	r.in.info_ctr = info_ctr;	r.in.devmode_ctr = devmode_ctr;	r.in.secdesc_ctr = secdesc_ctr;	r.in.command = command;	torture_comment(tctx, "Testing SetPrinter level %d/n", r.in.info_ctr->level);	torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r),		"failed to call SetPrinter");	torture_assert_werr_ok(tctx, r.out.result,		"failed to call SetPrinter");	return true;}

static bool test_netprintjobsetinfo_byid(struct torture_context *tctx,					 struct smbcli_state *cli,					 uint16_t JobID){	struct rap_NetPrintJobSetInfo r;	uint16_t levels[] = { 0, 1, 2 };	int i;	const char *comment = "tortured by samba";	r.in.JobID = JobID;	r.in.bufsize = strlen(comment);	r.in.ParamNum = RAP_PARAM_JOBCOMMENT;	r.in.Param.string = comment;	for (i=0; i < ARRAY_SIZE(levels); i++) {		r.in.level = levels[i];		torture_comment(tctx, "Testing rap_NetPrintJobSetInfo(%d) level %d/n", r.in.JobID, r.in.level);		torture_assert_ntstatus_ok(tctx,			smbcli_rap_netprintjobsetinfo(cli->tree, tctx, &r),			"smbcli_rap_netprintjobsetinfo failed");	}	return true;}

static bool test_netprintqenum(struct torture_context *tctx,			       struct smbcli_state *cli){	struct rap_NetPrintQEnum r;	int i, q;	uint16_t levels[] = { 0, 1, 2, 3, 4, 5 };	for (i=0; i < ARRAY_SIZE(levels); i++) {		r.in.level = levels[i];		r.in.bufsize = 8192;		torture_comment(tctx,			"Testing rap_NetPrintQEnum level %d/n", r.in.level);		torture_assert_ntstatus_ok(tctx,			smbcli_rap_netprintqenum(cli->tree, tctx, &r),			"smbcli_rap_netprintqenum failed");		torture_assert_werr_ok(tctx, W_ERROR(r.out.status),			"failed to enum printq");		for (q=0; q<r.out.count; q++) {			switch (r.in.level) {			case 0:				printf("%s/n", r.out.info[q].info0.PrintQName);				break;			}		}	}	return true;}

static bool test_GetPrinterDriver2(struct torture_context *tctx,					struct dcerpc_binding_handle *b,					struct test_spoolss_win_context *ctx,					struct policy_handle *handle){	NTSTATUS status;	struct spoolss_GetPrinterDriver2 gpd2;	DATA_BLOB blob = data_blob_talloc_zero(tctx, 87424);	uint32_t needed;	uint32_t server_major_version;	uint32_t server_minor_version;	torture_comment(tctx, "Testing GetPrinterDriver2/n");	gpd2.in.handle = handle;	gpd2.in.architecture = "Windows NT x86";	gpd2.in.level = 101;	gpd2.in.buffer = &blob;	gpd2.in.offered = 87424;	gpd2.in.client_major_version = 3;	gpd2.in.client_minor_version = 0;	gpd2.out.needed = &needed;	gpd2.out.server_major_version = &server_major_version;	gpd2.out.server_minor_version = &server_minor_version;	status = dcerpc_spoolss_GetPrinterDriver2_r(b, tctx, &gpd2);	torture_assert_ntstatus_ok(tctx, status, "GetPrinterDriver2 failed");	if (ctx->printer_has_driver) {		torture_assert_werr_ok(tctx, gpd2.out.result,				"GetPrinterDriver2 failed.");	}	return true;}

/* This is a convenience function for all OpenPrinterEx calls */static bool test_OpenPrinterEx(struct torture_context *tctx,				struct dcerpc_binding_handle *b,				struct policy_handle *handle,				const char *printer_name,				uint32_t access_mask){	NTSTATUS status;	struct spoolss_OpenPrinterEx op;	struct spoolss_UserLevel1 ul_1;	torture_comment(tctx, "Opening printer '%s'/n", printer_name);	op.in.printername		= talloc_strdup(tctx, printer_name);	op.in.datatype			= NULL;	op.in.devmode_ctr.devmode	= NULL;	op.in.access_mask		= access_mask;	op.in.userlevel_ctr.level	= 1;	op.in.userlevel_ctr.user_info.level1 = &ul_1;	op.out.handle			= handle;	ul_1.size 			= 1234;	ul_1.client			= "//clientname";	ul_1.user			= "username";	ul_1.build			= 1;	ul_1.major			= 2;	ul_1.minor			= 3;	ul_1.processor			= 4567;	status = dcerpc_spoolss_OpenPrinterEx_r(b, tctx, &op);	torture_assert_ntstatus_ok(tctx, status, "OpenPrinterEx failed");	torture_assert_werr_ok(tctx, op.out.result, "OpenPrinterEx failed");	return true;}

static bool print_printjob(struct torture_context *tctx,			   struct smbcli_tree *tree){	int fnum;	DATA_BLOB data;	ssize_t size_written;	const char *str;	torture_comment(tctx, "creating printjob %s/n", TORTURE_PRINT_FILE);	fnum = smbcli_open(tree, TORTURE_PRINT_FILE, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);	if (fnum == -1) {		torture_fail(tctx, "failed to open file");	}	str = talloc_asprintf(tctx, "TortureTestPage: %d/nData/n",0);	data = data_blob_string_const(str);	size_written = smbcli_write(tree, fnum, 0, data.data, 0, data.length);	if (size_written != data.length) {		torture_fail(tctx, "failed to write file");	}	torture_assert_ntstatus_ok(tctx,		smbcli_close(tree, fnum),		"failed to close file");	return true;}

static bool test_GetPrinterData(struct torture_context *tctx,				struct dcerpc_binding_handle *b,				struct policy_handle *handle,				const char *value_name,				WERROR expected_werr,				uint32_t expected_value){	NTSTATUS status;	struct spoolss_GetPrinterData gpd;	uint32_t needed;	enum winreg_Type type;	uint8_t *data = talloc_zero_array(tctx, uint8_t, 4);	torture_comment(tctx, "Testing GetPrinterData(%s)./n", value_name);	gpd.in.handle = handle;	gpd.in.value_name = value_name;	gpd.in.offered = 4;	gpd.out.needed = &needed;	gpd.out.type = &type;	gpd.out.data = data;	status = dcerpc_spoolss_GetPrinterData_r(b, tctx, &gpd);	torture_assert_ntstatus_ok(tctx, status, "GetPrinterData failed.");	torture_assert_werr_equal(tctx, gpd.out.result, expected_werr,			"GetPrinterData did not return expected error value.");	if (W_ERROR_IS_OK(expected_werr)) {		uint32_t value = IVAL(data, 0);		torture_assert_int_equal(tctx, value,			expected_value,			talloc_asprintf(tctx, "GetPrinterData for %s did not return expected value.", value_name));	}	return true;}

/*  test a echodata call over the internal messaging system*/static bool test_echodata(struct torture_context *tctx,						  const void *tcase_data,						  const void *test_data){	struct echo_EchoData r;	NTSTATUS status;	const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;	TALLOC_CTX *mem_ctx = tctx;	struct dcerpc_binding_handle *irpc_handle;	irpc_handle = irpc_binding_handle(mem_ctx, data->msg_ctx1,					  cluster_id(0, MSG_ID2),					  &ndr_table_rpcecho);	torture_assert(tctx, irpc_handle, "no memory");	/* make the call */	r.in.in_data = (unsigned char *)talloc_strdup(mem_ctx, "0123456789");	r.in.len = strlen((char *)r.in.in_data);	status = dcerpc_echo_EchoData_r(irpc_handle, mem_ctx, &r);	torture_assert_ntstatus_ok(tctx, status, "EchoData failed");	/* check the answer */	if (memcmp(r.out.out_data, r.in.in_data, r.in.len) != 0) {		NDR_PRINT_OUT_DEBUG(echo_EchoData, &r);		torture_fail(tctx, "EchoData wrong answer");	}	torture_comment(tctx, "Echo '%*.*s' -> '%*.*s'/n", 	       r.in.len, r.in.len,	       r.in.in_data,	       r.in.len, r.in.len,	       r.out.out_data);	return true;}

static bool test_openprinter_access(struct torture_context *tctx,				    struct dcerpc_pipe *p,				    const char *name,				    const char *printername,				    const char *username,				    uint32_t access_mask,				    WERROR expected_result){	struct policy_handle handle;	struct dcerpc_binding_handle *b = p->binding_handle;	bool ret = true;	ZERO_STRUCT(handle);	if (printername == NULL) {		torture_comment(tctx, "skipping test %s as there is no printer/n", name);		return true;	}	ret = test_openprinter_handle(tctx, p, name, printername, username, access_mask, expected_result, &handle);	if (is_valid_policy_hnd(&handle)) {		test_ClosePrinter(tctx, b, &handle);	}	return ret;}

static bool test_create_acl_file(struct torture_context *tctx,    struct smb2_tree *tree){	torture_comment(tctx, "Testing nttrans create with sec_desc on files/n");	return test_create_acl_ext(tctx, tree, false);}

static bool test_netprintjobenum_args(struct torture_context *tctx,				      struct smbcli_state *cli,				      const char *PrintQueueName,				      uint16_t level,				      uint16_t *count_p,				      union rap_printj_info **info_p){	struct rap_NetPrintJobEnum r;	r.in.PrintQueueName = PrintQueueName;	r.in.bufsize = 8192;	r.in.level = level;	torture_comment(tctx,		"Testing rap_NetPrintJobEnum(%s) level %d/n", r.in.PrintQueueName, r.in.level);	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netprintjobenum(cli->tree, tctx, &r),		"smbcli_rap_netprintjobenum failed");	if (count_p) {		*count_p = r.out.count;	}	if (info_p) {		*info_p = r.out.info;	}	return true;}

/*  test a addone call over the internal messaging system*/static bool test_addone(struct torture_context *test, const void *_data,			const void *_value){	struct echo_AddOne r;	NTSTATUS status;	const struct irpc_test_data *data = (const struct irpc_test_data *)_data;	uint32_t value = *(const uint32_t *)_value;	struct dcerpc_binding_handle *irpc_handle;	irpc_handle = irpc_binding_handle(test, data->msg_ctx1,					  cluster_id(0, MSG_ID2),					  &ndr_table_rpcecho);	torture_assert(test, irpc_handle, "no memory");	/* make the call */	r.in.in_data = value;	test_debug = true;	status = dcerpc_echo_AddOne_r(irpc_handle, test, &r);	test_debug = false;	torture_assert_ntstatus_ok(test, status, "AddOne failed");	/* check the answer */	torture_assert(test, *r.out.out_data == r.in.in_data + 1, 				   "AddOne wrong answer");	torture_comment(test, "%u + 1 = %u/n", r.in.in_data, *r.out.out_data);	return true;}

static bool torture_libsmbclient_initialize(struct torture_context *tctx){	SMBCCTX *ctx;	torture_comment(tctx, "Testing smbc_new_context/n");	ctx = smbc_new_context();	torture_assert(tctx, ctx, "failed to get new context");	torture_comment(tctx, "Testing smbc_init_context/n");	torture_assert(tctx, smbc_init_context(ctx), "failed to init context");	smbc_free_context(ctx, 1);	return true;}

static bool test_fsrvp_get_version(struct torture_context *tctx,				   struct dcerpc_pipe *p){	struct fss_GetSupportedVersion r;	struct dcerpc_binding_handle *b = p->binding_handle;	NTSTATUS status;	ZERO_STRUCT(r);	status = dcerpc_fss_GetSupportedVersion_r(b, tctx, &r);	torture_assert_ntstatus_ok(tctx, status,				   "GetSupportedVersion failed");	torture_comment(tctx, "got MinVersion %u/n", *r.out.MinVersion);	torture_comment(tctx, "got MaxVersion %u/n", *r.out.MaxVersion);	return true;}

static bool torture_libsmbclient_version(struct torture_context *tctx){	torture_comment(tctx, "Testing smbc_version/n");	torture_assert(tctx, smbc_version(), "failed to get version");	return true;}

/*  return the default DN for a ldap server given a connected RPC pipe to the  server */static const char *torture_get_ldap_base_dn(struct torture_context *tctx, struct dcerpc_pipe *p){	const char *hostname = p->binding->host;	struct ldb_context *ldb;	const char *ldap_url = talloc_asprintf(p, "ldap://%s", hostname);	const char *attrs[] = { "defaultNamingContext", NULL };	const char *dnstr;	TALLOC_CTX *tmp_ctx = talloc_new(tctx);	int ret;	struct ldb_result *res;	ldb = ldb_init(tmp_ctx, tctx->ev);	if (ldb == NULL) {		talloc_free(tmp_ctx);		return NULL;	}	if (ldb_set_opaque(ldb, "loadparm", tctx->lp_ctx)) {		talloc_free(ldb);		return NULL;	}	ldb_set_modules_dir(ldb,			    modules_path(ldb, "ldb"));	ret = ldb_connect(ldb, ldap_url, 0, NULL);	if (ret != LDB_SUCCESS) {		torture_comment(tctx, "Failed to make LDB connection to target");		talloc_free(tmp_ctx);		return NULL;	}	ret = dsdb_search_dn(ldb, tmp_ctx, &res, ldb_dn_new(tmp_ctx, ldb, ""),			     attrs, 0);	if (ret != LDB_SUCCESS) {		torture_comment(tctx, "Failed to get defaultNamingContext");		talloc_free(tmp_ctx);		return NULL;	}	dnstr = ldb_msg_find_attr_as_string(res->msgs[0], "defaultNamingContext", NULL);	dnstr = talloc_strdup(tctx, dnstr);	talloc_free(tmp_ctx);	return dnstr;}

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){	const uint16_t level = 10;	NTSTATUS status;	struct composite_context *c;	struct libnet_rpc_userinfo user;	struct dom_sid *user_sid;	user_sid = dom_sid_add_rid(mem_ctx, domain_sid, *rid);	ZERO_STRUCT(user);	user.in.domain_handle = *domain_handle;	user.in.sid           = dom_sid_string(mem_ctx, user_sid);	user.in.level         = level;       /* this should be extended */	torture_comment(tctx, "Testing async libnet_rpc_userinfo (SID argument)/n");	c = libnet_rpc_userinfo_send(mem_ctx, tctx->ev, p->binding_handle, &user, msg_handler);	torture_assert(tctx, c != NULL, "Failed to call async libnet_rpc_userinfo_send");	status = libnet_rpc_userinfo_recv(c, mem_ctx, &user);	torture_assert_ntstatus_ok(tctx, status, "Calling async libnet_rpc_userinfo_recv failed");	ZERO_STRUCT(user);	user.in.domain_handle = *domain_handle;	user.in.sid           = NULL;	user.in.username      = user_name;	user.in.level         = level;	torture_comment(tctx, "Testing async libnet_rpc_userinfo (username argument)/n");	c = libnet_rpc_userinfo_send(mem_ctx, tctx->ev, p->binding_handle, &user, msg_handler);	torture_assert(tctx, c != NULL, "Failed to call async libnet_rpc_userinfo_send");	status = libnet_rpc_userinfo_recv(c, mem_ctx, &user);	torture_assert_ntstatus_ok(tctx, status, "Calling async libnet_rpc_userinfo_recv failed");	return true;}

/*  test resolution using sync method*/static bool test_sync_resolve(struct torture_context *tctx){	int timelimit = torture_setting_int(tctx, "timelimit", 2);	struct timeval tv = timeval_current();	int count = 0;	const char *host = torture_setting_string(tctx, "host", NULL);	torture_comment(tctx, "Testing sync resolve of '%s' for %d seconds/n", 			host, timelimit);	while (timeval_elapsed(&tv) < timelimit) {		inet_ntoa(interpret_addr2(host));		count++;	}		torture_comment(tctx, "sync rate of %.1f resolves/sec/n", 			count/timeval_elapsed(&tv));	return true;}

static bool test_netprintqgetinfo(struct torture_context *tctx,				  struct smbcli_state *cli){	struct rap_NetPrintQGetInfo r;	struct rap_NetPrintQEnum r_enum;	int i, p;	uint16_t levels[] = { 0, 1, 2, 3, 4, 5 };	r.in.level = 0;	r.in.bufsize = 0;	r.in.PrintQueueName = "";	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),		"smbcli_rap_netprintqgetinfo failed");	torture_assert_werr_equal(tctx,				  W_ERROR(r.out.status),				  WERR_INVALID_PARAMETER,				  "smbcli_rap_netprintqgetinfo failed");	r_enum.in.level = 5;	r_enum.in.bufsize = 8192;	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netprintqenum(cli->tree, tctx, &r_enum),		"failed to enum printq");	torture_assert_werr_ok(tctx, W_ERROR(r_enum.out.status),		"failed to enum printq");	for (p=0; p < r_enum.out.count; p++) {		for (i=0; i < ARRAY_SIZE(levels); i++) {			r.in.level = levels[i];			r.in.bufsize = 8192;			r.in.PrintQueueName = r_enum.out.info[p].info5.PrintQueueName;			torture_comment(tctx, "Testing rap_NetPrintQGetInfo(%s) level %d/n",				r.in.PrintQueueName, r.in.level);			torture_assert_ntstatus_ok(tctx,				smbcli_rap_netprintqgetinfo(cli->tree, tctx, &r),				"smbcli_rap_netprintqgetinfo failed");			torture_assert_werr_ok(tctx,				W_ERROR(r.out.status),				"smbcli_rap_netprintqgetinfo failed");			switch (r.in.level) {			case 0:				printf("%s/n", r.out.info.info0.PrintQName);				break;			}		}	}	return true;}

bool test_opendomain(struct torture_context *tctx,                     struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,                     struct policy_handle *handle, struct lsa_String *domname,                     struct dom_sid2 *sid_p){    NTSTATUS status;    struct policy_handle h, domain_handle;    struct samr_Connect r1;    struct samr_LookupDomain r2;    struct dom_sid2 *sid = NULL;    struct samr_OpenDomain r3;    torture_comment(tctx, "connecting/n");    r1.in.system_name = 0;    r1.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;    r1.out.connect_handle = &h;    status = dcerpc_samr_Connect(p, mem_ctx, &r1);    torture_assert_ntstatus_ok(tctx, status, "Connect failed");    r2.in.connect_handle = &h;    r2.in.domain_name = domname;    r2.out.sid = &sid;    torture_comment(tctx, "domain lookup on %s/n", domname->string);    status = dcerpc_samr_LookupDomain(p, mem_ctx, &r2);    torture_assert_ntstatus_ok(tctx, status, "LookupDomain failed");    r3.in.connect_handle = &h;    r3.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;    r3.in.sid = *r2.out.sid;    r3.out.domain_handle = &domain_handle;    torture_comment(tctx, "opening domain/n");    status = dcerpc_samr_OpenDomain(p, mem_ctx, &r3);    torture_assert_ntstatus_ok(tctx, status, "OpenDomain failed");    *handle = domain_handle;    *sid_p = **r2.out.sid;    return true;}

/*   basic testing of change notify on directories*/static bool torture_smb2_notify_disabled(struct torture_context *torture,					 struct smb2_tree *tree1){	bool ret = true;	NTSTATUS status;	union smb_notify notify;	union smb_open io;	struct smb2_handle h1;	struct smb2_request *req;	torture_comment(torture, "TESTING CHANGE NOTIFY DISABLED/n");	smb2_deltree(tree1, BASEDIR);	smb2_util_rmdir(tree1, BASEDIR);	/*	  get a handle on the directory	*/	ZERO_STRUCT(io.smb2);	io.generic.level = RAW_OPEN_SMB2;	io.smb2.in.create_flags = 0;	io.smb2.in.desired_access = SEC_FILE_ALL;	io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;	io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;	io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |				NTCREATEX_SHARE_ACCESS_WRITE;	io.smb2.in.alloc_size = 0;	io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;	io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;	io.smb2.in.security_flags = 0;	io.smb2.in.fname = BASEDIR;	status = smb2_create(tree1, torture, &(io.smb2));	torture_assert_ntstatus_equal_goto(torture, status, NT_STATUS_OK,					   ret, done, "smb2_create");	h1 = io.smb2.out.file.handle;	ZERO_STRUCT(notify.smb2);	notify.smb2.level = RAW_NOTIFY_SMB2;	notify.smb2.in.buffer_size = 1000;	notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;	notify.smb2.in.file.handle = h1;	notify.smb2.in.recursive = true;	req = smb2_notify_send(tree1, &(notify.smb2));	status = smb2_notify_recv(req, torture, &(notify.smb2));	torture_assert_ntstatus_equal_goto(torture, status, NT_STATUS_NOT_IMPLEMENTED,					   ret, done, "smb2_notify_recv");	status = smb2_util_close(tree1, h1);	torture_assert_ntstatus_equal_goto(torture, status, NT_STATUS_OK,					   ret, done, "smb2_create");done:	smb2_deltree(tree1, BASEDIR);	return ret;}