/// <summary>
        /// Expect a SUT control response message
        /// </summary>
        /// <param name="timeout">Time out</param>
        /// <param name="requestId">RequestId should be in the response message</param>
        /// <returns>SUT Control response message</returns>
        public SUT_Control_Response_Message ExpectSUTControlResponseMessage(TimeSpan timeout, ushort requestId)
        {
            DateTime End = DateTime.Now + timeout;
            SUT_Control_Response_Message responseMessage = new SUT_Control_Response_Message();

            while (DateTime.Now < End)
            {
                IPEndPoint endpointReceived = new IPEndPoint(IPAddress.Any, 0);
                byte[]     buffer           = client.Receive(ref endpointReceived);

                if (buffer != null &&
                    remoteEP.Equals(endpointReceived))
                {
                    int index = 0;
                    if (responseMessage.Decode(buffer, ref index))
                    {
                        if (responseMessage.requestId == requestId)
                        {
                            return(responseMessage);
                        }
                    }
                }

                System.Threading.Thread.Sleep(100);
            }
            return(null);
        }
        /// <summary>
        /// Expect a SUT control response message
        /// </summary>
        /// <param name="timeout">Time out</param>
        /// <param name="requestId">RequestId should be in the response message</param>
        /// <returns>SUT Control response message</returns>
        public SUT_Control_Response_Message ExpectSUTControlResponseMessage(TimeSpan timeout, ushort requestId)
        {
            DateTime End = DateTime.Now + timeout;
            SUT_Control_Response_Message responseMessage = new SUT_Control_Response_Message();
            while (DateTime.Now < End)
            {
                IPEndPoint endpointReceived = new IPEndPoint(IPAddress.Any, 0);
                byte[] buffer = client.Receive(ref endpointReceived);

                if (buffer != null &&
                    remoteEP.Equals(endpointReceived))
                {
                    int index = 0;
                    if (responseMessage.Decode(buffer, ref index))
                    {
                        if (responseMessage.requestId == requestId)
                        {
                            return responseMessage;
                        }
                    }
                }

                System.Threading.Thread.Sleep(100);
            }
            return null;
        }
        /// <summary>
        /// Send SUT control request message to SUT agent and get the response is necessary
        /// </summary>
        /// <param name="requestMessage">SUT Control Request Message</param>
        /// <param name="ResponseNeeded">Whether response is needed, if true, must get a response, if false, apply the value of alwaysNeedResponse</param>
        /// <param name="payload">out parameter, is the payload of response</param>
        /// <returns></returns>
        public int OperateSUTControl(SUT_Control_Request_Message requestMessage, bool ResponseNeeded, out byte[] payload)
        {
            payload = null;

            foreach (IPEndPoint agentEndpoint in AgentList)
            {
                if (transport.Connect(timeout, agentEndpoint))
                {
                    transport.SendSUTControlRequestMessage(requestMessage);

                    if (alwaysNeedResponse || ResponseNeeded)
                    {
                        //expect response only when alwaysNeedResponse is true
                        SUT_Control_Response_Message responseMessage = transport.ExpectSUTControlResponseMessage(timeout, requestMessage.requestId);

                        if (responseMessage != null)
                        {
                            if (responseMessage.resultCode == (uint)SUTControl_ResultCode.SUCCESS)
                            {
                                transport.Disconnect();
                                payload = responseMessage.payload;
                                this.Site.Log.Add(LogEntryKind.Comment, "RDP SUT Control Protocol Adapter: CommandId is {0}: Success, agent: {1}.", requestMessage.commandId, agentEndpoint.ToString());
                                return(1);
                            }
                            else
                            {
                                string errorMessage = (responseMessage.errorMessage != null) ? responseMessage.errorMessage : "";
                                this.Site.Log.Add(LogEntryKind.Comment, "RDP SUT Control Protocol Adapter: CommandId is {0}: error in response: {1}, error message: {2}", requestMessage.commandId, agentEndpoint.ToString(), errorMessage);
                            }
                        }
                        else
                        {
                            this.Site.Log.Add(LogEntryKind.Comment, "RDP SUT Control Protocol Adapter: CommandId is {0}: Not get response from agent: {1}.", requestMessage.commandId, agentEndpoint.ToString());
                        }
                    }
                    transport.Disconnect();
                }
                else
                {
                    this.Site.Log.Add(LogEntryKind.Comment, "RDP SUT Control Protocol Adapter: CommandId is {0}: Cannot connect to the agent: {1}.", requestMessage.commandId, agentEndpoint.ToString());
                }
            }
            if (alwaysNeedResponse || ResponseNeeded)
            {
                // if alwaysNeedResponse is true, all response return failure
                return(-1);
            }
            else
            {
                // if alwaysNeedReponse is false, have send request to all Agents, return 1 for success
                return(1);
            }
        }
        /// <summary>
        /// Expect a SUT control response message
        /// </summary>
        /// <param name="timeout">Time out</param>
        /// <param name="requestId">RequestId should be in the response message</param>
        /// <returns>SUT Control response message</returns>
        public SUT_Control_Response_Message ExpectSUTControlResponseMessage(TimeSpan timeout, ushort requestId)
        {
            List <byte> receivedDataList = new List <byte>();
            int         bufferLength     = 2000;
            DateTime    End = DateTime.Now + timeout;
            SUT_Control_Response_Message responseMessage = new SUT_Control_Response_Message();

            while (DateTime.Now < End)
            {
                byte[] buffer = new byte[bufferLength];

                int readbyteNumber = 0;
                do
                {
                    readbyteNumber = netDataStream.Read(buffer, 0, bufferLength);
                    if (readbyteNumber > 0)
                    {
                        byte[] tmpbuffer = new byte[readbyteNumber];
                        Array.Copy(buffer, tmpbuffer, readbyteNumber);
                        receivedDataList.AddRange(tmpbuffer);
                    }
                }while (readbyteNumber == bufferLength);

                int index = 0;
                if (responseMessage.Decode(receivedDataList.ToArray(), ref index))
                {
                    if (responseMessage.requestId == requestId)
                    {
                        return(responseMessage);
                    }
                    else
                    {
                        receivedDataList.RemoveRange(0, index);
                    }
                }

                System.Threading.Thread.Sleep(100);
            }
            return(null);
        }
        /// <summary>
        /// Expect a SUT control response message
        /// </summary>
        /// <param name="timeout">Time out</param>
        /// <param name="requestId">RequestId should be in the response message</param>
        /// <returns>SUT Control response message</returns>
        public SUT_Control_Response_Message ExpectSUTControlResponseMessage(TimeSpan timeout, ushort requestId)
        {
            List<byte> receivedDataList = new List<byte>();
            int bufferLength = 2000;
            DateTime End = DateTime.Now + timeout;
            SUT_Control_Response_Message responseMessage = new SUT_Control_Response_Message();
            while (DateTime.Now < End)
            {
                byte[] buffer = new byte[bufferLength];

                int readbyteNumber = 0;
                do
                {
                    readbyteNumber = netDataStream.Read(buffer, 0, bufferLength);
                    if (readbyteNumber > 0)
                    {
                        byte[] tmpbuffer = new byte[readbyteNumber];
                        Array.Copy(buffer, tmpbuffer, readbyteNumber);
                        receivedDataList.AddRange(tmpbuffer);
                    }
                }
                while (readbyteNumber == bufferLength);

                int index = 0;
                if (responseMessage.Decode(receivedDataList.ToArray(), ref index))
                {
                    if (responseMessage.requestId == requestId)
                    {
                        return responseMessage;
                    }
                    else
                    {
                        receivedDataList.RemoveRange(0, index);
                    }
                }

                System.Threading.Thread.Sleep(100);
            }
            return null;
        }