/// <summary>
/// Parse bytes for a PINGRESP message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PINGRESP message instance</returns>
public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
{
MqttMsgPingResp msg = new MqttMsgPingResp();
// already know remaininglength is zero (MQTT specification),
// so it isn't necessary to read other data from socket
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
return msg;
}
/// <summary>
/// Parse bytes for a PINGRESP message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="socket">Socket connected to the broker</param>
/// <returns>PINGRESP message instance</returns>
public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, Socket socket)
{
MqttMsgPingResp msg = new MqttMsgPingResp();
// already know remaininglength is zero (MQTT specification),
// so it isn't necessary to read other data from socket
int remainingLength = MqttMsgBase.decodeRemainingLength(socket);
return(msg);
}
public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
MqttMsgPingResp mqttMsgPingResp = new MqttMsgPingResp();
if (protocolVersion == (byte)4 && ((uint)fixedHeaderFirstByte & 15U) > 0U)
{
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
MqttMsgBase.decodeRemainingLength(channel);
return(mqttMsgPingResp);
}
/// <summary>
/// Parse bytes for a PINGRESP message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PINGRESP message instance</returns>
public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
MqttMsgPingResp msg = new MqttMsgPingResp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGRESP_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// already know remaininglength is zero (MQTT specification),
// so it isn't necessary to read other data from socket
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
return msg;
}
/// <summary>
/// Parse bytes for a PINGRESP message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PINGRESP message instance</returns>
public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
MqttMsgPingResp msg = new MqttMsgPingResp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGRESP_FLAG_BITS)
{
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
}
// already know remaininglength is zero (MQTT specification),
// so it isn't necessary to read other data from socket
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
return(msg);
}
/// <summary>
/// Thread for receiving messages
/// </summary>
private void ReceiveThread()
{
int readBytes = 0;
byte[] fixedHeaderFirstByte = new byte[1];
byte msgType;
#if BROKER
long now = 0;
// receive thread started, broker need to receive the first message
// (CONNECT) within a reasonable amount of time after TCP/IP connection
long connectTime = Environment.TickCount;
#endif
while (this.isRunning)
{
try
{
if (this.channel.DataAvailable)
// read first byte (fixed header)
readBytes = this.channel.Receive(fixedHeaderFirstByte);
else
{
#if BROKER
// client not connected (client didn't send CONNECT yet)
if (!this.IsConnected)
{
now = Environment.TickCount;
// if connect timeout exceeded ...
if ((now - connectTime) >= this.settings.TimeoutOnConnection)
{
// client must close connection
this.Close();
// client raw disconnection
this.OnMqttMsgDisconnected();
}
}
#endif
// no bytes available, sleep before retry
readBytes = 0;
Thread.Sleep(10);
}
if (readBytes > 0)
{
#if BROKER
// update last message received ticks
this.lastCommTime = Environment.TickCount;
#endif
// extract message type from received byte
msgType = (byte)((fixedHeaderFirstByte[0] & MqttMsgBase.MSG_TYPE_MASK) >> MqttMsgBase.MSG_TYPE_OFFSET);
switch (msgType)
{
// CONNECT message received
case MqttMsgBase.MQTT_MSG_CONNECT_TYPE:
#if BROKER
MqttMsgConnect connect = MqttMsgConnect.Parse(fixedHeaderFirstByte[0], this.channel);
Trace.WriteLine(TraceLevel.Frame, "RECV {0}", connect);
// raise message received event
this.OnMqttMsgReceived(connect);
break;
#else
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#endif
// CONNACK message received
case MqttMsgBase.MQTT_MSG_CONNACK_TYPE:
#if BROKER
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#else
this.msgReceived = MqttMsgConnack.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", this.msgReceived);
this.syncEndReceiving.Set();
break;
#endif
// PINGREQ message received
case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE:
#if BROKER
this.msgReceived = MqttMsgPingReq.Parse(fixedHeaderFirstByte[0], this.channel);
Trace.WriteLine(TraceLevel.Frame, "RECV {0}", this.msgReceived);
MqttMsgPingResp pingresp = new MqttMsgPingResp();
this.Send(pingresp);
// raise message received event
//this.OnMqttMsgReceived(this.msgReceived);
break;
#else
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#endif
// PINGRESP message received
case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE:
#if BROKER
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#else
this.msgReceived = MqttMsgPingResp.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", this.msgReceived);
this.syncEndReceiving.Set();
break;
#endif
// SUBSCRIBE message received
case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE:
#if BROKER
MqttMsgSubscribe subscribe = MqttMsgSubscribe.Parse(fixedHeaderFirstByte[0], this.channel);
Trace.WriteLine(TraceLevel.Frame, "RECV {0}", subscribe);
// raise message received event
this.OnMqttMsgReceived(subscribe);
break;
#else
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#endif
// SUBACK message received
case MqttMsgBase.MQTT_MSG_SUBACK_TYPE:
#if BROKER
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#else
// enqueue SUBACK message received (for QoS Level 1) into the internal queue
MqttMsgSuback suback = MqttMsgSuback.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", suback);
// enqueue SUBACK message into the internal queue
this.EnqueueInternal(suback);
break;
#endif
// PUBLISH message received
case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE:
MqttMsgPublish publish = MqttMsgPublish.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", publish);
// enqueue PUBLISH message to acknowledge into the inflight queue
this.EnqueueInflight(publish, MqttMsgFlow.ToAcknowledge);
break;
// PUBACK message received
case MqttMsgBase.MQTT_MSG_PUBACK_TYPE:
// enqueue PUBACK message received (for QoS Level 1) into the internal queue
MqttMsgPuback puback = MqttMsgPuback.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", puback);
// enqueue PUBACK message into the internal queue
this.EnqueueInternal(puback);
break;
// PUBREC message received
case MqttMsgBase.MQTT_MSG_PUBREC_TYPE:
// enqueue PUBREC message received (for QoS Level 2) into the internal queue
MqttMsgPubrec pubrec = MqttMsgPubrec.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", pubrec);
// enqueue PUBREC message into the internal queue
this.EnqueueInternal(pubrec);
break;
// PUBREL message received
case MqttMsgBase.MQTT_MSG_PUBREL_TYPE:
// enqueue PUBREL message received (for QoS Level 2) into the internal queue
MqttMsgPubrel pubrel = MqttMsgPubrel.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", pubrel);
// enqueue PUBREL message into the internal queue
this.EnqueueInternal(pubrel);
break;
// PUBCOMP message received
case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE:
// enqueue PUBCOMP message received (for QoS Level 2) into the internal queue
MqttMsgPubcomp pubcomp = MqttMsgPubcomp.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", pubcomp);
// enqueue PUBCOMP message into the internal queue
this.EnqueueInternal(pubcomp);
break;
// UNSUBSCRIBE message received
case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE:
#if BROKER
MqttMsgUnsubscribe unsubscribe = MqttMsgUnsubscribe.Parse(fixedHeaderFirstByte[0], this.channel);
Trace.WriteLine(TraceLevel.Frame, "RECV {0}", unsubscribe);
// raise message received event
this.OnMqttMsgReceived(unsubscribe);
break;
#else
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#endif
// UNSUBACK message received
case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE:
#if BROKER
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#else
// enqueue UNSUBACK message received (for QoS Level 1) into the internal queue
MqttMsgUnsuback unsuback = MqttMsgUnsuback.Parse(fixedHeaderFirstByte[0], this.channel);
MqttUtility.Trace.WriteLine(TraceLevel.Frame, "RECV {0}", unsuback);
// enqueue UNSUBACK message into the internal queue
this.EnqueueInternal(unsuback);
break;
#endif
// DISCONNECT message received
case MqttMsgDisconnect.MQTT_MSG_DISCONNECT_TYPE:
#if BROKER
MqttMsgDisconnect disconnect = MqttMsgDisconnect.Parse(fixedHeaderFirstByte[0], this.channel);
Trace.WriteLine(TraceLevel.Frame, "RECV {0}", disconnect);
// raise message received event
this.OnMqttMsgReceived(disconnect);
break;
#else
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
#endif
default:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
}
this.exReceiving = null;
}
}
catch (Exception e)
{
MqttUtility.Trace.WriteLine(TraceLevel.Error, "Exception occurred: {0}", e.ToString());
this.exReceiving = new MqttCommunicationException(e);
}
}
}