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

/*  try the various request blobs */static bool test_create_blob(struct torture_context *tctx, struct smb2_tree *tree){	struct smb2_create io;	NTSTATUS status;	smb2_deltree(tree, FNAME);	ZERO_STRUCT(io);	io.in.desired_access     = SEC_FLAG_MAXIMUM_ALLOWED;	io.in.file_attributes    = FILE_ATTRIBUTE_NORMAL;	io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;	io.in.share_access = 		NTCREATEX_SHARE_ACCESS_DELETE|		NTCREATEX_SHARE_ACCESS_READ|		NTCREATEX_SHARE_ACCESS_WRITE;	io.in.create_options		= NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |					  NTCREATEX_OPTIONS_ASYNC_ALERT	|					  NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |					  0x00200000;	io.in.fname = FNAME;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "Testing alloc size/n");	io.in.alloc_size = 4096;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_EQUAL(io.out.alloc_size, io.in.alloc_size);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "Testing durable open/n");	io.in.durable_open = true;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "Testing query maximal access/n");	io.in.query_maximal_access = true;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_EQUAL(io.out.maximal_access, 0x001f01ff);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "Testing timewarp/n");	io.in.timewarp = 10000;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);	io.in.timewarp = 0;	torture_comment(tctx, "Testing query_on_disk/n");	io.in.query_on_disk_id = true;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "Testing unknown tag/n");	status = smb2_create_blob_add(tctx, &io.in.blobs,				      "FooO", data_blob(NULL, 0));	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "Testing bad tag length/n");	status = smb2_create_blob_add(tctx, &io.in.blobs,				      "xxx", data_blob(NULL, 0));	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);	smb2_deltree(tree, FNAME);		return true;}

