/// <summary>
/// Parse bytes for a PUBACK 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>PUBACK message instance</returns>
public static MqttMsgPuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPuback msg = new MqttMsgPuback();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBACK_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 MqttMsgPuback BuildPubAck(ushort messageId)
{
MqttMsgPuback pubAck = new MqttMsgPuback();
pubAck.MessageId = messageId;
return(pubAck);
}
public static void Puback(MqttClientConnection clientConnection, ushort messageId)
{
MqttMsgPuback puback = new MqttMsgPuback();
puback.MessageId = messageId;
Send(clientConnection, puback);
}
private void HandlePUBACKType(uint clientIndex, MqttMsgPuback pubAck)
{
try
{
publishManager.ManagePubAck(clientIndex, pubAck);
}
catch (Exception)
{
throw;
}
}
public void PubackBasicDecodeTestv5()
{
// Arrange
byte[] encodedCorrect = new byte[] { 4, 0, 42, 0, 0 };
MokChannel mokChannel = new(encodedCorrect);
// Act
MqttMsgPuback puback = MqttMsgPuback.Parse(64, MqttProtocolVersion.Version_5, mokChannel);
// Assert
Assert.Equal((ushort)42, puback.MessageId);
}
/// <summary>
/// Parse bytes for a PUBACK message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBACK message instance</returns>
public static MqttMsgPuback Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPuback msg = new MqttMsgPuback();
// 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 PUBACK message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBACK message instance</returns>
public static MqttMsgPuback Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPuback msg = new MqttMsgPuback();
// 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 void PubackAdvanceDecodeTestv5()
{
// Arrange
byte[] encodedCorrect = new byte[] { 53, 0, 42, 151, 49, 31, 0, 26, 89, 111, 117, 32, 104, 97, 118, 101, 32, 101, 120, 99, 101, 101, 100,
32, 121, 111, 117, 114, 32, 113, 117, 111, 116, 97, 38, 0, 4, 80, 114, 111, 112, 0, 1, 49, 38, 0, 4, 80, 114,
111, 112, 0, 1, 50 };
MokChannel mokChannel = new(encodedCorrect);
// Act
MqttMsgPuback puback = MqttMsgPuback.Parse(64, MqttProtocolVersion.Version_5, mokChannel);
// Assert
Assert.Equal((ushort)42, puback.MessageId);
Assert.Equal((byte)puback.ReasonCode, (byte)MqttReasonCode.QuotaExceeded);
Assert.Equal(puback.Reason, "You have exceed your quota");
Assert.Equal(puback.UserProperties.Count, 2);
var prop = new UserProperty("Prop", "1");
Assert.Equal(((UserProperty)puback.UserProperties[0]).Name, prop.Name);
Assert.Equal(((UserProperty)puback.UserProperties[0]).Value, prop.Value);
prop = new UserProperty("Prop", "2");
Assert.Equal(((UserProperty)puback.UserProperties[1]).Name, prop.Name);
Assert.Equal(((UserProperty)puback.UserProperties[1]).Value, prop.Value);
}
public static MqttMsgBase DecodeControlPacket(byte[] data)
{
byte fixedHeaderFirstByte = (byte)(data[0] >> MqttMsgBase.MSG_TYPE_OFFSET);
switch (fixedHeaderFirstByte)
{
case MqttMsgBase.MQTT_MSG_CONNECT_TYPE:
{
return(MqttMsgConnect.Parse(data));
}
case MqttMsgBase.MQTT_MSG_CONNACK_TYPE:
{
return(MqttMsgConnack.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE:
{
return(MqttMsgPublish.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBACK_TYPE:
{
return(MqttMsgPuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBREC_TYPE:
{
return(MqttMsgPubrec.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBREL_TYPE:
{
return(MqttMsgPubrel.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE:
{
return(MqttMsgPubcomp.Parse(data));
}
case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE:
{
return(MqttMsgSubscribe.Parse(data));
}
case MqttMsgBase.MQTT_MSG_SUBACK_TYPE:
{
return(MqttMsgSuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE:
{
return(MqttMsgUnsubscribe.Parse(data));
}
case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE:
{
return(MqttMsgUnsuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE:
{
return(MqttMsgPingReq.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE:
{
return(MqttMsgPingResp.Parse(data));
}
case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE:
{
CrestronLogger.WriteToLog("PACKETDECODER - Riconosciuto DISCONNNECT: ", 1);
return(MqttMsgDisconnect.Parse(data));
}
default:
{
throw new FormatException();
}
}
}
/// <summary>
/// Thread for receiving messages from broker
/// </summary>
private void ReceiveThread()
{
int readBytes;
byte[] fixedHeaderFirstByte = new byte[1];
byte msgType;
while (this.isRunning)
{
try
{
// read first byte (fixed header)
readBytes = this.socket.Receive(fixedHeaderFirstByte);
if (readBytes > 0)
{
// extract message type from received byte
msgType = (byte)((fixedHeaderFirstByte[0] & MqttMsgBase.MSG_TYPE_MASK) >> MqttMsgBase.MSG_TYPE_OFFSET);
switch (msgType)
{
// impossible, broker can't send CONNECT message
case MqttMsgBase.MQTT_MSG_CONNECT_TYPE:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
// CONNACK message received from broker
case MqttMsgBase.MQTT_MSG_CONNACK_TYPE:
this.msgReceived = MqttMsgConnack.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
break;
// impossible, broker can't send PINGREQ message
case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
// CONNACK message received from broker
case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE:
this.msgReceived = MqttMsgPingResp.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
break;
// impossible, broker can't send SUBSCRIBE message
case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
// SUBACK message received from broker
case MqttMsgBase.MQTT_MSG_SUBACK_TYPE:
this.msgReceived = MqttMsgSuback.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
// raise subscribed topic event (SUBACK message received)
this.OnMqttMsgSubscribed((MqttMsgSuback)this.msgReceived);
break;
// PUBLISH message received from broker
case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE:
MqttMsgPublish msgReceived = MqttMsgPublish.Parse(fixedHeaderFirstByte[0], this.socket);
// for QoS Level 1 and 2, client sends PUBACK message to broker
if ((this.msgReceived.QosLevel == MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE) ||
(this.msgReceived.QosLevel == MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE))
{
MqttMsgPuback puback = new MqttMsgPuback();
puback.MessageId = (msgReceived).MessageId;
this.Send(puback.GetBytes());
}
// raise PUBLISH message received event
this.OnMqttMsgPublishReceived(msgReceived);
break;
// PUBACK message received from broker
case MqttMsgBase.MQTT_MSG_PUBACK_TYPE:
this.msgReceived = MqttMsgPuback.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
// raise published message event
// (PUBACK received for QoS Level 1)
this.OnMqttMsgPublished(((MqttMsgPuback)this.msgReceived).MessageId);
break;
// PUBREC message received from broker
case MqttMsgBase.MQTT_MSG_PUBREC_TYPE:
this.msgReceived = MqttMsgPubrec.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
break;
// impossible, broker can't send PUBREL message
case MqttMsgBase.MQTT_MSG_PUBREL_TYPE:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
// PUBCOMP message received from broker
case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE:
this.msgReceived = MqttMsgPubcomp.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
// raise published message event
// (PUBCOMP received for QoS Level 2)
this.OnMqttMsgPublished(((MqttMsgPuback)this.msgReceived).MessageId);
break;
// impossible, broker can't send UNSUBSCRIBE message
case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
// UNSUBACK message received from broker
case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE:
this.msgReceived = MqttMsgUnsuback.Parse(fixedHeaderFirstByte[0], this.socket);
this.endReceiving.Set();
// raise unsubscribed topic event
this.OnMqttMsgUnsubscribed(((MqttMsgUnsuback)this.msgReceived).MessageId);
break;
default:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
}
this.exReceiving = null;
}
}
catch (Exception)
{
this.exReceiving = new MqttCommunicationException();
}
}
}
public MqttMsgBase DecodeControlPacket(byte[] data)
{
byte fixedHeaderFirstByte = (byte)(data[0] >> MSG_TYPE_OFFSET);
switch (fixedHeaderFirstByte)
{
case MqttMsgBase.MQTT_MSG_CONNECT_TYPE:
{
return(MqttMsgConnect.Parse(data));
}
case MqttMsgBase.MQTT_MSG_CONNACK_TYPE:
{
return(MqttMsgConnack.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE:
{
return(MqttMsgPublish.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBACK_TYPE:
{
return(MqttMsgPuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBREC_TYPE:
{
return(MqttMsgPubrec.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBREL_TYPE:
{
return(MqttMsgPubrel.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE:
{
return(MqttMsgPubcomp.Parse(data));
}
case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE:
{
return(MqttMsgSubscribe.Parse(data));
}
case MqttMsgBase.MQTT_MSG_SUBACK_TYPE:
{
return(MqttMsgSuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE:
{
return(MqttMsgUnsubscribe.Parse(data));
}
case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE:
{
return(MqttMsgUnsuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE:
{
return(MqttMsgPingReq.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE:
{
return(MqttMsgPingResp.Parse(data));
}
case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE:
{
return(MqttMsgDisconnect.Parse(data));
}
default:
{
throw new FormatException(" First byte shifted : " + fixedHeaderFirstByte);
}
}
}
/// <summary>
/// Publish a message to the broker
/// </summary>
/// <param name="topic">Message topic</param>
/// <param name="message">Message data (payload)</param>
/// <param name="qosLevel">QoS Level</param>
/// <param name="retain">Retain flag</param>
/// <returns>Message Id related to PUBLISH message</returns>
public ushort Publish(string topic, byte[] message,
byte qosLevel = MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE,
bool retain = false)
{
ushort messageId = 0;
int attempts = 0;
bool acknowledged = false;
MqttMsgPublish publish =
new MqttMsgPublish(topic, message, false, qosLevel, retain);
// based on QoS level, the messages flow between client and broker changes
switch (qosLevel)
{
// QoS Level 0, no answer from broker
case MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE:
this.Send(publish.GetBytes());
break;
// QoS Level 1, waiting for PUBACK message from broker
case MqttMsgBase.QOS_LEVEL_AT_LEAST_ONCE:
attempts = 0;
acknowledged = false;
do
{
MqttMsgPuback puback = null;
try
{
// try publish
puback = (MqttMsgPuback)this.SendReceive(publish.GetBytes());
acknowledged = true;
}
catch (MqttTimeoutException)
{
// no PUBACK message received in time, retry with duplicate flag
attempts++;
publish.DupFlag = true;
// delay before retry
if (attempts < MQTT_ATTEMPTS_RETRY)
{
Thread.Sleep(MQTT_DELAY_RETRY);
}
}
} while ((attempts < MQTT_ATTEMPTS_RETRY) && !acknowledged);
if (acknowledged)
{
messageId = publish.MessageId;
}
break;
// QoS Level 2, waiting for PUBREC message from broker,
// send PUBREL message and waiting for PUBCOMP message from broker
case MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE:
attempts = 0;
acknowledged = false;
do
{
MqttMsgPubrec pubrec = null;
try
{
// try publish
pubrec = (MqttMsgPubrec)this.SendReceive(publish.GetBytes());
acknowledged = true;
}
catch (MqttTimeoutException)
{
// no PUBREC message received in time, retry with duplicate flag
attempts++;
publish.DupFlag = true;
// delay before retry
if (attempts < MQTT_ATTEMPTS_RETRY)
{
Thread.Sleep(MQTT_DELAY_RETRY);
}
}
} while ((attempts < MQTT_ATTEMPTS_RETRY) && !acknowledged);
// first phase ok
if (acknowledged)
{
attempts = 0;
acknowledged = false;
do
{
// set publish message identifier into PUBREL message
MqttMsgPubrel pubrel = new MqttMsgPubrel();
pubrel.MessageId = publish.MessageId;
MqttMsgPubcomp pubcomp = null;
try
{
// try send PUBREL message
pubcomp = (MqttMsgPubcomp)this.SendReceive(pubrel.GetBytes());
acknowledged = true;
}
catch (MqttTimeoutException)
{
// no PUBCOMP message received in time, retry with duplicate flag
attempts++;
pubrel.DupFlag = true;
// delay before retry
if (attempts < MQTT_ATTEMPTS_RETRY)
{
Thread.Sleep(MQTT_DELAY_RETRY);
}
}
} while ((attempts < MQTT_ATTEMPTS_RETRY) && !acknowledged);
if (acknowledged)
{
messageId = publish.MessageId;
}
}
break;
default:
throw new MqttClientException(MqttClientErrorCode.QosNotAllowed);
}
return(messageId);
}
public MqttMsgBase DecodeControlPacket(byte[] data)
{
#if PACKET_DEBUG
CrestronLogger.WriteToLog("MQTTCLIENT - RECEIVE - " + BitConverter.ToString(data), 2);
#endif
byte fixedHeaderFirstByte = (byte)(data[0] >> MSG_TYPE_OFFSET);
switch (fixedHeaderFirstByte)
{
case MqttMsgBase.MQTT_MSG_CONNECT_TYPE:
{
return(MqttMsgConnect.Parse(data));
}
case MqttMsgBase.MQTT_MSG_CONNACK_TYPE:
{
return(MqttMsgConnack.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE:
{
return(MqttMsgPublish.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBACK_TYPE:
{
return(MqttMsgPuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBREC_TYPE:
{
return(MqttMsgPubrec.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBREL_TYPE:
{
return(MqttMsgPubrel.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE:
{
return(MqttMsgPubcomp.Parse(data));
}
case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE:
{
return(MqttMsgSubscribe.Parse(data));
}
case MqttMsgBase.MQTT_MSG_SUBACK_TYPE:
{
return(MqttMsgSuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE:
{
return(MqttMsgUnsubscribe.Parse(data));
}
case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE:
{
return(MqttMsgUnsuback.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE:
{
return(MqttMsgPingReq.Parse(data));
}
case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE:
{
return(MqttMsgPingResp.Parse(data));
}
case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE:
{
return(MqttMsgDisconnect.Parse(data));
}
default:
{
throw new FormatException(" First byte shifted : " + fixedHeaderFirstByte);
}
}
}
internal void ManagePubAck(MqttMsgPuback pubAck)
{
sessionManager.RemoveInflightMessage(pubAck.MessageId);
}
public void ProcessReceivedMessage(MqttRawMessage rawMessage)
{
if (!rawMessage.Connection.IsRunning)
{
return;
}
// update last message received ticks
rawMessage.Connection.LastCommunicationTime = Environment.TickCount;
// extract message type from received byte
var msgType = (byte)((rawMessage.MessageType & MqttMsgBase.MSG_TYPE_MASK) >> MqttMsgBase.MSG_TYPE_OFFSET);
var protocolVersion = (byte)rawMessage.Connection.ProtocolVersion;
switch (msgType)
{
case MqttMsgBase.MQTT_MSG_CONNECT_TYPE:
var connect = MqttMsgConnect.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer);
rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(connect));
break;
case MqttMsgBase.MQTT_MSG_PINGREQ_TYPE:
var pingReqest = MqttMsgPingReq.Parse(rawMessage.MessageType, protocolVersion);
outgoingMessageHandler.PingResp(rawMessage.Connection);
break;
case MqttMsgBase.MQTT_MSG_SUBSCRIBE_TYPE:
var subscribe = MqttMsgSubscribe.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer,
rawMessage.PayloadLength);
rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(subscribe));
break;
case MqttMsgBase.MQTT_MSG_PUBLISH_TYPE:
var publish = MqttMsgPublish.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer,
rawMessage.PayloadLength);
EnqueueInflight(rawMessage.Connection, publish, MqttMsgFlow.ToAcknowledge);
break;
case MqttMsgBase.MQTT_MSG_PUBACK_TYPE:
// enqueue PUBACK message received (for QoS Level 1) into the internal queue
var puback = MqttMsgPuback.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer);
EnqueueInternal(rawMessage.Connection, puback);
break;
case MqttMsgBase.MQTT_MSG_PUBREC_TYPE:
// enqueue PUBREC message received (for QoS Level 2) into the internal queue
var pubrec = MqttMsgPubrec.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer);
EnqueueInternal(rawMessage.Connection, pubrec);
break;
case MqttMsgBase.MQTT_MSG_PUBREL_TYPE:
// enqueue PUBREL message received (for QoS Level 2) into the internal queue
var pubrel = MqttMsgPubrel.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer);
EnqueueInternal(rawMessage.Connection, pubrel);
break;
case MqttMsgBase.MQTT_MSG_PUBCOMP_TYPE:
// enqueue PUBCOMP message received (for QoS Level 2) into the internal queue
var pubcomp = MqttMsgPubcomp.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer);
EnqueueInternal(rawMessage.Connection, pubcomp);
break;
case MqttMsgBase.MQTT_MSG_UNSUBSCRIBE_TYPE:
var unsubscribe = MqttMsgUnsubscribe.Parse(
rawMessage.MessageType,
protocolVersion,
rawMessage.PayloadBuffer,
rawMessage.PayloadLength);
rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(unsubscribe));
break;
case MqttMsgBase.MQTT_MSG_DISCONNECT_TYPE:
var disconnect = MqttMsgDisconnect.Parse(rawMessage.MessageType, protocolVersion);
rawMessage.Connection.EnqueueInternalEvent(new InternalEvent(disconnect));
break;
case MqttMsgBase.MQTT_MSG_CONNACK_TYPE:
case MqttMsgBase.MQTT_MSG_PINGRESP_TYPE:
case MqttMsgBase.MQTT_MSG_SUBACK_TYPE:
case MqttMsgBase.MQTT_MSG_UNSUBACK_TYPE:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
default:
throw new MqttClientException(MqttClientErrorCode.WrongBrokerMessage);
}
}
private void HandlePUBACKType(MqttMsgPuback pubAck)
{
publisherManager.ManagePubAck(pubAck);
}
internal void ManagePubAck(uint clientIndex, MqttMsgPuback pubAck)
{
throw new NotImplementedException();
}
