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);
}