/* * Test for maximum ea size - more than one ea name is checked. * * Additional parameters can be passed, to allow further testing: * *             default * maxeasize    65536   limit the max. size for a single EA name * maxeanames     101   limit of the number of tested names * maxeastart       1   this EA size is used to test for the 1st EA (atm) * maxeadebug       0   if set true, further debug output is done - in addition *                      the testfile is not deleted for further inspection! * * Set some/all of these options on the cmdline with: * --option torture:maxeasize=1024 --option torture:maxeadebug=1 ... * */static bool test_max_eas(struct smbcli_state *cli, struct torture_context *tctx){	NTSTATUS status;	union smb_open io;	const char *fname = BASEDIR "//ea_max.txt";	int fnum = -1;	bool ret = true;	bool err = false;	int       i, j, k, last, total;	DATA_BLOB eablob;	char      *eaname = NULL;	int       maxeasize;	int       maxeanames;	int       maxeastart;	torture_comment(tctx, "TESTING SETFILEINFO MAX. EA_SET/n");	maxeasize  = torture_setting_int(tctx, "maxeasize", 65536);	maxeanames = torture_setting_int(tctx, "maxeanames", 101);	maxeastart = torture_setting_int(tctx, "maxeastart", 1);	maxeadebug = torture_setting_int(tctx, "maxeadebug", 0);	/* Do some sanity check on possibly passed parms */	if (maxeasize <= 0) {		torture_comment(tctx, "Invalid parameter 'maxeasize=%d'",maxeasize);		err = true;	}	if (maxeanames <= 0) {		torture_comment(tctx, "Invalid parameter 'maxeanames=%d'",maxeanames);		err = true;	}	if (maxeastart <= 0) {		torture_comment(tctx, "Invalid parameter 'maxeastart=%d'",maxeastart);		err = true;	}	if (maxeadebug < 0) {		torture_comment(tctx, "Invalid parameter 'maxeadebug=%d'",maxeadebug);		err = true;	}	if (err) {	  torture_comment(tctx, "/n/n");	  goto done;	}	if (maxeastart > maxeasize) {		maxeastart = maxeasize;		torture_comment(tctx, "'maxeastart' outside range - corrected to %d/n",			maxeastart);	}	torture_comment(tctx, "MAXEA parms: maxeasize=%d maxeanames=%d maxeastart=%d"	       " maxeadebug=%d/n", maxeasize, maxeanames, maxeastart,	       maxeadebug);	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access =		NTCREATEX_SHARE_ACCESS_READ |		NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname;	status = smb_raw_open(cli->tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum = io.ntcreatex.out.file.fnum;	eablob = data_blob_talloc(tctx, NULL, maxeasize);	if (eablob.data == NULL) {		goto done;	}	/*	 * Fill in some EA data - the offset could be easily checked	 * during a hexdump.	 */	for (i = 0, k = 0; i < eablob.length / 4; i++, k+=4) {		eablob.data[k]   = k & 0xff;		eablob.data[k+1] = (k >>  8) & 0xff;		eablob.data[k+2] = (k >> 16) & 0xff;		eablob.data[k+3] = (k >> 24) & 0xff;//.........这里部分代码省略.........

// Parse the XSVF, reversing the byte-ordering of all the bytestreams.//static FLStatus xsvfSwapBytes(XC *xc, struct Buffer *outBuf, uint32 *maxBufSize, const char **error) {	FLStatus fStatus, retVal = FL_SUCCESS;	uint32 newXSize = 0, curXSize = 0, totOffset = 0;	uint32 numBytes;	BufferStatus bStatus;	uint8 thisByte;	uint32 dummy;	bool zeroMask = false;	if ( !maxBufSize ) {		maxBufSize = &dummy;	}	*maxBufSize = 0;	thisByte = getNextByte(xc);	while ( thisByte != XCOMPLETE ) {		switch ( thisByte ) {		case XTDOMASK:{			// Swap the XTDOMASK bytes.			uint32 initLength;			const uint8 *p;			const uint8 *end;			if ( newXSize != curXSize ) {				curXSize = newXSize;				sendXSize(outBuf, curXSize, error);			}			initLength = (uint32)outBuf->length;			numBytes = bitsToBytes(curXSize);			bStatus = bufAppendByte(outBuf, XTDOMASK, error);			CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");			fStatus = swapBytes(xc, numBytes, outBuf, error);			CHECK_STATUS(fStatus, fStatus, cleanup, "xsvfSwapBytes()");			p = outBuf->data + initLength + 1;			end = outBuf->data + outBuf->length;			while ( *p == 0 && p < end ) p++;			if ( p == end ) {				// All zeros so delete the command				outBuf->length = initLength;				zeroMask = true;			} else {				// Keep the command				if ( numBytes > *maxBufSize ) {					*maxBufSize = numBytes;				}				zeroMask = false;			}			break;		}		case XSDRTDO:			// Swap the tdiValue and tdoExpected bytes.			if ( newXSize != curXSize ) {				curXSize = newXSize;				sendXSize(outBuf, curXSize, error);			}			numBytes = bitsToBytes(curXSize);			if ( zeroMask ) {				// The last mask was all zeros, so replace this XSDRTDO with an XSDR and throw away				// the tdoExpected bytes.				bStatus = bufAppendByte(outBuf, XSDR, error);				CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");				fStatus = swapBytes(xc, numBytes, outBuf, error);				CHECK_STATUS(fStatus, fStatus, cleanup, "xsvfSwapBytes()");				while ( numBytes-- ) {					getNextByte(xc);				}			} else {				// The last mask was not all zeros, so we must honour the XSDRTDO's tdoExpected bytes.				CHECK_STATUS(					numBytes > BUF_SIZE, FL_UNSUPPORTED_SIZE_ERR, cleanup,					"xsvfSwapBytes(): Previous mask was nonzero, but no room to compare %d bytes", numBytes);				if ( numBytes > *maxBufSize ) {					*maxBufSize = numBytes;				}				bStatus = bufAppendByte(outBuf, XSDRTDO, error);				CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");				fStatus = swapAndInterleaveBytes(xc, numBytes, outBuf, error);				CHECK_STATUS(fStatus, fStatus, cleanup, "xsvfSwapBytes()");			}			break;		case XREPEAT:			// Drop XREPEAT for now. Will probably be needed for CPLDs.			getNextByte(xc);			break;					case XRUNTEST:			// Copy the XRUNTEST bytes as-is.			bStatus = bufAppendByte(outBuf, XRUNTEST, error);			CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");			bStatus = bufAppendByte(outBuf, getNextByte(xc), error);			CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");			bStatus = bufAppendByte(outBuf, getNextByte(xc), error);			CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");			bStatus = bufAppendByte(outBuf, getNextByte(xc), error);			CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");			bStatus = bufAppendByte(outBuf, getNextByte(xc), error);			CHECK_STATUS(bStatus, FL_ALLOC_ERR, cleanup, "xsvfSwapBytes()");			break;//.........这里部分代码省略.........

static bool test_session_expire1(struct torture_context *tctx){	NTSTATUS status;	bool ret = false;	struct smbcli_options options;	const char *host = torture_setting_string(tctx, "host", NULL);	const char *share = torture_setting_string(tctx, "share", NULL);	struct cli_credentials *credentials = cmdline_credentials;	struct smb2_tree *tree = NULL;	enum credentials_use_kerberos use_kerberos;	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	union smb_fileinfo qfinfo;	size_t i;	use_kerberos = cli_credentials_get_kerberos_state(credentials);	if (use_kerberos != CRED_MUST_USE_KERBEROS) {		torture_warning(tctx, "smb2.session.expire1 requires -k yes!");		torture_skip(tctx, "smb2.session.expire1 requires -k yes!");	}	torture_assert_int_equal(tctx, use_kerberos, CRED_MUST_USE_KERBEROS,				 "please use -k yes");	lpcfg_set_option(tctx->lp_ctx, "gensec_gssapi:requested_life_time=4");	lpcfg_smbcli_options(tctx->lp_ctx, &options);	status = smb2_connect(tctx,			      host,			      lpcfg_smb_ports(tctx->lp_ctx),			      share,			      lpcfg_resolve_context(tctx->lp_ctx),			      credentials,			      &tree,			      tctx->ev,			      &options,			      lpcfg_socket_options(tctx->lp_ctx),			      lpcfg_gensec_settings(tctx, tctx->lp_ctx)			      );	torture_assert_ntstatus_ok_goto(tctx, status, ret, done,					"smb2_connect failed");	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_expire1_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	io1.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;	status = smb2_create(tree, tctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	/* get the security descriptor */	ZERO_STRUCT(qfinfo);	qfinfo.access_information.level = RAW_FILEINFO_ACCESS_INFORMATION;	qfinfo.access_information.in.file.handle = _h1;	for (i=0; i < 2; i++) {		torture_comment(tctx, "query info => OK/n");		ZERO_STRUCT(qfinfo.access_information.out);		status = smb2_getinfo_file(tree, tctx, &qfinfo);		CHECK_STATUS(status, NT_STATUS_OK);		torture_comment(tctx, "sleep 5 seconds/n");		smb_msleep(5*1000);		torture_comment(tctx, "query info => EXPIRED/n");		ZERO_STRUCT(qfinfo.access_information.out);		status = smb2_getinfo_file(tree, tctx, &qfinfo);		CHECK_STATUS(status, NT_STATUS_NETWORK_SESSION_EXPIRED);		/*		 * the krb5 library may not handle expired creds		 * well, lets start with an empty ccache.		 */		cli_credentials_invalidate_ccache(credentials, CRED_SPECIFIED);		torture_comment(tctx, "reauth => OK/n");		status = smb2_session_setup_spnego(tree->session,						   credentials,						   0 /* previous_session_id */);		CHECK_STATUS(status, NT_STATUS_OK);	}	ZERO_STRUCT(qfinfo.access_information.out);	status = smb2_getinfo_file(tree, tctx, &qfinfo);//.........这里部分代码省略.........

/*! * /brief Initializes a channel * * This function initializes the channel and the communication parameters associated with it. The * function takes variable number of parameters. For example, if channelType is I2C then the * number of variable parameters will be equal to the number of members in the structure * ChannelConfig. The variable parameters will be passed to this function in the same order as * they appear in the structure defination * The function performs the USB function specific initialization followed by MPSSE initialization. * Once that is done it will configure MPSSE with the legacy protocol specific initializations(SPI/ * I2C/JTAG) with the help of that parameters that are passed by the caller * * /param[in] Protocol Specifies the protocol type(I2C/SPI/JTAG) * /param[in] handle Handle of the channel * /param[in] varArg1 Clock rate * /param[in] varArg2 Latency timer * /param[in] varArg3 Configuration options * /return status * /sa * /note * /warning */FT_STATUS FT_InitChannel(FT_LegacyProtocol Protocol, FT_HANDLE handle,...){	va_list argumentList;	uint32	clockRate,latencyTimer,configOptions;	FT_STATUS status;	FT_DEVICE ftDevice;	FN_ENTER;	/*initialise the argument list*/	va_start(argumentList,handle);	/*Get the value for Clockrate*/	clockRate = va_arg(argumentList,uint32);	/*latencyTimer*/	latencyTimer = va_arg(argumentList,uint32);	/* The options parameter passed in I2C_Init, SPI_Init */	configOptions = va_arg(argumentList,uint32);	/*Check parameters*/	if((clockRate<MIN_CLOCK_RATE)||(clockRate>MAX_CLOCK_RATE)||(latencyTimer<		MIN_LATENCY_TIMER)||(latencyTimer>MAX_LATENCY_TIMER))				return FT_INVALID_PARAMETER;	/*Get the device type*/	status = Mid_GetFtDeviceType(handle, &ftDevice);	CHECK_STATUS(status);	/*reset the device*/	status = Mid_ResetDevice(handle);	CHECK_STATUS(status);	/*Purge*/	status = Mid_PurgeDevice(handle);	CHECK_STATUS(status);	/*set USB buffer size*/	status = Mid_SetUSBParameters(handle,/		USB_INPUT_BUFFER_SIZE,USB_OUTPUT_BUFFER_SIZE);	CHECK_STATUS(status);	/*sets the special characters for the device,	disable event and error characters*/	status = Mid_SetDeviceSpecialChar(handle,FALSE,DISABLE_EVENT,FALSE,/		DISABLE_CHAR);	CHECK_STATUS(status);	/*SetTimeOut*/#ifdef FT800_HACK//hack from prashanth - changed the read timeout to 0	status = Mid_SetDeviceTimeOut(handle, 0 /		/*DEVICE_READ_TIMEOUT_INFINITE*/,DEVICE_WRITE_TIMEOUT);	CHECK_STATUS(status);#else	status = Mid_SetDeviceTimeOut(handle, 5000 /		/*DEVICE_READ_TIMEOUT_INFINITE*/,DEVICE_WRITE_TIMEOUT);	CHECK_STATUS(status);#endif	/*SetLatencyTimer*/	status = Mid_SetLatencyTimer(handle,(UCHAR)latencyTimer);	CHECK_STATUS(status);	/*ResetMPSSE*/	status = Mid_ResetMPSSE(handle);	CHECK_STATUS(status);	/*EnableMPSSEInterface*/	status = Mid_EnableMPSSEIn(handle);	CHECK_STATUS(status);	/*20110608 - enabling loopback before sync*/	status = Mid_SetDeviceLoopbackState(handle,MID_LOOPBACK_TRUE);	CHECK_STATUS(status);	/*Sync MPSSE */	status = Mid_SyncMPSSE(handle);	CHECK_STATUS(status);	/*wait for USB*/	INFRA_SLEEP(50);	/*set Clock frequency*/	status = Mid_SetClock(handle, ftDevice, clockRate);	CHECK_STATUS(status);	DBG(MSG_INFO, "Mid_SetClock Status Ok return 0x%x/n",(unsigned)status);	INFRA_SLEEP(20);	/*Stop Loop back*/	status = Mid_SetDeviceLoopbackState(handle,MID_LOOPBACK_FALSE);	CHECK_STATUS(status);	DBG(MSG_INFO, "Mid_SetDeviceLoopbackState Status Ok return 0x%x/n",/		(unsigned)status);	status = Mid_EmptyDeviceInputBuff(handle);//.........这里部分代码省略.........

/** * test setting security descriptor after reauth. */bool test_session_reauth4(struct torture_context *tctx, struct smb2_tree *tree){	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	bool ret = true;	union smb_fileinfo qfinfo;	union smb_setfileinfo sfinfo;	struct cli_credentials *anon_creds = NULL;	uint32_t secinfo_flags = SECINFO_OWNER				| SECINFO_GROUP				| SECINFO_DACL				| SECINFO_PROTECTED_DACL				| SECINFO_UNPROTECTED_DACL;	struct security_descriptor *sd1;	struct security_ace ace;	struct dom_sid *extra_sid;	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_reauth4_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	/* get the security descriptor */	ZERO_STRUCT(qfinfo);	qfinfo.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	qfinfo.query_secdesc.in.file.handle = _h1;	qfinfo.query_secdesc.in.secinfo_flags = secinfo_flags;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	sd1 = qfinfo.query_secdesc.out.sd;	/* re-authenticate as anonymous */	anon_creds = cli_credentials_init_anon(mem_ctx);	torture_assert(tctx, (anon_creds != NULL), "talloc error");	status = smb2_session_setup_spnego(tree->session,					   anon_creds,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* give full access on the file to anonymous */	extra_sid = dom_sid_parse_talloc(tctx, SID_NT_ANONYMOUS);	ZERO_STRUCT(ace);	ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;	ace.flags = 0;	ace.access_mask = SEC_STD_ALL | SEC_FILE_ALL;	ace.trustee = *extra_sid;	status = security_descriptor_dacl_add(sd1, &ace);	CHECK_STATUS(status, NT_STATUS_OK);	ZERO_STRUCT(sfinfo);	sfinfo.set_secdesc.level = RAW_SFILEINFO_SEC_DESC;	sfinfo.set_secdesc.in.file.handle = _h1;	sfinfo.set_secdesc.in.secinfo_flags = SECINFO_DACL;	sfinfo.set_secdesc.in.sd = sd1;	status = smb2_setinfo_file(tree, &sfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	/* re-authenticate as original user again */	status = smb2_session_setup_spnego(tree->session,					   cmdline_credentials,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* re-get the security descriptor */	ZERO_STRUCT(qfinfo);	qfinfo.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	qfinfo.query_secdesc.in.file.handle = _h1;	qfinfo.query_secdesc.in.secinfo_flags = secinfo_flags;//.........这里部分代码省略.........

/** * basic test for doing a session reconnect */bool test_session_reconnect1(struct torture_context *tctx, struct smb2_tree *tree){	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_handle _h2;	struct smb2_handle *h2 = NULL;	struct smb2_create io1, io2;	uint64_t previous_session_id;	bool ret = true;	struct smb2_tree *tree2 = NULL;	union smb_fileinfo qfinfo;	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_reconnect_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	/* disconnect, reconnect and then do durable reopen */	previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);	torture_assert_goto(tctx, torture_smb2_connection_ext(tctx, previous_session_id,			    &tree->session->transport->options, &tree2),			    ret, done,			    "session reconnect failed/n");	/* try to access the file via the old handle */	ZERO_STRUCT(qfinfo);	qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;	qfinfo.generic.in.file.handle = _h1;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);	h1 = NULL;	smb2_oplock_create_share(&io2, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree2, mem_ctx, &io2);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));	_h2 = io2.out.file.handle;	h2 = &_h2;done:	if (h1 != NULL) {		smb2_util_close(tree, *h1);	}	if (h2 != NULL) {		smb2_util_close(tree2, *h2);	}	if (tree2 != NULL) {		smb2_util_unlink(tree2, fname);	}	smb2_util_unlink(tree, fname);	talloc_free(tree);	talloc_free(tree2);	talloc_free(mem_ctx);	return ret;}

/*  test tree ops*/static BOOL test_tree(struct smbcli_state *cli, TALLOC_CTX *mem_ctx){	NTSTATUS status;	BOOL ret = True;	const char *share, *host;	struct smbcli_tree *tree;	union smb_tcon tcon;	union smb_open io;	union smb_write wr;	union smb_close cl;	int fnum;	const char *fname = BASEDIR "//test.txt";	uint8_t c = 1;	printf("TESTING TREE HANDLING/n");	if (!torture_setup_dir(cli, BASEDIR)) {		return False;	}	share = lp_parm_string(-1, "torture", "share");	host  = lp_parm_string(-1, "torture", "host");		printf("create a second tree context on the same session/n");	tree = smbcli_tree_init(cli->session, mem_ctx, False);	tcon.generic.level = RAW_TCON_TCONX;	tcon.tconx.in.flags = 0;	tcon.tconx.in.password = data_blob(NULL, 0);	tcon.tconx.in.path = talloc_asprintf(mem_ctx, "////%s//%s", host, share);	tcon.tconx.in.device = "A:";		status = smb_raw_tcon(tree, mem_ctx, &tcon);	CHECK_STATUS(status, NT_STATUS_OK);		tree->tid = tcon.tconx.out.tid;	printf("tid1=%d tid2=%d/n", cli->tree->tid, tree->tid);	printf("try a tconx with a bad device type/n");	tcon.tconx.in.device = "FOO";		status = smb_raw_tcon(tree, mem_ctx, &tcon);	CHECK_STATUS(status, NT_STATUS_BAD_DEVICE_TYPE);	printf("create a file using the new tid/n");	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname;	status = smb_raw_open(tree, mem_ctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum = io.ntcreatex.out.file.fnum;	printf("write using the old tid/n");	wr.generic.level = RAW_WRITE_WRITEX;	wr.writex.in.file.fnum = fnum;	wr.writex.in.offset = 0;	wr.writex.in.wmode = 0;	wr.writex.in.remaining = 0;	wr.writex.in.count = 1;	wr.writex.in.data = &c;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);	printf("write with the new tid/n");	status = smb_raw_write(tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("disconnect the new tid/n");	status = smb_tree_disconnect(tree);	CHECK_STATUS(status, NT_STATUS_OK);	printf("the new tid should not now be accessible/n");	status = smb_raw_write(tree, &wr);	CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);	printf("the fnum should have been auto-closed/n");	cl.close.level = RAW_CLOSE_CLOSE;	cl.close.in.file.fnum = fnum;	cl.close.in.write_time = 0;	status = smb_raw_close(cli->tree, &cl);	CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);	/* close down the new tree */	talloc_free(tree);	done://.........这里部分代码省略.........

/* * Name:     ddr3_tip_pbs * Desc:     PBS * Args:     TBD * Notes: * Returns:  OK if success, other error code if fail. */int ddr3_tip_pbs(u32 dev_num, enum pbs_dir pbs_mode){	u32 res0[MAX_INTERFACE_NUM];	int adll_tap = MEGA / freq_val[medium_freq] / 64;	int pad_num = 0;	enum hws_search_dir search_dir =		(pbs_mode == PBS_RX_MODE) ? HWS_HIGH2LOW : HWS_LOW2HIGH;	enum hws_dir dir = (pbs_mode == PBS_RX_MODE) ? OPER_READ : OPER_WRITE;	int iterations = (pbs_mode == PBS_RX_MODE) ? 31 : 63;	u32 res_valid_mask = (pbs_mode == PBS_RX_MODE) ? 0x1f : 0x3f;	int init_val = (search_dir == HWS_LOW2HIGH) ? 0 : iterations;	enum hws_edge_compare search_edge = EDGE_FP;	u32 pup = 0, bit = 0, if_id = 0, all_lock = 0, cs_num = 0;	int reg_addr = 0;	u32 validation_val = 0;	u32 cs_enable_reg_val[MAX_INTERFACE_NUM];	u16 *mask_results_dq_reg_map = ddr3_tip_get_mask_results_dq_reg();	u8 temp = 0;	struct hws_topology_map *tm = ddr3_get_topology_map();	/* save current cs enable reg val */	for (if_id = 0; if_id <= MAX_INTERFACE_NUM - 1; if_id++) {		VALIDATE_ACTIVE(tm->if_act_mask, if_id);		/* save current cs enable reg val */		CHECK_STATUS(ddr3_tip_if_read			     (dev_num, ACCESS_TYPE_UNICAST, if_id,			      CS_ENABLE_REG, cs_enable_reg_val, MASK_ALL_BITS));		/* enable single cs */		CHECK_STATUS(ddr3_tip_if_write			     (dev_num, ACCESS_TYPE_UNICAST, if_id,			      CS_ENABLE_REG, (1 << 3), (1 << 3)));	}	reg_addr = (pbs_mode == PBS_RX_MODE) ?		(READ_CENTRALIZATION_PHY_REG +		 (effective_cs * CS_REGISTER_ADDR_OFFSET)) :		(WRITE_CENTRALIZATION_PHY_REG +		 (effective_cs * CS_REGISTER_ADDR_OFFSET));	read_adll_value(nominal_adll, reg_addr, MASK_ALL_BITS);	/* stage 1 shift ADLL */	ddr3_tip_ip_training(dev_num, ACCESS_TYPE_MULTICAST,			     PARAM_NOT_CARE, ACCESS_TYPE_MULTICAST,			     PARAM_NOT_CARE, RESULT_PER_BIT,			     HWS_CONTROL_ELEMENT_ADLL, search_dir, dir,			     tm->if_act_mask, init_val, iterations,			     pbs_pattern, search_edge, CS_SINGLE, cs_num,			     train_status);	validation_val = (pbs_mode == PBS_RX_MODE) ? 0x1f : 0;	for (pup = 0; pup < tm->num_of_bus_per_interface; pup++) {		VALIDATE_ACTIVE(tm->bus_act_mask, pup);		for (if_id = 0; if_id <= MAX_INTERFACE_NUM - 1; if_id++) {			VALIDATE_ACTIVE(tm->if_act_mask, if_id);			min_adll_per_pup[if_id][pup] =				(pbs_mode == PBS_RX_MODE) ? 0x1f : 0x3f;			pup_state[if_id][pup] = 0x3;			adll_shift_lock[if_id][pup] = 1;			max_adll_per_pup[if_id][pup] = 0x0;		}	}	/* EBA */	for (pup = 0; pup < tm->num_of_bus_per_interface; pup++) {		VALIDATE_ACTIVE(tm->bus_act_mask, pup);		for (bit = 0; bit < BUS_WIDTH_IN_BITS; bit++) {			CHECK_STATUS(ddr3_tip_if_read				     (dev_num, ACCESS_TYPE_MULTICAST,				      PARAM_NOT_CARE,				      mask_results_dq_reg_map[					      bit + pup * BUS_WIDTH_IN_BITS],				      res0, MASK_ALL_BITS));			for (if_id = 0; if_id <= MAX_INTERFACE_NUM - 1;			     if_id++) {				VALIDATE_ACTIVE(tm->if_act_mask, if_id);				DEBUG_PBS_ENGINE(DEBUG_LEVEL_TRACE,						 ("FP I/F %d, bit:%d, pup:%d res0 0x%x/n",						  if_id, bit, pup,						  res0[if_id]));				if (pup_state[if_id][pup] != 3)					continue;				/* if not EBA state than move to next pup */				if ((res0[if_id] & 0x2000000) == 0) {					DEBUG_PBS_ENGINE(DEBUG_LEVEL_TRACE,							 ("-- Fail Training IP/n"));					/* training machine failed */					pup_state[if_id][pup] = 1;					adll_shift_lock[if_id][pup] = 0;					continue;				}//.........这里部分代码省略.........

static bool test_smb2_open_for_delete(struct torture_context *tctx,				      struct smb2_tree *tree){	union smb_open io;	union smb_fileinfo finfo;	const char *fname = DNAME "//torture_open_for_delete.txt";	NTSTATUS status;	struct smb2_handle h, h1;	bool ret = true;	torture_comment(tctx,		"Checking SMB2_OPEN for delete on a readonly file./n");	smb2_util_unlink(tree, fname);	smb2_deltree(tree, fname);	status = torture_smb2_testdir(tree, DNAME, &h);	CHECK_STATUS(status, NT_STATUS_OK);	/* reasonable default parameters */	ZERO_STRUCT(io.smb2);	io.generic.level = RAW_OPEN_SMB2;	io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;	io.smb2.in.alloc_size = 0;	io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;	io.smb2.in.file_attributes = FILE_ATTRIBUTE_READONLY;	io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;	io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;	io.smb2.in.create_options = 0;	io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;	io.smb2.in.security_flags = 0;	io.smb2.in.fname = fname;	/* Create the readonly file. */	status = smb2_create(tree, tctx, &(io.smb2));	CHECK_STATUS(status, NT_STATUS_OK);	h1 = io.smb2.out.file.handle;	CHECK_VAL(io.smb2.out.oplock_level, 0);	io.smb2.in.create_options = 0;	CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);	CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);	smb2_util_close(tree, h1);	/* Now try and open for delete only - should succeed. */	io.smb2.in.desired_access = SEC_STD_DELETE;	io.smb2.in.file_attributes = 0;	io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |				NTCREATEX_SHARE_ACCESS_WRITE |				NTCREATEX_SHARE_ACCESS_DELETE;	io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;	status = smb2_create(tree, tctx, &(io.smb2));	CHECK_STATUS(status, NT_STATUS_OK);	smb2_util_unlink(tree, fname);	smb2_util_close(tree, h1);	smb2_util_unlink(tree, fname);	smb2_deltree(tree, DNAME);	return ret;}

static BOOL test_valid_request(TALLOC_CTX *mem_ctx, struct smb2_tree *tree){	BOOL ret = True;	NTSTATUS status;	struct smb2_handle dh;	struct smb2_notify n;	struct smb2_request *req;	status = smb2_util_roothandle(tree, &dh);	CHECK_STATUS(status, NT_STATUS_OK);	n.in.recursive		= 0x0000;	n.in.buffer_size	= 0x00080000;	n.in.file.handle	= dh;	n.in.completion_filter	= 0x00000FFF;	n.in.unknown		= 0x00000000;	req = smb2_notify_send(tree, &n);	while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {		if (event_loop_once(req->transport->socket->event.ctx) != 0) {			break;		}	}	status = torture_setup_complex_file(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_notify_recv(req, mem_ctx, &n);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(n.out.num_changes, 1);	CHECK_VALUE(n.out.changes[0].action, NOTIFY_ACTION_REMOVED);	CHECK_WIRE_STR(n.out.changes[0].name, FNAME);	/* 	 * if the change response doesn't fit in the buffer	 * NOTIFY_ENUM_DIR is returned.	 */	n.in.buffer_size	= 0x00000000;	req = smb2_notify_send(tree, &n);	while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {		if (event_loop_once(req->transport->socket->event.ctx) != 0) {			break;		}	}	status = torture_setup_complex_file(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_notify_recv(req, mem_ctx, &n);	CHECK_STATUS(status, STATUS_NOTIFY_ENUM_DIR);	/* 	 * if the change response fits in the buffer we get	 * NT_STATUS_OK again	 */	n.in.buffer_size	= 0x00080000;	req = smb2_notify_send(tree, &n);	while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {		if (event_loop_once(req->transport->socket->event.ctx) != 0) {			break;		}	}	status = torture_setup_complex_file(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_notify_recv(req, mem_ctx, &n);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(n.out.num_changes, 3);	CHECK_VALUE(n.out.changes[0].action, NOTIFY_ACTION_REMOVED);	CHECK_WIRE_STR(n.out.changes[0].name, FNAME);	CHECK_VALUE(n.out.changes[1].action, NOTIFY_ACTION_ADDED);	CHECK_WIRE_STR(n.out.changes[1].name, FNAME);	CHECK_VALUE(n.out.changes[2].action, NOTIFY_ACTION_MODIFIED);	CHECK_WIRE_STR(n.out.changes[2].name, FNAME);	/* if the first notify returns NOTIFY_ENUM_DIR, all do */	status = smb2_util_close(tree, dh);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_roothandle(tree, &dh);	CHECK_STATUS(status, NT_STATUS_OK);	n.in.recursive		= 0x0000;	n.in.buffer_size	= 0x00000001;	n.in.file.handle	= dh;	n.in.completion_filter	= 0x00000FFF;	n.in.unknown		= 0x00000000;	req = smb2_notify_send(tree, &n);	while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {		if (event_loop_once(req->transport->socket->event.ctx) != 0) {			break;		}	}	status = torture_setup_complex_file(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);//.........这里部分代码省略.........

static bool test_smb2_open_brlocked(struct torture_context *tctx,				    struct smb2_tree *tree){	union smb_open io, io1;	union smb_lock io2;	struct smb2_lock_element lock[1];	const char *fname = DNAME "//torture_ntcreatex.txt";	NTSTATUS status;	bool ret = true;	struct smb2_handle h;	char b = 42;	torture_comment(tctx,		"Testing SMB2 open with a byte range locked file/n");	smb2_util_unlink(tree, fname);	status = torture_smb2_testdir(tree, DNAME, &h);	CHECK_STATUS(status, NT_STATUS_OK);	ZERO_STRUCT(io.smb2);	io.generic.level = RAW_OPEN_SMB2;	io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;	io.smb2.in.desired_access = 0x2019f;	io.smb2.in.alloc_size = 0;	io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;	io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |		NTCREATEX_SHARE_ACCESS_WRITE;	io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;	io.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;	io.smb2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;	io.smb2.in.security_flags = SMB2_SECURITY_DYNAMIC_TRACKING;	io.smb2.in.fname = fname;	status = smb2_create(tree, tctx, &(io.smb2));	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_write(tree, io.smb2.out.file.handle, &b, 0, 1);	CHECK_STATUS(status, NT_STATUS_OK);	ZERO_STRUCT(io2.smb2);	io2.smb2.level = RAW_LOCK_SMB2;	io2.smb2.in.file.handle = io.smb2.out.file.handle;	io2.smb2.in.lock_count = 1;	ZERO_STRUCT(lock);	lock[0].offset = 0;	lock[0].length = 1;	lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |			SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;	io2.smb2.in.locks = &lock[0];	status = smb2_lock(tree, &(io2.smb2));	CHECK_STATUS(status, NT_STATUS_OK);	ZERO_STRUCT(io1.smb2);	io1.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;	io1.smb2.in.desired_access = 0x20196;	io1.smb2.in.alloc_size = 0;	io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;	io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |		NTCREATEX_SHARE_ACCESS_WRITE;	io1.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;	io1.smb2.in.create_options = 0;	io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;	io1.smb2.in.security_flags = SMB2_SECURITY_DYNAMIC_TRACKING;	io1.smb2.in.fname = fname;	status = smb2_create(tree, tctx, &(io1.smb2));	CHECK_STATUS(status, NT_STATUS_OK);	smb2_util_close(tree, io.smb2.out.file.handle);	smb2_util_close(tree, io1.smb2.out.file.handle);	smb2_util_unlink(tree, fname);	smb2_deltree(tree, DNAME);	return ret;}

/*  test SMB2 open*/static bool test_smb2_open(struct torture_context *tctx,			   struct smb2_tree *tree){	union smb_open io;	union smb_fileinfo finfo;	const char *fname = DNAME "//torture_ntcreatex.txt";	const char *dname = DNAME "//torture_ntcreatex.dir";	NTSTATUS status;	struct smb2_handle h, h1;	bool ret = true;	int i;	struct {		uint32_t create_disp;		bool with_file;		NTSTATUS correct_status;	} open_funcs[] = {		{ NTCREATEX_DISP_SUPERSEDE,     true,  NT_STATUS_OK },		{ NTCREATEX_DISP_SUPERSEDE,     false, NT_STATUS_OK },		{ NTCREATEX_DISP_OPEN,          true,  NT_STATUS_OK },		{ NTCREATEX_DISP_OPEN,          false, NT_STATUS_OBJECT_NAME_NOT_FOUND },		{ NTCREATEX_DISP_CREATE,        true,  NT_STATUS_OBJECT_NAME_COLLISION },		{ NTCREATEX_DISP_CREATE,        false, NT_STATUS_OK },		{ NTCREATEX_DISP_OPEN_IF,       true,  NT_STATUS_OK },		{ NTCREATEX_DISP_OPEN_IF,       false, NT_STATUS_OK },		{ NTCREATEX_DISP_OVERWRITE,     true,  NT_STATUS_OK },		{ NTCREATEX_DISP_OVERWRITE,     false, NT_STATUS_OBJECT_NAME_NOT_FOUND },		{ NTCREATEX_DISP_OVERWRITE_IF,  true,  NT_STATUS_OK },		{ NTCREATEX_DISP_OVERWRITE_IF,  false, NT_STATUS_OK },		{ 6,                            true,  NT_STATUS_INVALID_PARAMETER },		{ 6,                            false, NT_STATUS_INVALID_PARAMETER },	};	torture_comment(tctx, "Checking SMB2 Open/n");	smb2_util_unlink(tree, fname);	smb2_util_rmdir(tree, dname);	status = torture_smb2_testdir(tree, DNAME, &h);	CHECK_STATUS(status, NT_STATUS_OK);	ZERO_STRUCT(io.smb2);	/* reasonable default parameters */	io.generic.level = RAW_OPEN_SMB2;	io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;	io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;	io.smb2.in.alloc_size = 1024*1024;	io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;	io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;	io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;	io.smb2.in.create_options = 0;	io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;	io.smb2.in.security_flags = 0;	io.smb2.in.fname = fname;	/* test the create disposition */	for (i=0; i<ARRAY_SIZE(open_funcs); i++) {		if (open_funcs[i].with_file) {			io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;			status= smb2_create(tree, tctx, &(io.smb2));			if (!NT_STATUS_IS_OK(status)) {				torture_comment(tctx,				    "Failed to create file %s status %s %d/n",				    fname, nt_errstr(status), i);				ret = false;				goto done;			}			smb2_util_close(tree, io.smb2.out.file.handle);		}		io.smb2.in.create_disposition = open_funcs[i].create_disp;		status = smb2_create(tree, tctx, &(io.smb2));		if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {			torture_comment(tctx,			    "(%s) incorrect status %s should be %s (i=%d "			    "with_file=%d open_disp=%d)/n",			 __location__, nt_errstr(status),			nt_errstr(open_funcs[i].correct_status),			i, (int)open_funcs[i].with_file,			(int)open_funcs[i].create_disp);			ret = false;			goto done;		}		if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {			smb2_util_close(tree, io.smb2.out.file.handle);			smb2_util_unlink(tree, fname);		}	}	/* basic field testing */	io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;	status = smb2_create(tree, tctx, &(io.smb2));	CHECK_STATUS(status, NT_STATUS_OK);	h1 = io.smb2.out.file.handle;	CHECK_VAL(io.smb2.out.oplock_level, 0);//.........这里部分代码省略.........

/*  try creating with acls */static bool test_create_acl_ext(struct torture_context *tctx, struct smb2_tree *tree, bool test_dir){	bool ret = true;	struct smb2_create io;	NTSTATUS status;	struct security_ace ace;	struct security_descriptor *sd;	struct dom_sid *test_sid;	union smb_fileinfo q = {};	uint32_t attrib =	    FILE_ATTRIBUTE_HIDDEN |	    FILE_ATTRIBUTE_SYSTEM |	    (test_dir ? FILE_ATTRIBUTE_DIRECTORY : 0);	NTSTATUS (*delete_func)(struct smb2_tree *, const char *) =	    test_dir ? smb2_util_rmdir : smb2_util_unlink;	smb2_deltree(tree, FNAME);	ZERO_STRUCT(io);	io.in.desired_access     = SEC_FLAG_MAXIMUM_ALLOWED;	io.in.file_attributes    = FILE_ATTRIBUTE_NORMAL;	io.in.create_disposition = NTCREATEX_DISP_CREATE;	io.in.share_access = 		NTCREATEX_SHARE_ACCESS_DELETE |		NTCREATEX_SHARE_ACCESS_READ |		NTCREATEX_SHARE_ACCESS_WRITE;	io.in.create_options = NTCREATEX_OPTIONS_ASYNC_ALERT | 0x00200000 |	    (test_dir ?  NTCREATEX_OPTIONS_DIRECTORY :		(NTCREATEX_OPTIONS_NON_DIRECTORY_FILE));	io.in.fname = FNAME;	torture_comment(tctx, "basic create/n");	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	q.query_secdesc.in.file.handle = io.out.file.handle;	q.query_secdesc.in.secinfo_flags = 		SECINFO_OWNER |		SECINFO_GROUP |		SECINFO_DACL;	status = smb2_getinfo_file(tree, tctx, &q);	CHECK_STATUS(status, NT_STATUS_OK);	sd = q.query_secdesc.out.sd;	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	status = delete_func(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "adding a new ACE/n");	test_sid = dom_sid_parse_talloc(tctx, SID_NT_AUTHENTICATED_USERS);	ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;	ace.flags = 0;	ace.access_mask = SEC_STD_ALL;	ace.trustee = *test_sid;	status = security_descriptor_dacl_add(sd, &ace);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "creating a file with an initial ACL/n");	io.in.sec_desc = sd;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	FAIL_UNLESS(smb2_util_verify_sd(tctx, tree, io.out.file.handle, sd));	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	status = delete_func(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "creating with attributes/n");	io.in.sec_desc = NULL;	io.in.file_attributes = attrib;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	FAIL_UNLESS(smb2_util_verify_attrib(tctx, tree, io.out.file.handle, attrib));	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	status = delete_func(tree, FNAME);	CHECK_STATUS(status, NT_STATUS_OK);	torture_comment(tctx, "creating with attributes and ACL/n");	io.in.sec_desc = sd;	io.in.file_attributes = attrib;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);//.........这里部分代码省略.........

bool test_session_reauth1(struct torture_context *tctx, struct smb2_tree *tree){	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	bool ret = true;	union smb_fileinfo qfinfo;	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_reauth1_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	status = smb2_session_setup_spnego(tree->session,					   cmdline_credentials,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* try to access the file via the old handle */	ZERO_STRUCT(qfinfo);	qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;	qfinfo.generic.in.file.handle = _h1;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_session_setup_spnego(tree->session,					   cmdline_credentials,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* try to access the file via the old handle */	ZERO_STRUCT(qfinfo);	qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;	qfinfo.generic.in.file.handle = _h1;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);done:	if (h1 != NULL) {		smb2_util_close(tree, *h1);	}	smb2_util_unlink(tree, fname);	talloc_free(tree);	talloc_free(mem_ctx);	return ret;}

/*  test tree with ulogoff  this demonstrates that a tcon isn't autoclosed by a ulogoff  the tcon can be reused using any other valid session later*/static bool test_tree_ulogoff(struct smbcli_state *cli, struct torture_context *tctx){	NTSTATUS status;	bool ret = true;	const char *share, *host;	struct smbcli_session *session1;	struct smbcli_session *session2;	struct smb_composite_sesssetup setup;	struct smbcli_tree *tree;	union smb_tcon tcon;	union smb_open io;	union smb_write wr;	int fnum1, fnum2;	const char *fname1 = BASEDIR "//test1.txt";	const char *fname2 = BASEDIR "//test2.txt";	uint8_t c = 1;	struct smbcli_session_options options;	printf("TESTING TREE with ulogoff/n");	if (!torture_setup_dir(cli, BASEDIR)) {		return false;	}	share = torture_setting_string(tctx, "share", NULL);	host  = torture_setting_string(tctx, "host", NULL);	lpcfg_smbcli_session_options(tctx->lp_ctx, &options);	printf("create the first new sessions/n");	session1 = smbcli_session_init(cli->transport, tctx, false, options);	setup.in.sesskey = cli->transport->negotiate.sesskey;	setup.in.capabilities = cli->transport->negotiate.capabilities;	setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);	setup.in.credentials = cmdline_credentials;	setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);	status = smb_composite_sesssetup(session1, &setup);	CHECK_STATUS(status, NT_STATUS_OK);	session1->vuid = setup.out.vuid;	printf("vuid1=%d/n", session1->vuid);	printf("create a tree context on the with vuid1/n");	tree = smbcli_tree_init(session1, tctx, false);	tcon.generic.level = RAW_TCON_TCONX;	tcon.tconx.in.flags = 0;	tcon.tconx.in.password = data_blob(NULL, 0);	tcon.tconx.in.path = talloc_asprintf(tctx, "////%s//%s", host, share);	tcon.tconx.in.device = "A:";	status = smb_raw_tcon(tree, tctx, &tcon);	CHECK_STATUS(status, NT_STATUS_OK);	tree->tid = tcon.tconx.out.tid;	printf("tid=%d/n", tree->tid);	printf("create a file using vuid1/n");	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname1;	status = smb_raw_open(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum1 = io.ntcreatex.out.file.fnum;	printf("write using vuid1/n");	wr.generic.level = RAW_WRITE_WRITEX;	wr.writex.in.file.fnum = fnum1;	wr.writex.in.offset = 0;	wr.writex.in.wmode = 0;	wr.writex.in.remaining = 0;	wr.writex.in.count = 1;	wr.writex.in.data = &c;	status = smb_raw_write(tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("ulogoff the vuid1/n");	status = smb_raw_ulogoff(session1);	CHECK_STATUS(status, NT_STATUS_OK);	printf("create the second new sessions/n");	session2 = smbcli_session_init(cli->transport, tctx, false, options);	setup.in.sesskey = cli->transport->negotiate.sesskey;	setup.in.capabilities = cli->transport->negotiate.capabilities;	setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);	setup.in.credentials = cmdline_credentials;	setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);	status = smb_composite_sesssetup(session2, &setup);	CHECK_STATUS(status, NT_STATUS_OK);//.........这里部分代码省略.........

/** * test getting security descriptor after reauth */bool test_session_reauth3(struct torture_context *tctx, struct smb2_tree *tree){	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	bool ret = true;	union smb_fileinfo qfinfo;	struct cli_credentials *anon_creds = NULL;	uint32_t secinfo_flags = SECINFO_OWNER				| SECINFO_GROUP				| SECINFO_DACL				| SECINFO_PROTECTED_DACL				| SECINFO_UNPROTECTED_DACL;	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_reauth3_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	/* get the security descriptor */	ZERO_STRUCT(qfinfo);	qfinfo.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	qfinfo.query_secdesc.in.file.handle = _h1;	qfinfo.query_secdesc.in.secinfo_flags = secinfo_flags;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	/* re-authenticate as anonymous */	anon_creds = cli_credentials_init_anon(mem_ctx);	torture_assert(tctx, (anon_creds != NULL), "talloc error");	status = smb2_session_setup_spnego(tree->session,					   anon_creds,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* try to access the file via the old handle */	ZERO_STRUCT(qfinfo);	qfinfo.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	qfinfo.query_secdesc.in.file.handle = _h1;	qfinfo.query_secdesc.in.secinfo_flags = secinfo_flags;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	/* re-authenticate as original user again */	status = smb2_session_setup_spnego(tree->session,					   cmdline_credentials,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* try to access the file via the old handle */	ZERO_STRUCT(qfinfo);	qfinfo.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	qfinfo.query_secdesc.in.file.handle = _h1;	qfinfo.query_secdesc.in.secinfo_flags = secinfo_flags;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);done:	if (h1 != NULL) {		smb2_util_close(tree, *h1);	}	smb2_util_unlink(tree, fname);	talloc_free(tree);	talloc_free(mem_ctx);	return ret;}

/*  test pid ops  this test demonstrates that exit() only sees the PID  used for the open() calls*/static bool test_pid_exit_only_sees_open(struct smbcli_state *cli, TALLOC_CTX *mem_ctx){	NTSTATUS status;	bool ret = true;	union smb_open io;	union smb_write wr;	union smb_close cl;	int fnum;	const char *fname = BASEDIR "//test.txt";	uint8_t c = 1;	uint16_t pid1, pid2;	printf("TESTING PID HANDLING exit() only cares about open() PID/n");	if (!torture_setup_dir(cli, BASEDIR)) {		return false;	}	pid1 = cli->session->pid;	pid2 = pid1 + 1;	printf("pid1=%d pid2=%d/n", pid1, pid2);	printf("create a file using pid1/n");	cli->session->pid = pid1;	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname;	status = smb_raw_open(cli->tree, mem_ctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum = io.ntcreatex.out.file.fnum;	printf("write using pid2/n");	cli->session->pid = pid2;	wr.generic.level = RAW_WRITE_WRITEX;	wr.writex.in.file.fnum = fnum;	wr.writex.in.offset = 0;	wr.writex.in.wmode = 0;	wr.writex.in.remaining = 0;	wr.writex.in.count = 1;	wr.writex.in.data = &c;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("exit pid2/n");	cli->session->pid = pid2;	status = smb_raw_exit(cli->session);	CHECK_STATUS(status, NT_STATUS_OK);	printf("the fnum should still be accessible via pid2/n");	cli->session->pid = pid2;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("exit pid2/n");	cli->session->pid = pid2;	status = smb_raw_exit(cli->session);	CHECK_STATUS(status, NT_STATUS_OK);	printf("the fnum should still be accessible via pid1 and pid2/n");	cli->session->pid = pid1;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	cli->session->pid = pid2;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("exit pid1/n");	cli->session->pid = pid1;	status = smb_raw_exit(cli->session);	CHECK_STATUS(status, NT_STATUS_OK);	printf("the fnum should not now be accessible via pid1 or pid2/n");	cli->session->pid = pid1;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);	cli->session->pid = pid2;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);	printf("the fnum should have been auto-closed/n");	cli->session->pid = pid1;//.........这里部分代码省略.........

/** * test renaming after reauth. * compare security descriptors before and after rename/reauth */bool test_session_reauth5(struct torture_context *tctx, struct smb2_tree *tree){	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char dname[256];	char fname[256];	char fname2[256];	struct smb2_handle _dh1;	struct smb2_handle *dh1 = NULL;	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	bool ret = true;	bool ok;	union smb_fileinfo qfinfo;	union smb_setfileinfo sfinfo;	struct cli_credentials *anon_creds = NULL;	uint32_t secinfo_flags = SECINFO_OWNER				| SECINFO_GROUP				| SECINFO_DACL				| SECINFO_PROTECTED_DACL				| SECINFO_UNPROTECTED_DACL;	struct security_descriptor *f_sd1;	struct security_descriptor *d_sd1 = NULL;	struct security_ace ace;	struct dom_sid *extra_sid;	/* Add some random component to the file name. */	snprintf(dname, sizeof(dname), "session_reauth5_%s.d",		 generate_random_str(tctx, 8));	snprintf(fname, sizeof(fname), "%s//file.dat", dname);	ok = smb2_util_setup_dir(tctx, tree, dname);	CHECK_VAL(ok, true);	status = torture_smb2_testdir(tree, dname, &_dh1);	CHECK_STATUS(status, NT_STATUS_OK);	dh1 = &_dh1;	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	/* get the security descriptor */	ZERO_STRUCT(qfinfo);	qfinfo.query_secdesc.level = RAW_FILEINFO_SEC_DESC;	qfinfo.query_secdesc.in.file.handle = _h1;	qfinfo.query_secdesc.in.secinfo_flags = secinfo_flags;	status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	f_sd1 = qfinfo.query_secdesc.out.sd;	/* re-authenticate as anonymous */	anon_creds = cli_credentials_init_anon(mem_ctx);	torture_assert(tctx, (anon_creds != NULL), "talloc error");	status = smb2_session_setup_spnego(tree->session,					   anon_creds,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* try to rename the file: fails */	snprintf(fname2, sizeof(fname2), "%s//file2.dat", dname);	smb2_util_unlink(tree, fname2);	ZERO_STRUCT(sfinfo);	sfinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;	sfinfo.rename_information.in.file.handle = _h1;	sfinfo.rename_information.in.overwrite = true;	sfinfo.rename_information.in.new_name = fname2;	status = smb2_setinfo_file(tree, &sfinfo);	CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);	/* re-authenticate as original user again */	status = smb2_session_setup_spnego(tree->session,					   cmdline_credentials,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* give full access on the file to anonymous *///.........这里部分代码省略.........

/*  test session ops*/static bool test_session(struct smbcli_state *cli, struct torture_context *tctx){	NTSTATUS status;	bool ret = true;	struct smbcli_session *session;	struct smbcli_session *session2;	struct smbcli_session *session3;	struct smbcli_session *session4;	struct cli_credentials *anon_creds;	struct smbcli_session *sessions[15];	struct composite_context *composite_contexts[15];	struct smbcli_tree *tree;	struct smb_composite_sesssetup setup;	struct smb_composite_sesssetup setups[15];	struct gensec_settings *gensec_settings;	union smb_open io;	union smb_write wr;	union smb_close cl;	int fnum;	const char *fname = BASEDIR "//test.txt";	uint8_t c = 1;	int i;	struct smbcli_session_options options;	printf("TESTING SESSION HANDLING/n");	if (!torture_setup_dir(cli, BASEDIR)) {		return false;	}	printf("create a second security context on the same transport/n");	lpcfg_smbcli_session_options(tctx->lp_ctx, &options);	gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);	session = smbcli_session_init(cli->transport, tctx, false, options);	setup.in.sesskey = cli->transport->negotiate.sesskey;	setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */	setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);	setup.in.credentials = cmdline_credentials;	setup.in.gensec_settings = gensec_settings;	status = smb_composite_sesssetup(session, &setup);	CHECK_STATUS(status, NT_STATUS_OK);		session->vuid = setup.out.vuid;	printf("create a third security context on the same transport, with vuid set/n");	session2 = smbcli_session_init(cli->transport, tctx, false, options);	session2->vuid = session->vuid;	setup.in.sesskey = cli->transport->negotiate.sesskey;	setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */	setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);	setup.in.credentials = cmdline_credentials;	status = smb_composite_sesssetup(session2, &setup);	CHECK_STATUS(status, NT_STATUS_OK);	session2->vuid = setup.out.vuid;	printf("vuid1=%d vuid2=%d vuid3=%d/n", cli->session->vuid, session->vuid, session2->vuid);		if (cli->transport->negotiate.capabilities & CAP_EXTENDED_SECURITY) {		/* Samba4 currently fails this - we need to determine if this insane behaviour is important */		if (session2->vuid == session->vuid) {			printf("server allows the user to re-use an existing vuid in session setup /n");		}	} else {		CHECK_NOT_VALUE(session2->vuid, session->vuid);	}	talloc_free(session2);	if (cli->transport->negotiate.capabilities & CAP_EXTENDED_SECURITY) {		printf("create a fourth security context on the same transport, without extended security/n");		session3 = smbcli_session_init(cli->transport, tctx, false, options);		session3->vuid = session->vuid;		setup.in.sesskey = cli->transport->negotiate.sesskey;		setup.in.capabilities &= ~CAP_EXTENDED_SECURITY; /* force a non extended security login (should fail) */		setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);			setup.in.credentials = cmdline_credentials;		status = smb_composite_sesssetup(session3, &setup);		CHECK_STATUS(status, NT_STATUS_LOGON_FAILURE);		printf("create a fouth anonymous security context on the same transport, without extended security/n");		session4 = smbcli_session_init(cli->transport, tctx, false, options);		session4->vuid = session->vuid;		setup.in.sesskey = cli->transport->negotiate.sesskey;		setup.in.capabilities &= ~CAP_EXTENDED_SECURITY; /* force a non extended security login (should fail) */		setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);		//.........这里部分代码省略.........

/** * do reauth with wrong credentials, * hence triggering the error path in reauth. * The invalid reauth deletes the session. */bool test_session_reauth6(struct torture_context *tctx, struct smb2_tree *tree){	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	bool ret = true;	char *corrupted_password;	struct cli_credentials *broken_creds;	bool ok;	bool encrypted;	NTSTATUS expected;	enum credentials_use_kerberos krb_state;	krb_state = cli_credentials_get_kerberos_state(cmdline_credentials);	if (krb_state == CRED_MUST_USE_KERBEROS) {		torture_skip(tctx,			     "Can't test failing session setup with kerberos.");	}	encrypted = smb2cli_tcon_is_encryption_on(tree->smbXcli);	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_reauth1_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	io1.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	/*	 * reauthentication with invalid credentials:	 */	broken_creds = cli_credentials_shallow_copy(mem_ctx,						    cmdline_credentials);	torture_assert(tctx, (broken_creds != NULL), "talloc error");	corrupted_password = talloc_asprintf(mem_ctx, "%s%s",				cli_credentials_get_password(broken_creds),				"corrupt");	torture_assert(tctx, (corrupted_password != NULL), "talloc error");	ok = cli_credentials_set_password(broken_creds, corrupted_password,					  CRED_SPECIFIED);	CHECK_VAL(ok, true);	status = smb2_session_setup_spnego(tree->session,					   broken_creds,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_LOGON_FAILURE);	torture_comment(tctx, "did failed reauth/n");	/*	 * now verify that the invalid session reauth has closed our session	 */	if (encrypted) {		expected = NT_STATUS_CONNECTION_DISCONNECTED;	} else {		expected = NT_STATUS_USER_SESSION_DELETED;	}	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree, mem_ctx, &io1);	CHECK_STATUS(status, expected);done:	if (h1 != NULL) {		smb2_util_close(tree, *h1);	}	smb2_util_unlink(tree, fname);	talloc_free(tree);	talloc_free(mem_ctx);	return ret;}

/*  test pid ops with 2 sessions*/static bool test_pid_2sess(struct smbcli_state *cli, struct torture_context *tctx){	NTSTATUS status;	bool ret = true;	struct smbcli_session *session;	struct smb_composite_sesssetup setup;	union smb_open io;	union smb_write wr;	union smb_close cl;	int fnum;	const char *fname = BASEDIR "//test.txt";	uint8_t c = 1;	uint16_t vuid1, vuid2;	struct smbcli_session_options options;	printf("TESTING PID HANDLING WITH 2 SESSIONS/n");	if (!torture_setup_dir(cli, BASEDIR)) {		return false;	}	lpcfg_smbcli_session_options(tctx->lp_ctx, &options);	printf("create a second security context on the same transport/n");	session = smbcli_session_init(cli->transport, tctx, false, options);	setup.in.sesskey = cli->transport->negotiate.sesskey;	setup.in.capabilities = cli->transport->negotiate.capabilities; /* ignored in secondary session setup, except by our libs, which care about the extended security bit */	setup.in.workgroup = lpcfg_workgroup(tctx->lp_ctx);	setup.in.credentials = cmdline_credentials;	setup.in.gensec_settings = lpcfg_gensec_settings(tctx, tctx->lp_ctx);	status = smb_composite_sesssetup(session, &setup);	CHECK_STATUS(status, NT_STATUS_OK);		session->vuid = setup.out.vuid;	vuid1 = cli->session->vuid;	vuid2 = session->vuid;	printf("vuid1=%d vuid2=%d/n", vuid1, vuid2);	printf("create a file using the vuid1/n");	cli->session->vuid = vuid1;	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname;	status = smb_raw_open(cli->tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum = io.ntcreatex.out.file.fnum;	printf("write using the vuid1 (fnum=%d)/n", fnum);	cli->session->vuid = vuid1;	wr.generic.level = RAW_WRITE_WRITEX;	wr.writex.in.file.fnum = fnum;	wr.writex.in.offset = 0;	wr.writex.in.wmode = 0;	wr.writex.in.remaining = 0;	wr.writex.in.count = 1;	wr.writex.in.data = &c;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("exit the pid with vuid2/n");	cli->session->vuid = vuid2;	status = smb_raw_exit(cli->session);	CHECK_STATUS(status, NT_STATUS_OK);	printf("the fnum should still be accessible/n");	cli->session->vuid = vuid1;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("exit the pid with vuid1/n");	cli->session->vuid = vuid1;	status = smb_raw_exit(cli->session);	CHECK_STATUS(status, NT_STATUS_OK);	printf("the fnum should not now be accessible/n");	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_INVALID_HANDLE);	printf("the fnum should have been auto-closed/n");	cl.close.level = RAW_CLOSE_CLOSE;	cl.close.in.file.fnum = fnum;	cl.close.in.write_time = 0;//.........这里部分代码省略.........

/*! * /brief Opens a channel and returns a handle to it * * This function opens the indexed channel and returns a handle to it * * /param[in] Protocol Specifies the protocol type(I2C/SPI/JTAG) * /param[in] index Index of the channel * /param[out] handle Pointer to the handle * /return status * /sa * /note Trying to open an already open channel will return an error code * /warning */FT_STATUS FT_OpenChannel(FT_LegacyProtocol Protocol, uint32 index,			FT_HANDLE *handle){	/* Opens a channel and returns the pointer to its handle */	uint32 tempNumChannels,channelCount;	FT_DEVICE_LIST_INFO_NODE *pDeviceList;	FT_DEVICE_LIST_INFO_NODE deviceList;	FT_STATUS status;	uint32 devLoop = MID_NO_CHANNEL_FOUND;	FN_ENTER;	/*initalize *numChansto 0 */	channelCount = MID_NO_CHANNEL_FOUND;	/*Get the number of devices connected to the system(FT_CreateDeviceInfoList)*/	status = varFunctionPtrLst.p_FT_GetNumChannel(&tempNumChannels);	CHECK_STATUS(status);	/*Check if No of channel is greater than 0*/	if(tempNumChannels >= index)	{		/*Allocate space for getting the information about the device (based on		number of devices)*/		pDeviceList = INFRA_MALLOC(sizeof(FT_DEVICE_LIST_INFO_NODE)/			*tempNumChannels);		if(NULL == pDeviceList)		{			return FT_INSUFFICIENT_RESOURCES;		}		/*get the devices information(FT_GetDeviceInfoList)*/		status = varFunctionPtrLst.p_FT_GetDeviceInfoList(pDeviceList,/			&tempNumChannels);		CHECK_STATUS(status);		/*loop until No of devices */		while(devLoop < tempNumChannels)		{			deviceList = pDeviceList[devLoop];			/*check if device is I2C*/			if(Mid_CheckMPSSEAvailable(deviceList))			{				/*increment *numChans*/				channelCount++;			}			/*check if the index matches the I2C channel count*/			if(channelCount == index)			{				/*call FT_Open*/				status = varFunctionPtrLst.p_FT_Open(devLoop,handle);                break;            }			devLoop++;		}		INFRA_FREE(pDeviceList);	}	else	{		/* The index of the device is greater than the max number of devices available */		return FT_INVALID_HANDLE;	}	FN_EXIT;	/*return status*/	return status;}

/*  test pid ops with 2 tcons*/static bool test_pid_2tcon(struct smbcli_state *cli, struct torture_context *tctx){	NTSTATUS status;	bool ret = true;	const char *share, *host;	struct smbcli_tree *tree;	union smb_tcon tcon;	union smb_open io;	union smb_write wr;	union smb_close cl;	int fnum1, fnum2;	const char *fname1 = BASEDIR "//test1.txt";	const char *fname2 = BASEDIR "//test2.txt";	uint8_t c = 1;	uint16_t tid1, tid2;	printf("TESTING PID HANDLING WITH 2 TCONS/n");	if (!torture_setup_dir(cli, BASEDIR)) {		return false;	}	share = torture_setting_string(tctx, "share", NULL);	host  = torture_setting_string(tctx, "host", NULL);		printf("create a second tree context on the same session/n");	tree = smbcli_tree_init(cli->session, tctx, false);	tcon.generic.level = RAW_TCON_TCONX;	tcon.tconx.in.flags = 0;	tcon.tconx.in.password = data_blob(NULL, 0);	tcon.tconx.in.path = talloc_asprintf(tctx, "////%s//%s", host, share);	tcon.tconx.in.device = "A:";		status = smb_raw_tcon(tree, tctx, &tcon);	CHECK_STATUS(status, NT_STATUS_OK);		tree->tid = tcon.tconx.out.tid;	tid1 = cli->tree->tid;	tid2 = tree->tid;	printf("tid1=%d tid2=%d/n", tid1, tid2);	printf("create a file using the tid1/n");	cli->tree->tid = tid1;	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname1;	status = smb_raw_open(cli->tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum1 = io.ntcreatex.out.file.fnum;	printf("write using the tid1/n");	wr.generic.level = RAW_WRITE_WRITEX;	wr.writex.in.file.fnum = fnum1;	wr.writex.in.offset = 0;	wr.writex.in.wmode = 0;	wr.writex.in.remaining = 0;	wr.writex.in.count = 1;	wr.writex.in.data = &c;	status = smb_raw_write(cli->tree, &wr);	CHECK_STATUS(status, NT_STATUS_OK);	CHECK_VALUE(wr.writex.out.nwritten, 1);	printf("create a file using the tid2/n");	cli->tree->tid = tid2;	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname2;	status = smb_raw_open(cli->tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum2 = io.ntcreatex.out.file.fnum;	printf("write using the tid2/n");	wr.generic.level = RAW_WRITE_WRITEX;	wr.writex.in.file.fnum = fnum2;	wr.writex.in.offset = 0;	wr.writex.in.wmode = 0;	wr.writex.in.remaining = 0;//.........这里部分代码省略.........

FT_STATUS Mid_SendReceiveCmdFromMPSSE(FT_HANDLE handle, UCHAR echoCmdFlag,UCHAR ecoCmd,UCHAR *cmdEchoed){	FT_STATUS status;	DWORD bytesInInputBuf = 0;	DWORD numOfBytesRead = 0;	DWORD bytesWritten;	DWORD byteCounter;	UCHAR cmdResponse = MID_CMD_NOT_ECHOED;	int loopCounter = 0;	UCHAR *readBuffer=NULL;	FN_ENTER;	readBuffer = (UCHAR*)INFRA_MALLOC(MID_MAX_IN_BUF_SIZE);	if(NULL == readBuffer)	{		return FT_INSUFFICIENT_RESOURCES;	}	/*initialize cmdEchoed to MID_CMD_NOT_ECHOED*/	*cmdEchoed = MID_CMD_NOT_ECHOED;	/* check whether command has to be sent only once*/	if (echoCmdFlag == MID_ECHO_COMMAND_ONCE)	{		status = varFunctionPtrLst.p_FT_Write(handle,&ecoCmd,1,&bytesWritten);		CHECK_STATUS(status);	}	do	{		DBG(MSG_DEBUG,"In Loop Mid_SendReceiveCmdFromMPSSE loopCounter = %d /n"/			,loopCounter);		/*check whether command has to be sent every time in the loop*/		if(echoCmdFlag == MID_ECHO_COMMAND_CONTINUOUSLY)		{		  status = varFunctionPtrLst.p_FT_Write(handle,&ecoCmd,1,&bytesWritten);		 CHECK_STATUS(status);		}		/*read the no of bytes available in Receive buffer*/		status = varFunctionPtrLst.p_FT_GetQueueStatus(handle,&bytesInInputBuf);		CHECK_STATUS(status);		INFRA_SLEEP(1);		DBG(MSG_DEBUG,"bytesInInputBuf size =  %d/n",bytesInInputBuf);		if(bytesInInputBuf >0)		{			MID_CHK_IN_BUF_OK(bytesInInputBuf);			status = varFunctionPtrLst.p_FT_Read(handle,readBuffer,bytesInInputBuf,&numOfBytesRead);			CHECK_STATUS(status);			if(numOfBytesRead >0)			{				byteCounter = 0;				do				{					if(byteCounter <= (numOfBytesRead-1))                    {						if(readBuffer[byteCounter]==MID_BAD_COMMAND_RESPONSE)                        {							cmdResponse = MID_BAD_COMMAND_RESPONSE;						}						else						{							if(cmdResponse == MID_BAD_COMMAND_RESPONSE)							{								if(readBuffer[byteCounter]==ecoCmd)								{                                    *cmdEchoed = MID_CMD_ECHOED;                                }							}							cmdResponse = MID_CMD_NOT_ECHOED;                        }					}					byteCounter++;				}while((byteCounter < bytesInInputBuf)&&(*cmdEchoed == MID_CMD_NOT_ECHOED));			}		}		/*for breaking the loop */		loopCounter++;		if(loopCounter > MID_MAX_IN_BUF_SIZE)		{			DBG(MSG_DEBUG,"Loop breaked after executing %u times/n",(unsigned)MID_MAX_IN_BUF_SIZE);			status = FT_OTHER_ERROR;			break;		}	}while((*cmdEchoed == MID_CMD_NOT_ECHOED) && (status == FT_OK));	if(NULL != readBuffer)	{		INFRA_FREE(readBuffer);//Bug12	}	FN_EXIT;    return status;}

IoObject *IoCairoSurfacePattern_setFilter(IoCairoSurfacePattern *self, IoObject *locals, IoMessage *m){	cairo_pattern_set_filter(PATTERN(self), IoMessage_locals_intArgAt_(m, locals, 0));	CHECK_STATUS(self);	return self;}

static bool test_eas(struct smbcli_state *cli, struct torture_context *tctx){	NTSTATUS status;	union smb_setfileinfo setfile;	union smb_open io;	const char *fname = BASEDIR "//ea.txt";	bool ret = true;	int fnum = -1;	torture_comment(tctx, "TESTING SETFILEINFO EA_SET/n");	io.generic.level = RAW_OPEN_NTCREATEX;	io.ntcreatex.in.root_fid.fnum = 0;	io.ntcreatex.in.flags = 0;	io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;	io.ntcreatex.in.create_options = 0;	io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;	io.ntcreatex.in.share_access =		NTCREATEX_SHARE_ACCESS_READ |		NTCREATEX_SHARE_ACCESS_WRITE;	io.ntcreatex.in.alloc_size = 0;	io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;	io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;	io.ntcreatex.in.security_flags = 0;	io.ntcreatex.in.fname = fname;	status = smb_raw_open(cli->tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	fnum = io.ntcreatex.out.file.fnum;	ret &= check_ea(cli, fname, "EAONE", NULL);	torture_comment(tctx, "Adding first two EAs/n");	setfile.generic.level = RAW_SFILEINFO_EA_SET;	setfile.generic.in.file.fnum = fnum;	setfile.ea_set.in.num_eas = 2;	setfile.ea_set.in.eas = talloc_array(tctx, struct ea_struct, 2);	setfile.ea_set.in.eas[0].flags = 0;	setfile.ea_set.in.eas[0].name.s = "EAONE";	setfile.ea_set.in.eas[0].value = data_blob_string_const("VALUE1");	setfile.ea_set.in.eas[1].flags = 0;	setfile.ea_set.in.eas[1].name.s = "SECONDEA";	setfile.ea_set.in.eas[1].value = data_blob_string_const("ValueTwo");	status = smb_raw_setfileinfo(cli->tree, &setfile);	CHECK_STATUS(status, NT_STATUS_OK);	ret &= check_ea(cli, fname, "EAONE", "VALUE1");	ret &= check_ea(cli, fname, "SECONDEA", "ValueTwo");	torture_comment(tctx, "Modifying 2nd EA/n");	setfile.ea_set.in.num_eas = 1;	setfile.ea_set.in.eas[0].name.s = "SECONDEA";	setfile.ea_set.in.eas[0].value = data_blob_string_const(" Changed Value");	status = smb_raw_setfileinfo(cli->tree, &setfile);	CHECK_STATUS(status, NT_STATUS_OK);	ret &= check_ea(cli, fname, "EAONE", "VALUE1");	ret &= check_ea(cli, fname, "SECONDEA", " Changed Value");	torture_comment(tctx, "Setting a NULL EA/n");	setfile.ea_set.in.eas[0].value = data_blob(NULL, 0);	setfile.ea_set.in.eas[0].name.s = "NULLEA";	status = smb_raw_setfileinfo(cli->tree, &setfile);	CHECK_STATUS(status, NT_STATUS_OK);	ret &= check_ea(cli, fname, "EAONE", "VALUE1");	ret &= check_ea(cli, fname, "SECONDEA", " Changed Value");	ret &= check_ea(cli, fname, "NULLEA", NULL);	torture_comment(tctx, "Deleting first EA/n");	setfile.ea_set.in.eas[0].flags = 0;	setfile.ea_set.in.eas[0].name.s = "EAONE";	setfile.ea_set.in.eas[0].value = data_blob(NULL, 0);	status = smb_raw_setfileinfo(cli->tree, &setfile);	CHECK_STATUS(status, NT_STATUS_OK);	ret &= check_ea(cli, fname, "EAONE", NULL);	ret &= check_ea(cli, fname, "SECONDEA", " Changed Value");	torture_comment(tctx, "Deleting second EA/n");	setfile.ea_set.in.eas[0].flags = 0;	setfile.ea_set.in.eas[0].name.s = "SECONDEA";	setfile.ea_set.in.eas[0].value = data_blob(NULL, 0);	status = smb_raw_setfileinfo(cli->tree, &setfile);	CHECK_STATUS(status, NT_STATUS_OK);	ret &= check_ea(cli, fname, "EAONE", NULL);	ret &= check_ea(cli, fname, "SECONDEA", NULL);done:	smbcli_close(cli->tree, fnum);	return ret;}

bool test_session_bind1(struct torture_context *tctx, struct smb2_tree *tree1){	const char *host = torture_setting_string(tctx, "host", NULL);	const char *share = torture_setting_string(tctx, "share", NULL);	struct cli_credentials *credentials = cmdline_credentials;	NTSTATUS status;	TALLOC_CTX *mem_ctx = talloc_new(tctx);	char fname[256];	struct smb2_handle _h1;	struct smb2_handle *h1 = NULL;	struct smb2_create io1;	union smb_fileinfo qfinfo;	bool ret = false;	struct smb2_tree *tree2 = NULL;	struct smb2_transport *transport1 = tree1->session->transport;	struct smb2_transport *transport2 = NULL;	struct smb2_session *session1_1 = tree1->session;	struct smb2_session *session1_2 = NULL;	struct smb2_session *session2_1 = NULL;	struct smb2_session *session2_2 = NULL;	uint32_t caps;	caps = smb2cli_conn_server_capabilities(transport1->conn);	if (!(caps & SMB2_CAP_MULTI_CHANNEL)) {		torture_skip(tctx, "server doesn't support SMB2_CAP_MULTI_CHANNEL/n");	}	/* Add some random component to the file name. */	snprintf(fname, sizeof(fname), "session_bind1_%s.dat",		 generate_random_str(tctx, 8));	smb2_util_unlink(tree1, fname);	smb2_oplock_create_share(&io1, fname,				 smb2_util_share_access(""),				 smb2_util_oplock_level("b"));	status = smb2_create(tree1, mem_ctx, &io1);	CHECK_STATUS(status, NT_STATUS_OK);	_h1 = io1.out.file.handle;	h1 = &_h1;	CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);	CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));	status = smb2_connect(tctx,			      host,			      lpcfg_smb_ports(tctx->lp_ctx),			      share,			      lpcfg_resolve_context(tctx->lp_ctx),			      credentials,			      &tree2,			      tctx->ev,			      &transport1->options,			      lpcfg_socket_options(tctx->lp_ctx),			      lpcfg_gensec_settings(tctx, tctx->lp_ctx)			      );	torture_assert_ntstatus_ok_goto(tctx, status, ret, done,					"smb2_connect failed");	session2_2 = tree2->session;	transport2 = tree2->session->transport;	/*	 * Now bind the 2nd transport connection to the 1st session	 */	session1_2 = smb2_session_channel(transport2,					  lpcfg_gensec_settings(tctx, tctx->lp_ctx),					  tree2,					  session1_1);	torture_assert(tctx, session1_2 != NULL, "smb2_session_channel failed");	status = smb2_session_setup_spnego(session1_2,					   cmdline_credentials,					   0 /* previous_session_id */);	CHECK_STATUS(status, NT_STATUS_OK);	/* use the 1st connection, 1st session */	ZERO_STRUCT(qfinfo);	qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;	qfinfo.generic.in.file.handle = _h1;	tree1->session = session1_1;	status = smb2_getinfo_file(tree1, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	/* use the 2nd connection, 1st session */	ZERO_STRUCT(qfinfo);	qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;	qfinfo.generic.in.file.handle = _h1;	tree1->session = session1_2;	status = smb2_getinfo_file(tree1, mem_ctx, &qfinfo);	CHECK_STATUS(status, NT_STATUS_OK);	tree1->session = session1_1;	smb2_util_close(tree1, *h1);	h1 = NULL;	/*	 * Now bind the 1st transport connection to the 2nd session	 */	session2_1 = smb2_session_channel(transport1,					  lpcfg_gensec_settings(tctx, tctx->lp_ctx),//.........这里部分代码省略.........

voidmain(int argc, char *argv[]){	int set = -1, enable = -1;	int seg = 0, bus = 0, dev = 2, fn = 0, pin = 0;	ACPI_STATUS status;	int verbose = 0;	AcpiDbgLevel = 0;	ARGBEGIN{	case 'v':		AcpiDbgLevel = ACPI_LV_VERBOSITY1;		verbose++;		break;	case 's':		set = open("#P/irqmap", OWRITE);		if (set < 0)			sysfatal("%r");		break;	default:		sysfatal("usage: acpi/irq [-v] [-s]");		break;	}ARGEND;	status = AcpiInitializeSubsystem();	if (ACPI_FAILURE(status)) {		sysfatal("Error %d/n", status);	}        status = AcpiInitializeTables(NULL, 0, FALSE);        if (ACPI_FAILURE(status))		sysfatal("can't set up acpi tables: %d", status);	if (verbose)		print("init dables/n");         status = AcpiLoadTables();        if (ACPI_FAILURE(status))		sysfatal("Can't load ACPI tables: %d", status);	/* from acpi: */    	/* If the Hardware Reduced flag is set, machine is always in acpi mode */	AcpiGbl_ReducedHardware = 1;	if (verbose) 		print("LOADED TABLES./n");        status = AcpiEnableSubsystem(0);        if (ACPI_FAILURE(status))		print("Probably does not matter: Can't enable ACPI subsystem");	if (verbose)		print("enabled subsystem./n");        status = AcpiInitializeObjects(0);        if (ACPI_FAILURE(status))		sysfatal("Can't Initialize ACPI objects");	int picmode;	status = FindIOAPICs(&picmode);	if (picmode == 0)		sysfatal("PANIC: Can't handle picmode 0!");	ACPI_STATUS ExecuteOSI(int pic_mode);	if (verbose)		print("FindIOAPICs returns status %d picmode %d/n", status, picmode);	status = ExecuteOSI(picmode);	CHECK_STATUS("ExecuteOSI");failed:	if (verbose)		print("inited objects./n");	if (verbose)		AcpiDbgLevel |= ACPI_LV_VERBOSITY1 | ACPI_LV_FUNCTIONS;	status = AcpiInitializeDebugger();	if (ACPI_FAILURE(status)) {		sysfatal("Error %d/n", status);	}	int GetPRT();	status = GetPRT();	if (ACPI_FAILURE(status)) {		sysfatal("Error %d/n", status);	}	while (1) {		if (scanf("%x %x", &bus, &dev) < 0)			break;		ACPI_STATUS RouteIRQ(ACPI_PCI_ID* device, int pin, int* irq);		AcpiDbgLevel = 0;		ACPI_PCI_ID id = (ACPI_PCI_ID){seg, bus, dev, fn};		status = AcpiOsReadPciConfiguration (&id, 0x3d, &pin, 8);		if (!ACPI_SUCCESS(status)){			printf("Can't read pin for bus %d dev %d/n", bus, dev);			continue;		}		print("ROUTE {%d, %d, %d, %d}, pin %d/n", seg, bus, dev, fn, pin);		int irq;		status = RouteIRQ(&id, pin, &irq);		print("status %d, irq %d/n", status, irq);		AcpiDbgLevel = 0;		print("echo %d %d %d %d 0x%x > /dev/irqmap", seg, bus, dev, fn, irq);		//ACPI_STATUS PrintDevices(void);		//status = PrintDevices();		if (set > -1)			fprint(set, "%d %d %d %d 0x%x", seg, bus, dev, fn, irq);	}//.........这里部分代码省略.........

/*  test some interesting combinations found by gentest */static bool test_create_gentest(struct torture_context *tctx, struct smb2_tree *tree){	struct smb2_create io;	NTSTATUS status;	uint32_t access_mask, file_attributes_set;	uint32_t ok_mask, not_supported_mask, invalid_parameter_mask;	uint32_t not_a_directory_mask, unexpected_mask;	union smb_fileinfo q;	ZERO_STRUCT(io);	io.in.desired_access     = SEC_FLAG_MAXIMUM_ALLOWED;	io.in.file_attributes    = FILE_ATTRIBUTE_NORMAL;	io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;	io.in.share_access = 		NTCREATEX_SHARE_ACCESS_DELETE|		NTCREATEX_SHARE_ACCESS_READ|		NTCREATEX_SHARE_ACCESS_WRITE;	io.in.create_options = 0;	io.in.fname = FNAME;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_OK);	status = smb2_util_close(tree, io.out.file.handle);	CHECK_STATUS(status, NT_STATUS_OK);	io.in.create_options = 0xF0000000;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);	io.in.create_options = 0;	io.in.file_attributes = FILE_ATTRIBUTE_DEVICE;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);	io.in.file_attributes = FILE_ATTRIBUTE_VOLUME;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);	io.in.create_disposition = NTCREATEX_DISP_OPEN;	io.in.file_attributes = FILE_ATTRIBUTE_VOLUME;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);		io.in.create_disposition = NTCREATEX_DISP_CREATE;	io.in.desired_access = 0x08000000;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);	io.in.desired_access = 0x04000000;	status = smb2_create(tree, tctx, &io);	CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);	io.in.file_attributes = 0;	io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;	io.in.desired_access     = SEC_FLAG_MAXIMUM_ALLOWED;	ok_mask = 0;	not_supported_mask = 0;	invalid_parameter_mask = 0;	not_a_directory_mask = 0;	unexpected_mask = 0;	{		int i;		for (i=0;i<32;i++) {			io.in.create_options = 1<<i;			if (io.in.create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) {				continue;			}			status = smb2_create(tree, tctx, &io);			if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {				not_supported_mask |= 1<<i;			} else if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {				invalid_parameter_mask |= 1<<i;			} else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {				not_a_directory_mask |= 1<<i;			} else if (NT_STATUS_EQUAL(status, NT_STATUS_OK)) {				ok_mask |= 1<<i;				status = smb2_util_close(tree, io.out.file.handle);				CHECK_STATUS(status, NT_STATUS_OK);			} else {				unexpected_mask |= 1<<i;				torture_comment(tctx,				    "create option 0x%08x returned %s/n",				    1<<i, nt_errstr(status));			}		}	}	io.in.create_options = 0;	CHECK_EQUAL(ok_mask,                0x00efcf7e);	CHECK_EQUAL(not_a_directory_mask,   0x00000001);	CHECK_EQUAL(not_supported_mask,     0x00102080);	CHECK_EQUAL(invalid_parameter_mask, 0xff000000);	CHECK_EQUAL(unexpected_mask,        0x00000000);	io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;//.........这里部分代码省略.........