public void SendProtocolError(ProtocolError error) { _writer.Reset(); _writer.Write((byte)3); _writer.Write((int)error); _connection.Send(_writer.ToArray()); }
private async Task <State> DoExpectConfigAsync() { Stream stream = networkStream.Stream; Frame frame = await Frame.ReadAsync(stream, shutdownTokenSource.Token, logger); if (frame == null) { logger.Site().Information("{0} EOS encountered while waiting for config, so disconnecting.", this); return(State.Disconnecting); } var result = EpoxyProtocol.Classify(frame, logger); switch (result.Disposition) { case EpoxyProtocol.FrameDisposition.ProcessConfig: // we don't actually use the config yet return(connectionType == ConnectionType.Server ? State.ServerSendConfig : State.Connected); case EpoxyProtocol.FrameDisposition.HandleProtocolError: // we got a protocol error while we expected config handshakeError = result.Error; return(State.Disconnecting); case EpoxyProtocol.FrameDisposition.HangUp: return(State.Disconnecting); default: protocolError = result.ErrorCode ?? ProtocolErrorCode.PROTOCOL_VIOLATED; logger.Site().Error("{0} Unsupported FrameDisposition {1} when waiting for config. ErrorCode: {2})", this, result.Disposition, protocolError); return(State.SendProtocolError); } }
public async Task <RegistrationResult> Register(string username, string password) { var result = await Post.To("/_matrix/client/r0/register") .Using(RestClient) .AddBody(new RegistrationRequest { Username = username, Password = password, AuthenticationData = new AuthenticationData { Type = "m.login.dummy" }, InhibitLogin = true, DeviceId = null, InitialDeviceDisplayName = null }) .On(400, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .On(401, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .On(403, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .On(429, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .WhenSucceeded(new Action <RegistrationResult>(r => { AccountRegistered?.Invoke(this, new RegistrationEventArgs(MxId.Parse(r.UserId))); })) .Execute <RegistrationResult>(); return(result); }
internal static ClassifyState TransitionExpectProtocolError( ClassifyState state, Frame frame, ref ProtocolError error, ref FrameDisposition disposition, Logger logger) { if (state != ClassifyState.ExpectProtocolError || frame == null || frame.Count == 0 || frame.Framelets[0].Type != FrameletType.ProtocolError) { return(ClassifyState.InternalStateError); } if (frame.Count > 1) { logger.Site().Error("Protocol error frame had trailing framelets."); return(ClassifyState.ErrorInErrorFrame); } var framelet = frame.Framelets[0]; var inputBuffer = new InputBuffer(framelet.Contents); var fastBinaryReader = new FastBinaryReader <InputBuffer>(inputBuffer, version: 1); switch (errorDeserializer.TryDeserialize(fastBinaryReader, out error)) { case Deserialize.Result.Success: break; default: logger.Site().Error("Didn't get a valid {0}.", nameof(ProtocolError)); return(ClassifyState.ErrorInErrorFrame); } logger.Site().Debug("Deserialized {0} with code {1}.", nameof(ProtocolError), error.error_code); disposition = FrameDisposition.HandleProtocolError; return(ClassifyState.ClassifiedValidFrame); }
public void TransitionExpectProtocolError_Error() { ProtocolError error = null; var disposition = EpoxyProtocol.FrameDisposition.Indeterminate; var after = EpoxyProtocol.TransitionExpectProtocolError( EpoxyProtocol.ClassifyState.ExpectProtocolError, doubleProtocolErrorFrame, ref error, ref disposition, LoggerTests.BlackHole); Assert.AreEqual(EpoxyProtocol.ClassifyState.ErrorInErrorFrame, after); }
public void TransitionExpectProtocolError_Valid() { ProtocolError error = null; var disposition = EpoxyProtocol.FrameDisposition.Indeterminate; var after = EpoxyProtocol.TransitionExpectProtocolError( EpoxyProtocol.ClassifyState.ExpectProtocolError, protocolErrorFrame, ref error, ref disposition, LoggerTests.BlackHole); Assert.AreEqual(EpoxyProtocol.ClassifyState.ClassifiedValidFrame, after); Assert.AreEqual(MeaninglessErrorCode, error.error_code); Assert.AreEqual(EpoxyProtocol.FrameDisposition.HandleProtocolError, disposition); }
public void TransitionExpectProtocolError_InvalidPreconditions() { ProtocolError error = null; var disposition = EpoxyProtocol.FrameDisposition.Indeterminate; var after = EpoxyProtocol.TransitionExpectProtocolError( EpoxyProtocol.ClassifyState.ExpectProtocolError, goodRequestFrame, ref error, ref disposition, LoggerTests.BlackHole); Assert.AreEqual(EpoxyProtocol.ClassifyState.InternalStateError, after); Assert.Null(error); Assert.AreEqual(EpoxyProtocol.FrameDisposition.Indeterminate, disposition); }
private void StartParsingInBackground(CancellationToken cancelToken) { Task.Run(() => { while (!cancelToken.IsCancellationRequested) { var b = ReadByteFromSerialBuffer(); _protocol.Parse(b); if (CheckForProtocolError(out var error)) { ProtocolError?.Invoke(this, error); } if (CheckForEvent(out var eventPdu)) { OnEventReceived(eventPdu); } } }, cancelToken); }
public static BaseMessage GenerateProtocolError(BaseMessage parentMessage, string errCode, string errText, IDictionary <string, object> errPayload = null) { ProtocolError err = new ProtocolError(); err.ErrCode = errCode; err.ErrText = errText; err.ErrPayload = errPayload; BaseMessage msg = new BaseMessage(parentMessage, true); if (parentMessage == null) { msg.ID = Guid.NewGuid().ToString(); } msg.Ok = false; msg.Payload = err.ToDictionary(); return(msg); }
internal static Frame MakeProtocolErrorFrame(ProtocolErrorCode errorCode, Error details, Logger logger) { var protocolError = new ProtocolError { error_code = errorCode, details = (details == null ? null : new Bonded <Error>(details)) }; var outputBuffer = new OutputBuffer(16); var fastWriter = new FastBinaryWriter <OutputBuffer>(outputBuffer); Serialize.To(fastWriter, protocolError); var frame = new Frame(1, logger); frame.Add(new Framelet(FrameletType.ProtocolError, outputBuffer.Data)); return(frame); }
public static string GetDescription(this ProtocolError error) { switch (error) { case ProtocolError.InvalidMessageType: return("That message type does not exist"); case ProtocolError.AlreadyInRoom: return("You are already in that room"); case ProtocolError.NotInRoom: return("You are not in that room"); default: return(""); } }
public async Task <LoginResult> Login(string username, string password, string deviceId = null, string initialDisplayName = "TensorMatrix") { var methodQueryResult = await QueryLoginMethods(); if (!methodQueryResult.SupportedMethods.Any(x => x.Type == "m.login.password")) { throw new UnsupportedLoginMethodException("Homeserver does not support password-based login."); } var result = await Post.To("/_matrix/client/r0/login") .Using(RestClient) .AddBody(new PasswordLoginRequest <MxidIdentifier> { Identifier = new MxidIdentifier { User = username }, DeviceId = deviceId, InitialDeviceDisplayName = initialDisplayName, Password = password }) .On(400, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .On(403, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .On(429, (req, res, err) => ProtocolError?.Invoke(this, new ErrorEventArgs(err, res))) .WhenSucceeded(new Action <LoginResult>(r => { MxId = MxId.Parse(r.UserId); JwtAuthenticator = new JwtAuthenticator(r.AccessToken); RestClient.Authenticator = JwtAuthenticator; DeviceId = r.DeviceId; if (r.WellKnown != null) { RestClient.BaseUrl = new Uri(r.WellKnown.HomeServer.BaseUrl); } LoggedIn?.Invoke(this, new LoginEventArgs(MxId, r.AccessToken, r.DeviceId)); })) .Execute <LoginResult>(); return(result); }
public void ModbusRtuProtocol_validateResponse() { /* * GlobalObject go = new GlobalObject(); * go.varList = new System.Collections.Generic.LinkedList<Var>(); * go.varList.AddLast(new Var("var1", VarType.Int16, new ModbusAddress(Space.Coils, 0x00))); * go.varList.AddLast(new Var("var2", VarType.Int16, new ModbusAddress(Space.Coils, 0x01))); * PrivateObject auxPrivateObject = new PrivateObject(go); * auxPrivateObject.Invoke("buildAddrVarMap"); */ Query query = new Query(); //query.data = new UInt16[] { 0x01, 0x01, 0x00, 0x00, 0x00, 0x0A, 0xBC, 0x0D }; query.function = 1; query.startTag = 0; query.tagNum = 10; //query.globalObject = go; byte[] respMsg1 = new byte[] { 0x01, 0x01, 0x02, 0x55, 0x40, 0x00, 0x00 }; UInt16 crc = ModbusRtuProtocol.calculateCrc(respMsg1, 5); respMsg1[5] = (byte)(crc >> 8); respMsg1[6] = (byte)crc; ModbusRtuProtocol modbusRtuProtocol = new ModbusRtuProtocol(); modbusRtuProtocol.deviceAddress = 1; modbusRtuProtocol.query = query; PrivateObject po = new PrivateObject(modbusRtuProtocol); ProtocolError pe = (ProtocolError)po.Invoke("validateResponse", new Object[] { respMsg1 }); Assert.IsTrue(pe == ProtocolError.OK); // Assert.IsTrue(modbusRtuProtocol.query.globalObject.addrVarMap[new ModbusAddress(Space.Coils, 0x00)].UInt16Value == 0 ); // Assert.IsTrue(modbusRtuProtocol.query.globalObject.addrVarMap[new ModbusAddress(Space.Coils, 0x01)].UInt16Value == 1); }
/// <summary> /// This method is used to test Protocol Error related adapter requirements. /// </summary> /// <param name="instance">Specify the instance which need to be verified.</param> /// <param name="site">Specify the ITestSite instance.</param> public void VerifyProtocolError(ProtocolError instance, ITestSite site) { // If the instance is not null and there are no parsing errors, then the Protocol Error related adapter requirements can be directly captured. if (null == instance) { site.Assert.Fail("The instance of type ProtocolError is null due to parsing error or type casting error."); } // All the serial number null values related requirements can be located here. site.Log.Add(LogEntryKind.Debug, "Runs for ProtocolErrorGuid verification logic with the error code {0}.", instance.ErrorCode); }
public void ModbusRtuProtocol_decode() { GlobalObject go = new GlobalObject(); go.varList = new System.Collections.Generic.LinkedList <Var>(); go.varList.AddLast(new Var("var1-1", VarType.Int16, new ModbusAddress(Space.Coils, 0x00))); go.varList.AddLast(new Var("var1-2", VarType.Int16, new ModbusAddress(Space.Coils, 0x01))); go.varList.AddLast(new Var("var1-3", VarType.Int16, new ModbusAddress(Space.Coils, 0x02))); go.varList.AddLast(new Var("var1-4", VarType.Int16, new ModbusAddress(Space.Coils, 0x03))); go.varList.AddLast(new Var("var2-1", VarType.Int16, new ModbusAddress(Space.DiscreteInputs, 0x00))); go.varList.AddLast(new Var("var2-2", VarType.Int16, new ModbusAddress(Space.DiscreteInputs, 0x01))); go.varList.AddLast(new Var("var2-3", VarType.Int16, new ModbusAddress(Space.DiscreteInputs, 0x02))); go.varList.AddLast(new Var("var2-4", VarType.Int16, new ModbusAddress(Space.DiscreteInputs, 0x03))); go.varList.AddLast(new Var("var3-1", VarType.Int16, new ModbusAddress(Space.AnalogInputs, 0x00))); go.varList.AddLast(new Var("var3-2", VarType.Int16, new ModbusAddress(Space.AnalogInputs, 0x01))); go.varList.AddLast(new Var("var3-3", VarType.Int16, new ModbusAddress(Space.AnalogInputs, 0x02))); go.varList.AddLast(new Var("var3-4", VarType.Int16, new ModbusAddress(Space.AnalogInputs, 0x03))); go.varList.AddLast(new Var("var4-1", VarType.Int16, new ModbusAddress(Space.Holdings, 0x00))); go.varList.AddLast(new Var("var4-2", VarType.Int16, new ModbusAddress(Space.Holdings, 0x01))); go.varList.AddLast(new Var("var4-3", VarType.Int16, new ModbusAddress(Space.Holdings, 0x02))); go.varList.AddLast(new Var("var4-4", VarType.Int16, new ModbusAddress(Space.Holdings, 0x03))); PrivateObject auxPrivateObject = new PrivateObject(go); auxPrivateObject.Invoke("buildAddrVarMap"); ModbusRtuProtocol modbusRtuProtocol = new ModbusRtuProtocol(); Query query = new Query(); // query.data = new UInt16[] { 0x01, 0x01, 0x00, 0x00, 0x00, 0x0A, 0xBC, 0x0D }; query.function = 1; query.startTag = 0; query.tagNum = 10; query.globalObject = go; byte[] respMsg1 = new byte[] { 0x01, 0x01, 0x02, 0x55, 0x40, 0x00, 0x00 }; UInt16 crc = ModbusRtuProtocol.calculateCrc(respMsg1, 5); respMsg1[5] = (byte)(crc >> 8); respMsg1[6] = (byte)crc; modbusRtuProtocol.deviceAddress = 1; modbusRtuProtocol.query = query; modbusRtuProtocol.globalObject = go; Response response = new Response(query); ProtocolError pe = modbusRtuProtocol.decode(respMsg1, query, response); Assert.IsTrue(pe == ProtocolError.OK); Assert.IsTrue(modbusRtuProtocol.query.globalObject.addrVarMap[new ModbusAddress(Space.Coils, 0x00)].uInt16Value == 1); Assert.IsTrue(modbusRtuProtocol.query.globalObject.addrVarMap[new ModbusAddress(Space.Coils, 0x01)].uInt16Value == 0); Assert.IsTrue(modbusRtuProtocol.query.globalObject.addrVarMap[new ModbusAddress(Space.Coils, 0x02)].uInt16Value == 1); Assert.IsTrue(modbusRtuProtocol.query.globalObject.addrVarMap[new ModbusAddress(Space.Coils, 0x03)].uInt16Value == 0); respMsg1[6] ^= respMsg1[6]; //make the crc wrong pe = modbusRtuProtocol.decode(respMsg1, query, response); Assert.IsTrue(pe == ProtocolError.CRCError); //дописать тесты для других функций }
public void ErrorResponds(object sender, ProtocolError e) { App.Current.Dispatcher.Invoke(() => { MessageWindow.Show(Owner, e.Error); }); }
//decode an answer of a remote device //--- master mode --- public override ProtocolError decode(byte[] msg, Query query, Response response) { this.query = query; ProtocolError protocolError = validateResponse(msg); if (protocolError == ProtocolError.OK) { if (response != null) { int function = msg[1]; UInt16[] tagValues = new UInt16[0]; switch (function) { case 1: case 2: tagValues = new UInt16[query.tagNum]; for (int i = 0; i < query.tagNum - 1; i++) { tagValues[i] = (UInt16)((msg[3 + i / 8] & (0x01 << i % 8)) != 0 ? 1 : 0); } break; case 3: tagValues = new UInt16[query.tagNum]; for (int i = 0; i < query.tagNum - 1; i++) { tagValues[i] = (UInt16)(((UInt16)msg[3 + i * 2] << 8) | (UInt16)msg[4 + i * 2]); } break; case 4: tagValues = new UInt16[1]; tagValues[0] = (UInt16)(msg[3] << 8 | msg[4]); break; case 5: tagValues = new UInt16[1]; tagValues[0] = (UInt16)((msg[4] != 0) ? 1 : 0); break; case 6: tagValues = new UInt16[1]; tagValues[0] = (UInt16)((UInt16)msg[4] << 8 | (UInt16)msg[5]); break; case 15: //no data in the response case 16: //no data in the response break; } if (function >= 1 && function <= 6) { globalObject.updateTags(ModbusProtocol.getSpace(function), query.startTag, tagValues); globalObject.updateVariables(ModbusProtocol.getSpace(function), query.startTag, query.startTag + query.tagNum - 1); } } else { throw new AccessViolationException("response object not found!"); } } return(protocolError); }
public void Error(Object v, ProtocolError error) { throw new Exception("Error: " + error); }
internal static ClassifyState TransitionExpectProtocolError( ClassifyState state, Frame frame, ref ProtocolError error, ref FrameDisposition disposition, Logger logger) { if (state != ClassifyState.ExpectProtocolError || frame == null || frame.Count == 0 || frame.Framelets[0].Type != FrameletType.ProtocolError) { return ClassifyState.InternalStateError; } if (frame.Count > 1) { logger.Site().Error("Protocol error frame had trailing framelets."); return ClassifyState.ErrorInErrorFrame; } var framelet = frame.Framelets[0]; var inputBuffer = new InputBuffer(framelet.Contents); var fastBinaryReader = new FastBinaryReader<InputBuffer>(inputBuffer, version: 1); switch (errorDeserializer.TryDeserialize(fastBinaryReader, out error)) { case Deserialize.Result.Success: break; default: logger.Site().Error("Didn't get a valid {0}.", nameof(ProtocolError)); return ClassifyState.ErrorInErrorFrame; } logger.Site().Debug("Deserialized {0} with code {1}.", nameof(ProtocolError), error.error_code); disposition = FrameDisposition.HandleProtocolError; return ClassifyState.ClassifiedValidFrame; }
public void Parse(byte ch) { if (_pduBufPos >= PDU_BUF_SIZE) { _pduBufPos = 0; } //----------------- // Parse PDU_TYPE //----------------- // check packet position if (_pduBufPos == 0) { // beginning of packet, check for correct framing/expected byte(s) // Packet must be either Command/Response (0x00) or Event (0x80) if ((ch & 0x7F) == 0x00) { // store new character in RX buffer _rxPduBuf[_pduBufPos++] = ch; } } else { _rxPduBuf[_pduBufPos++] = ch; if (_pduBufPos == (PDU_HDR_POS_CLS_ID + 1)) { //------------ // Parse CLSID //------------ if (_rxPduBuf[PDU_HDR_POS_CLS_ID] != (byte)ClassId.BlueCats) { if ((_rxPduBuf[PDU_HDR_POS_CLS_ID] & 0x7F) == 0x00) { _rxPduBuf[0] = _rxPduBuf[PDU_HDR_POS_CLS_ID]; _pduBufPos = 1; } else { _pduBufPos = 0; // bad sync, reset pdu buffer } } } //----------------- // Parse PAY_LEN //----------------- else if (_pduBufPos == (PDU_HDR_POS_PAY_LEN + 1)) { _pduPayLen = ch; } else if (_pduBufPos >= PDU_HDR_LEN) { //----------------------------- // Parse header CRC8 and verify //----------------------------- if (_pduBufPos == PDU_HDR_LEN) { // check pdu header crc8 byte hdrCrc8 = Crc8(_rxPduBuf, 0, PDU_HDR_LEN - 1); if (hdrCrc8 != _rxPduBuf[PDU_HDR_POS_CRC8]) { _pduBufPos = 0; // crc failed, reset pdu buffer var errMsg = $"Header CRC8 does not match (calculated: 0x{hdrCrc8:2X}, given: 0x{_rxPduBuf[ PDU_HDR_POS_CRC8 ]:2X}"; ProtocolError?.Invoke(this, errMsg); } } //--------------------- // Full packet received //--------------------- if (_pduBufPos == (_pduPayLen + PDU_HDR_LEN)) { // just received last expected byte, reset pdu buffer _pduBufPos = 0; //------------------------------ // Parse payload CRC8 and verify //------------------------------ if (_pduPayLen > 0) { // check pdu payload crc8 byte payCrc8 = Crc8(_rxPduBuf, PDU_PAY_POS, _pduPayLen); if (payCrc8 != _rxPduBuf[PDU_HDR_POS_PAY_CRC8]) { var errMsg = $"Header CRC8 does not match (calculated: 0x{payCrc8:X2}, given: 0x{_rxPduBuf[ PDU_HDR_POS_CRC8 ]:X2})"; ProtocolError?.Invoke(this, errMsg); return; } } //----------- // Handle RSP //----------- if (_rxPduBuf[PDU_HDR_POS_PDU_TYPE] == (byte)PduType.Command) { if (_pduPayLen <= 0) { _pduBufPos = 0; // reset pdu buffer ProtocolError?.Invoke(this, "Missing response code for response"); } var payloadBytes = _rxPduBuf.Take(_pduPayLen + PDU_HDR_LEN).ToArray(); var pdu = CommandResponsePdu.FromByteArray(payloadBytes); CommandResponseReceived?.Invoke(this, pdu); } //----------- // Handle EVT //----------- else if (_rxPduBuf[PDU_HDR_POS_PDU_TYPE] == (byte)PduType.Event) { var payloadBytes = _rxPduBuf.Take(_pduPayLen + PDU_HDR_LEN).ToArray(); var pdu = EventPdu.FromByteArray(payloadBytes); EventReceived?.Invoke(this, pdu); } } } } }
internal static ClassifyResult Classify(Frame frame, Logger logger) { if (frame == null) { return(new ClassifyResult { Disposition = FrameDisposition.Indeterminate }); } logger.Site().Debug("Processing {0} framelets.", frame.Count); var state = ClassifyState.ExpectFirstFramelet; var disposition = FrameDisposition.Indeterminate; EpoxyHeaders headers = null; var layerData = new ArraySegment <byte>(); var messageData = default(MessageData); ProtocolError error = null; ProtocolErrorCode?errorCode = null; uint transitions = 0; while (true) { // If it looks like we have a bug and are looping forever, bail out of the state machine. if (transitions++ > maximumTransitions) { return(new ClassifyResult { Disposition = FrameDisposition.Indeterminate }); } switch (state) { case ClassifyState.ExpectFirstFramelet: state = TransitionExpectFirstFramelet(state, frame, ref errorCode, logger); continue; case ClassifyState.ExpectEpoxyHeaders: state = TransitionExpectEpoxyHeaders(state, frame, ref headers, ref errorCode, logger); continue; case ClassifyState.ExpectOptionalLayerData: state = TransitionExpectOptionalLayerData(state, frame, headers, ref layerData, ref errorCode, logger); continue; case ClassifyState.ExpectMessageData: state = TransitionExpectMessageData(state, frame, headers, layerData, ref messageData, ref errorCode, logger); continue; case ClassifyState.ExpectEndOfFrame: state = TransitionExpectEndOfFrame(state, frame, layerData, ref errorCode, logger); continue; case ClassifyState.FrameComplete: state = TransitionFrameComplete(state, headers, ref errorCode, logger); continue; case ClassifyState.ValidFrame: state = TransitionValidFrame(state, headers, ref disposition); continue; case ClassifyState.ExpectConfig: state = TransitionExpectConfig(state, frame, ref errorCode, ref disposition, logger); continue; case ClassifyState.ExpectProtocolError: state = TransitionExpectProtocolError(state, frame, ref error, ref disposition, logger); continue; case ClassifyState.ClassifiedValidFrame: if (disposition == FrameDisposition.Indeterminate) { state = ClassifyState.InternalStateError; continue; } return(new ClassifyResult { Disposition = disposition, Headers = headers, LayerData = layerData, MessageData = messageData, Error = error }); case ClassifyState.MalformedFrame: if (errorCode == null) { state = ClassifyState.InternalStateError; continue; } return(new ClassifyResult { Disposition = FrameDisposition.SendProtocolError, ErrorCode = errorCode }); case ClassifyState.ErrorInErrorFrame: return(new ClassifyResult { Disposition = FrameDisposition.HangUp, Error = new ProtocolError { error_code = ProtocolErrorCode.ERROR_IN_ERROR } }); case ClassifyState.InternalStateError: return(new ClassifyResult { Disposition = FrameDisposition.Indeterminate }); default: logger.Site().Error("Unhandled state {0}. Dropping frame.", state); return(new ClassifyResult { Disposition = FrameDisposition.Indeterminate }); } } }
/// <summary> /// 创建服务端错误 /// </summary> public static CustomErrorException Create(ProtocolError errorCode) { return(Create(errorCode, string.Empty)); }
/// <summary> /// 创建服务端错误 /// </summary> public static CustomErrorException Create(ProtocolError errorCode, string errorDescription) { return(new CustomErrorException(errorCode, errorDescription)); }
public ProtoChannelException(ProtocolError error) : base(String.Format("Protocol error {0}", error)) { Error = error; }
public void Error(ProtocolError error) { Emit(0, error); }
public void SendProtocolError(ProtocolError error) { Console.WriteLine("PROTOCOL ERROR: " + error + " ( " + error.GetDescription() + ")"); }
public ProtocolErrorException(ProtocolError error) { this.error = error; }
public BinaryProtocolException(ProtocolError error) { Error = error; }
public void Error(Session ssn, ProtocolError error) { }
protected override void OnEventAnalyzed(byte id, byte[] eventValue) { switch (id) { case 0x00: { var major = BitConverter.ToUInt16(eventValue, 0); var minor = BitConverter.ToUInt16(eventValue, 2); var patch = BitConverter.ToUInt16(eventValue, 4); var build = BitConverter.ToUInt16(eventValue, 6); var llVersion = BitConverter.ToUInt16(eventValue, 8); var protocolVersion = eventValue[10]; var hw = eventValue[11]; var eventArgs = new BootEventArgs(major, minor, patch, build, llVersion, protocolVersion, hw); Boot?.Invoke(this, eventArgs); break; } case 0x02: { var endpoint = (Endpoint)eventValue[0]; var data = eventValue[1]; var eventArgs = new EndpointWatermarkRXEventArgs(endpoint, data); EndpointWatermarkRX?.Invoke(this, eventArgs); break; } case 0x03: { var endpoint = (Endpoint)eventValue[0]; var data = eventValue[1]; var eventArgs = new EndpointWatermarkTXEventArgs(endpoint, data); EndpointWatermarkTX?.Invoke(this, eventArgs); break; } case 0x04: { var address = BitConverter.ToUInt16(eventValue, 0); var errorCode = BitConverter.ToUInt16(eventValue, 2); var eventArgs = new ScriptFailureEventArgs(address, errorCode); ScriptFailure?.Invoke(this, eventArgs); break; } case 0x05: { NoLicenseKey?.Invoke(this, EventArgs.Empty); break; } case 0x06: { var errorCode = BitConverter.ToUInt16(eventValue, 0); var eventArgs = new ProtocolErrorEventArgs(errorCode); ProtocolError?.Invoke(this, eventArgs); break; } case 0x07: { var state = eventValue[0]; var eventArgs = new UsbEnumeratedEventArgs(state); UsbEnumerated?.Invoke(this, eventArgs); break; } default: { break; } } }
/// <summary> /// 构服务端错误 /// </summary> private CustomErrorException(ProtocolError errorCode, string errorDescription) { this.Code = errorCode; this.Description = errorDescription; }
protected void SendError(ProtocolError error) { long packageStart = BeginSendPackage(); WriteMessage(TypeModel, new Messages.Error { ErrorNumber = (uint)error }); EndSendPackage(PackageType.Error, packageStart); }