public static void FsctlBadCommandRequest(
            int messageId,
            int sessionId,
            int treeId,
            bool isSigned,
            int fid,
            FsctlInvalidCommand command)
        {
            Condition.IsTrue(smbConnection.openedFiles.ContainsKey(fid));
            Condition.IsTrue(smbConnection.openedFiles[fid].treeId == treeId);
            Checker.CheckRequest(smbConnection, messageId, sessionId, treeId, isSigned, smbState);
            if (Parameter.sutPlatform != Platform.Win2K8R2
                    && Parameter.sutPlatform != Platform.NonWindows)
            {
                Condition.IsTrue(command == FsctlInvalidCommand.FsctlRequestOplockLevle1
                                    || command == FsctlInvalidCommand.FsctlRequestOplockLevel2
                                    || command == FsctlInvalidCommand.FsctlRequestBatchOplock
                                    || command == FsctlInvalidCommand.FsctlOplockBreakAcknowledge
                                    || command == FsctlInvalidCommand.FsctlOpBatchAckClosePending
                                    || command == FsctlInvalidCommand.FsctlOpLockBreakNotify
                                    || command == FsctlInvalidCommand.FsctlMoveFile
                                    || command == FsctlInvalidCommand.FsctlMarkHandle
                                    || command == FsctlInvalidCommand.FsctlQueryRetrievalPointers
                                    || command == FsctlInvalidCommand.FsctlPipeAssignEvent
                                    || command == FsctlInvalidCommand.FsctlGetVolumeBitmap
                                    || command == FsctlInvalidCommand.FsctlGetNtfsFileRecord
                                    || command == FsctlInvalidCommand.FsctlInvalidateVolumes
                                    || command == FsctlInvalidCommand.FsctlReadUsnJournal
                                    || command == FsctlInvalidCommand.FsctlCreateUsnJournal
                                    || command == FsctlInvalidCommand.FsctlQueryUsnJournal
                                    || command == FsctlInvalidCommand.FsctlDeleteUsnJournal
                                    || command == FsctlInvalidCommand.FsctlEnumUsnData);
            }
            smbRequest = new FSCTLBadCommandRequest(messageId, command);
            Update.UpdateRequest(smbConnection, smbRequest);

            // Store the bad command value.
            badCommand = command;
        }
        /// <summary>
        /// FSCTL Bad command request.
        /// </summary>
        /// <param name="messageId">This is used to associate a response with a request.</param>
        /// <param name="sessionId">The current session ID for this connection.</param>
        /// <param name="treeId">The tree ID for the corrent share connection.</param>
        /// <param name="isSigned">Indicate whether the message is signed or not for this response.</param>
        /// <param name="fid">The file identifier.</param>
        /// <param name="command">This is used to tell the adapter to send an invalid kind of command.</param>
        public void FsctlBadCommandRequest(
            int messageId,
            int sessionId,
            int treeId,
            bool isSigned,
            int fid,
            FsctlInvalidCommand command)
        {
            #region Create Packet

            NamespaceCifs.SmbNtTransactIoctlRequestPacket smbPacket = new NamespaceCifs.SmbNtTransactIoctlRequestPacket();

            ushort uid = (ushort)this.uId[(uint)sessionId];
            uint functionCode = (uint)command;
            byte[] data = new byte[DataCount];

            smbPacket = this.smbClientStack.CreateNTTransIOCtlRequest(
                (ushort)this.fId[(uint)fid],
                true,
                byte.MinValue,
                functionCode,
                data);

            if (isSigned)
            {
                NamespaceCifs.CifsClientPerConnection connection =
                    this.smbClientStack.Context.GetConnection(ConnectionId);

                NamespaceCifs.CifsClientPerSession session = this.smbClientStack.Context.GetSession(ConnectionId, uid);

                smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey);
            }

            #endregion

            #region Send and Receive ExpectPacket

            this.smbClientStack.SendPacket(smbPacket);
            StackPacket response = this.smbClientStack.ExpectPacket(this.timeout);

            NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response;

            this.QueryUidTable(smbPacketResponse);
            this.QueryTidTable(smbPacketResponse);

            VerifyTransport(smbPacketResponse);
            VerifyCommonMessageSyntax(smbPacketResponse);

            SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket;
            NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader;
            this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status);

            #endregion
        }
 /// <summary>
 /// Invalid FSCTL command request.
 /// </summary>
 /// <param name="messageId">This is used to associate a response with a request.</param>
 /// <param name="invalidCommand">Invaild command.</param>
 public FSCTLBadCommandRequest(int messageId, FsctlInvalidCommand invalidCommand)
     : base(messageId, Command.InvalidFsctlCommand)
 {
     this.messageId = messageId;
     this.invalidCommand = invalidCommand;
 }