/// <summary>
/// Parse bytes for a PUBCOMP 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>PUBCOMP message instance</returns>
public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPubcomp msg = new MqttMsgPubcomp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return msg;
}
/// <summary>
/// Parse bytes for a PUBCOMP 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>PUBCOMP message instance</returns>
public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPubcomp msg = new MqttMsgPubcomp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS)
{
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return(msg);
}
public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
int num1 = 0;
MqttMsgPubcomp mqttMsgPubcomp1 = new MqttMsgPubcomp();
if (protocolVersion == (byte)4 && ((uint)fixedHeaderFirstByte & 15U) > 0U)
{
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
byte[] buffer = new byte[MqttMsgBase.decodeRemainingLength(channel)];
channel.Receive(buffer);
MqttMsgPubcomp mqttMsgPubcomp2 = mqttMsgPubcomp1;
byte[] numArray1 = buffer;
int index1 = num1;
int num2 = checked (index1 + 1);
int num3 = (int)checked ((ushort)((int)numArray1[index1] << 8 & 65280));
mqttMsgPubcomp2.messageId = (ushort)num3;
MqttMsgPubcomp mqttMsgPubcomp3 = mqttMsgPubcomp1;
int messageId = (int)mqttMsgPubcomp3.messageId;
byte[] numArray2 = buffer;
int index2 = num2;
int num4 = checked (index2 + 1);
int num5 = (int)numArray2[index2];
mqttMsgPubcomp3.messageId = (ushort)(messageId | num5);
return(mqttMsgPubcomp1);
}
/// <summary>
/// Parse bytes for a PUBCOMP message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="socket">Socket connected to the broker</param>
/// <returns>PUBCOMP message instance</returns>
public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, Socket socket)
{
byte[] buffer;
int index = 0;
MqttMsgPubcomp msg = new MqttMsgPubcomp();
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(socket);
buffer = new byte[remainingLength];
// read bytes from socket...
socket.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return msg;
}
/// <summary>
/// Parse bytes for a PUBCOMP message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="socket">Socket connected to the broker</param>
/// <returns>PUBCOMP message instance</returns>
public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, Socket socket)
{
byte[] buffer;
int index = 0;
MqttMsgPubcomp msg = new MqttMsgPubcomp();
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(socket);
buffer = new byte[remainingLength];
// read bytes from socket...
socket.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return(msg);
}
/// <summary>
/// Process inflight messages queue
/// </summary>
private void ProcessInflightThread()
{
MqttMsgContext msgContext = null;
MqttMsgBase msgInflight = null;
MqttMsgBase msgReceived = null;
bool acknowledge = false;
int timeout = Timeout.Infinite;
try
{
while (this.isRunning)
{
#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
// wait on message queueud to inflight
this.inflightWaitHandle.WaitOne(timeout, false);
#else
// wait on message queueud to inflight
this.inflightWaitHandle.WaitOne(timeout);
#endif
// it could be unblocked because Close() method is joining
if (this.isRunning)
{
lock (this.inflightQueue)
{
// set timeout tu MaxValue instead of Infinte (-1) to perform
// compare with calcultad current msgTimeout
timeout = Int32.MaxValue;
// a message inflight could be re-enqueued but we have to
// analyze it only just one time for cycle
int count = this.inflightQueue.Count;
// process all inflight queued messages
while (count > 0)
{
count--;
acknowledge = false;
msgReceived = null;
// dequeue message context from queue
msgContext = (MqttMsgContext)this.inflightQueue.Dequeue();
// get inflight message
msgInflight = (MqttMsgBase)msgContext.Message;
switch (msgContext.State)
{
case MqttMsgState.QueuedQos0:
// QoS 0, PUBLISH message to send to broker, no state change, no acknowledge
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
this.Send(msgInflight);
}
// QoS 0, no need acknowledge
else if (msgContext.Flow == MqttMsgFlow.ToAcknowledge)
{
// notify published message from broker (no need acknowledged)
this.OnMqttMsgReceived(msgInflight);
}
break;
case MqttMsgState.QueuedQos1:
// QoS 1, PUBLISH or SUBSCRIBE/UNSUBSCRIBE message to send to broker, state change to wait PUBACK or SUBACK/UNSUBACK
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
if (msgInflight.Type == MqttMsgBase.MQTT_MSG_PUBLISH_TYPE)
// PUBLISH message to send, wait for PUBACK
msgContext.State = MqttMsgState.WaitForPuback;
else if (msgInflight.Type == MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE)
// SUBSCRIBE message to send, wait for SUBACK
msgContext.State = MqttMsgState.WaitForSuback;
else if (msgInflight.Type == MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE)
// UNSUBSCRIBE message to send, wait for UNSUBACK
msgContext.State = MqttMsgState.WaitForUnsuback;
msgContext.Timestamp = Environment.TickCount;
msgContext.Attempt++;
// retry ? set dup flag
if (msgContext.Attempt > 1)
msgInflight.DupFlag = true;
this.Send(msgInflight);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
// re-enqueue message (I have to re-analyze for receiving PUBACK, SUBACK or UNSUBACK)
this.inflightQueue.Enqueue(msgContext);
}
// QoS 1, PUBLISH message received from broker to acknowledge, send PUBACK
else if (msgContext.Flow == MqttMsgFlow.ToAcknowledge)
{
MqttMsgPuback puback = new MqttMsgPuback();
puback.MessageId = ((MqttMsgPublish)msgInflight).MessageId;
this.Send(puback);
// notify published message from broker and acknowledged
this.OnMqttMsgReceived(msgInflight);
}
break;
case MqttMsgState.QueuedQos2:
// QoS 2, PUBLISH message to send to broker, state change to wait PUBREC
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
msgContext.State = MqttMsgState.WaitForPubrec;
msgContext.Timestamp = Environment.TickCount;
msgContext.Attempt++;
// retry ? set dup flag
if (msgContext.Attempt > 1)
msgInflight.DupFlag = true;
this.Send(msgInflight);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
// re-enqueue message (I have to re-analyze for receiving PUBREC)
this.inflightQueue.Enqueue(msgContext);
}
// QoS 2, PUBLISH message received from broker to acknowledge, send PUBREC, state change to wait PUBREL
else if (msgContext.Flow == MqttMsgFlow.ToAcknowledge)
{
MqttMsgPubrec pubrec = new MqttMsgPubrec();
pubrec.MessageId = ((MqttMsgPublish)msgInflight).MessageId;
msgContext.State = MqttMsgState.WaitForPubrel;
this.Send(pubrec);
// re-enqueue message (I have to re-analyze for receiving PUBREL)
this.inflightQueue.Enqueue(msgContext);
}
break;
case MqttMsgState.WaitForPuback:
case MqttMsgState.WaitForSuback:
case MqttMsgState.WaitForUnsuback:
// QoS 1, waiting for PUBACK of a PUBLISH message sent or
// waiting for SUBACK of a SUBSCRIBE message sent or
// waiting for UNSUBACK of a UNSUBSCRIBE message sent or
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
acknowledge = false;
lock (this.internalQueue)
{
if (this.internalQueue.Count > 0)
msgReceived = (MqttMsgBase)this.internalQueue.Peek();
}
// it is a PUBACK message or a SUBACK/UNSUBACK message
if ((msgReceived != null) && ((msgReceived.Type == MqttMsgBase.MQTT_MSG_PUBACK_TYPE) ||
(msgReceived.Type == MqttMsgBase.MQTT_MSG_SUBACK_TYPE) ||
(msgReceived.Type == MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE)))
{
// PUBACK message or SUBACK message for the current message
if (((msgInflight.Type == MqttMsgBase.MQTT_MSG_PUBLISH_TYPE) && (((MqttMsgPuback)msgReceived).MessageId == ((MqttMsgPublish)msgInflight).MessageId)) ||
((msgInflight.Type == MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE) && (((MqttMsgSuback)msgReceived).MessageId == ((MqttMsgSubscribe)msgInflight).MessageId)) ||
((msgInflight.Type == MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE) && (((MqttMsgUnsuback)msgReceived).MessageId == ((MqttMsgUnsubscribe)msgInflight).MessageId)))
{
lock (this.internalQueue)
{
// received message processed
this.internalQueue.Dequeue();
acknowledge = true;
}
// notify received acknowledge from broker of a published message or subscribe/unsubscribe message
this.OnMqttMsgReceived(msgReceived);
}
}
// current message not acknowledged, no PUBACK or SUBACK/UNSUBACK or not equal messageid
if (!acknowledge)
{
// check timeout for receiving PUBACK since PUBLISH was sent or
// for receiving SUBACK since SUBSCRIBE was sent or
// for receiving UNSUBACK since UNSUBSCRIBE was sent
if ((Environment.TickCount - msgContext.Timestamp) >= this.settings.DelayOnRetry)
{
// max retry not reached, resend
if (msgContext.Attempt <= this.settings.AttemptsOnRetry)
{
msgContext.State = MqttMsgState.QueuedQos1;
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
// update timeout (0 -> reanalyze queue immediately)
timeout = 0;
}
}
else
{
// re-enqueue message (I have to re-analyze for receiving PUBACK, SUBACK or UNSUBACK)
this.inflightQueue.Enqueue(msgContext);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
}
}
}
break;
case MqttMsgState.WaitForPubrec:
// QoS 2, waiting for PUBREC of a PUBLISH message sent
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
acknowledge = false;
lock (this.internalQueue)
{
if (this.internalQueue.Count > 0)
msgReceived = (MqttMsgBase)this.internalQueue.Peek();
}
// it is a PUBREC message
if ((msgReceived != null) && (msgReceived.Type == MqttMsgBase.MQTT_MSG_PUBREC_TYPE))
{
// PUBREC message for the current PUBLISH message, send PUBREL, wait for PUBCOMP
if (((MqttMsgPubrec)msgReceived).MessageId == ((MqttMsgPublish)msgInflight).MessageId)
{
lock (this.internalQueue)
{
// received message processed
this.internalQueue.Dequeue();
acknowledge = true;
}
MqttMsgPubrel pubrel = new MqttMsgPubrel();
pubrel.MessageId = ((MqttMsgPublish)msgInflight).MessageId;
msgContext.State = MqttMsgState.WaitForPubcomp;
msgContext.Timestamp = Environment.TickCount;
msgContext.Attempt = 1;
this.Send(pubrel);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
}
}
// current message not acknowledged
if (!acknowledge)
{
// check timeout for receiving PUBREC since PUBLISH was sent
if ((Environment.TickCount - msgContext.Timestamp) >= this.settings.DelayOnRetry)
{
// max retry not reached, resend
if (msgContext.Attempt <= this.settings.AttemptsOnRetry)
{
msgContext.State = MqttMsgState.QueuedQos2;
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
// update timeout (0 -> reanalyze queue immediately)
timeout = 0;
}
}
else
{
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
}
}
}
break;
case MqttMsgState.WaitForPubrel:
// QoS 2, waiting for PUBREL of a PUBREC message sent
if (msgContext.Flow == MqttMsgFlow.ToAcknowledge)
{
lock (this.internalQueue)
{
if (this.internalQueue.Count > 0)
msgReceived = (MqttMsgBase)this.internalQueue.Peek();
}
// it is a PUBREL message
if ((msgReceived != null) && (msgReceived.Type == MqttMsgBase.MQTT_MSG_PUBREL_TYPE))
{
// PUBREL message for the current message, send PUBCOMP
if (((MqttMsgPubrel)msgReceived).MessageId == ((MqttMsgPublish)msgInflight).MessageId)
{
lock (this.internalQueue)
{
// received message processed
this.internalQueue.Dequeue();
}
MqttMsgPubcomp pubcomp = new MqttMsgPubcomp();
pubcomp.MessageId = ((MqttMsgPublish)msgInflight).MessageId;
this.Send(pubcomp);
// notify published message from broker and acknowledged
this.OnMqttMsgReceived(msgInflight);
}
else
{
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
}
}
else
{
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
}
}
break;
case MqttMsgState.WaitForPubcomp:
// QoS 2, waiting for PUBCOMP of a PUBREL message sent
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
acknowledge = false;
lock (this.internalQueue)
{
if (this.internalQueue.Count > 0)
msgReceived = (MqttMsgBase)this.internalQueue.Peek();
}
// it is a PUBCOMP message
if ((msgReceived != null) && (msgReceived.Type == MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE))
{
// PUBCOMP message for the current message
if (((MqttMsgPubcomp)msgReceived).MessageId == ((MqttMsgPublish)msgInflight).MessageId)
{
lock (this.internalQueue)
{
// received message processed
this.internalQueue.Dequeue();
acknowledge = true;
}
// notify received acknowledge from broker of a published message
this.OnMqttMsgReceived(msgReceived);
}
}
// current message not acknowledged
if (!acknowledge)
{
// check timeout for receiving PUBCOMP since PUBREL was sent
if ((Environment.TickCount - msgContext.Timestamp) >= this.settings.DelayOnRetry)
{
// max retry not reached, resend
if (msgContext.Attempt < this.settings.AttemptsOnRetry)
{
msgContext.State = MqttMsgState.SendPubrel;
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
// update timeout (0 -> reanalyze queue immediately)
timeout = 0;
}
}
else
{
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
}
}
}
break;
case MqttMsgState.SendPubrec:
// TODO : impossible ? --> QueuedQos2 ToAcknowledge
break;
case MqttMsgState.SendPubrel:
// QoS 2, PUBREL message to send to broker, state change to wait PUBCOMP
if (msgContext.Flow == MqttMsgFlow.ToPublish)
{
MqttMsgPubrel pubrel = new MqttMsgPubrel();
pubrel.MessageId = ((MqttMsgPublish)msgInflight).MessageId;
msgContext.State = MqttMsgState.WaitForPubcomp;
msgContext.Timestamp = Environment.TickCount;
msgContext.Attempt++;
// retry ? set dup flag
if (msgContext.Attempt > 1)
pubrel.DupFlag = true;
this.Send(pubrel);
// update timeout
int msgTimeout = (this.settings.DelayOnRetry - (Environment.TickCount - msgContext.Timestamp));
timeout = (msgTimeout < timeout) ? msgTimeout : timeout;
// re-enqueue message
this.inflightQueue.Enqueue(msgContext);
}
break;
case MqttMsgState.SendPubcomp:
// TODO : impossible ?
break;
case MqttMsgState.SendPuback:
// TODO : impossible ? --> QueuedQos1 ToAcknowledge
break;
default:
break;
}
}
// if calculated timeout is MaxValue, it means that must be Infinite (-1)
if (timeout == Int32.MaxValue)
timeout = Timeout.Infinite;
}
}
}
}
catch (MqttCommunicationException e)
{
MqttUtility.Trace.WriteLine(TraceLevel.Error, "Exception occurred: {0}", e.ToString());
this.Close();
// raise disconnection client event
this.OnMqttMsgDisconnected();
}
}
/// <summary>
/// Enqueue a message into the internal queue
/// </summary>
/// <param name="msg">Message to enqueue</param>
private void EnqueueInternal(MqttMsgBase msg)
{
// enqueue is needed (or not)
bool enqueue = true;
// if it is a PUBREL message (for QoS Level 2)
if (msg.Type == MqttMsgBase.MQTT_MSG_PUBREL_TYPE)
{
lock (this.inflightQueue)
{
// if it is a PUBREL but the corresponding PUBLISH isn't in the inflight queue,
// it means that we processed PUBLISH message and received PUBREL and we sent PUBCOMP
// but publisher didn't receive PUBCOMP so it re-sent PUBREL. We need only to re-send PUBCOMP.
// NOTE : I need to find on message id and flow because the broker could be publish/received
// to/from client and message id could be the same (one tracked by broker and the other by client)
MqttMsgContextFinder msgCtxFinder = new MqttMsgContextFinder(((MqttMsgPubrel)msg).MessageId, MqttMsgFlow.ToAcknowledge);
MqttMsgContext msgCtx = (MqttMsgContext)this.inflightQueue.Get(msgCtxFinder.Find);
// the PUBLISH message isn't in the inflight queue, it was already processed so
// we need to re-send PUBCOMP only
if (msgCtx == null)
{
MqttMsgPubcomp pubcomp = new MqttMsgPubcomp();
pubcomp.MessageId = ((MqttMsgPubrel)msg).MessageId;
this.Send(pubcomp);
enqueue = false;
}
}
}
if (enqueue)
{
lock (this.internalQueue)
{
this.internalQueue.Enqueue(msg);
this.inflightWaitHandle.Set();
}
}
}