[DW] Flex4Grid deleted

[NF] BosMon Mqtt Plugin created

M2Mqtt/Messages/MqttMsgBase.cs

@@ -0,0 +1,176 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if SSL && !WINDOWS_PHONE
+#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+using Microsoft.SPOT.Net.Security;
+#else
+using System.Net.Security;
+#endif
+#endif
+using System;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Base class for all MQTT messages
+    /// </summary>
+    public abstract class MqttMsgBase
+    {
+        #region Constants...
+
+        // mask, offset and size for fixed header fields
+        internal const byte MSG_TYPE_MASK = 0xF0;
+        internal const byte MSG_TYPE_OFFSET = 0x04;
+        internal const byte MSG_TYPE_SIZE = 0x04;
+        internal const byte DUP_FLAG_MASK = 0x08;
+        internal const byte DUP_FLAG_OFFSET = 0x03;
+        internal const byte DUP_FLAG_SIZE = 0x01;
+        internal const byte QOS_LEVEL_MASK = 0x06;
+        internal const byte QOS_LEVEL_OFFSET = 0x01;
+        internal const byte QOS_LEVEL_SIZE = 0x02;
+        internal const byte RETAIN_FLAG_MASK = 0x01;
+        internal const byte RETAIN_FLAG_OFFSET = 0x00;
+        internal const byte RETAIN_FLAG_SIZE = 0x01;
+
+        // MQTT message types
+        internal const byte MQTT_MSG_CONNECT_TYPE = 0x01;
+        internal const byte MQTT_MSG_CONNACK_TYPE = 0x02;
+        internal const byte MQTT_MSG_PUBLISH_TYPE = 0x03;
+        internal const byte MQTT_MSG_PUBACK_TYPE = 0x04;
+        internal const byte MQTT_MSG_PUBREC_TYPE = 0x05;
+        internal const byte MQTT_MSG_PUBREL_TYPE = 0x06;
+        internal const byte MQTT_MSG_PUBCOMP_TYPE = 0x07;
+        internal const byte MQTT_MSG_SUBSCRIBE_TYPE = 0x08;
+        internal const byte MQTT_MSG_SUBACK_TYPE = 0x09;
+        internal const byte MQTT_MSG_UNSUBSCRIBE_TYPE = 0x0A;
+        internal const byte MQTT_MSG_UNSUBACK_TYPE = 0x0B;
+        internal const byte MQTT_MSG_PINGREQ_TYPE = 0x0C;
+        internal const byte MQTT_MSG_PINGRESP_TYPE = 0x0D;
+        internal const byte MQTT_MSG_DISCONNECT_TYPE = 0x0E;
+
+        // QOS levels
+        public const byte QOS_LEVEL_AT_MOST_ONCE = 0x00;
+        public const byte QOS_LEVEL_AT_LEAST_ONCE = 0x01;
+        public const byte QOS_LEVEL_EXACTLY_ONCE = 0x02;
+
+        internal const ushort MAX_TOPIC_LENGTH = 65535;
+        internal const ushort MIN_TOPIC_LENGTH = 1;
+        internal const byte MESSAGE_ID_SIZE = 2;
+
+        #endregion
+
+        #region Properties...
+
+        /// <summary>
+        /// Message type
+        /// </summary>
+        public byte Type
+        {
+            get { return this.type; }
+            set { this.type = value; }
+        }
+
+        /// <summary>
+        /// Duplicate message flag
+        /// </summary>
+        public bool DupFlag
+        {
+            get { return this.dupFlag; }
+            set { this.dupFlag = value; }
+        }
+
+        /// <summary>
+        /// Quality of Service level
+        /// </summary>
+        public byte QosLevel
+        {
+            get { return this.qosLevel; }
+            set { this.qosLevel = value; }
+        }
+
+        /// <summary>
+        /// Retain message flag
+        /// </summary>
+        public bool Retain
+        {
+            get { return this.retain; }
+            set { this.retain = value; }
+        }
+
+        #endregion
+
+        // message type
+        protected byte type;
+        // duplicate delivery
+        protected bool dupFlag;
+        // quality of service level
+        protected byte qosLevel;
+        // retain flag
+        protected bool retain;
+
+        /// <summary>
+        /// Returns message bytes rapresentation
+        /// </summary>
+        /// <returns>Bytes rapresentation</returns>
+        public abstract byte[] GetBytes();
+        
+        /// <summary>
+        /// Encode remaining length and insert it into message buffer
+        /// </summary>
+        /// <param name="remainingLength">Remaining length value to encode</param>
+        /// <param name="buffer">Message buffer for inserting encoded value</param>
+        /// <param name="index">Index from which insert encoded value into buffer</param>
+        /// <returns>Index updated</returns>
+        protected int encodeRemainingLength(int remainingLength, byte[] buffer, int index)
+        {
+            int digit = 0;
+            do
+            {
+                digit = remainingLength % 128;
+                remainingLength /= 128;
+                if (remainingLength > 0)
+                    digit = digit | 0x80;
+                buffer[index++] = (byte)digit;
+            } while (remainingLength > 0);
+            return index;
+        }
+
+        /// <summary>
+        /// Decode remaining length reading bytes from socket
+        /// </summary>
+        /// <param name="channel">Channel from reading bytes</param>
+        /// <returns>Decoded remaining length</returns>
+        protected static int decodeRemainingLength(IMqttNetworkChannel channel)
+        {
+            int multiplier = 1;
+            int value = 0;
+            int digit = 0;
+            byte[] nextByte = new byte[1];
+            do
+            {
+                // next digit from stream
+                channel.Receive(nextByte);
+                digit = nextByte[0];
+                value += ((digit & 127) * multiplier);
+                multiplier *= 128;
+            } while ((digit & 128) != 0);
+            return value;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgConnack.cs

@@ -0,0 +1,137 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for CONNACK message from broker to client
+    /// </summary>
+    public class MqttMsgConnack : MqttMsgBase
+    {
+        #region Constants...
+
+        // return codes for CONNACK message
+        public const byte CONN_ACCEPTED = 0x00;
+        public const byte CONN_REFUSED_PROT_VERS = 0x01;
+        public const byte CONN_REFUSED_IDENT_REJECTED = 0x02;
+        public const byte CONN_REFUSED_SERVER_UNAVAILABLE = 0x03;
+        public const byte CONN_REFUSED_USERNAME_PASSWORD = 0x04;
+        public const byte CONN_REFUSED_NOT_AUTHORIZED = 0x05;
+
+        private const byte TOPIC_NAME_COMP_RESP_BYTE_OFFSET = 0;
+        private const byte TOPIC_NAME_COMP_RESP_BYTE_SIZE = 1;
+        private const byte CONN_RETURN_CODE_BYTE_OFFSET = 1;
+        private const byte CONN_RETURN_CODE_BYTE_SIZE = 1;
+
+        #endregion
+
+        #region Properties...
+
+        /// <summary>
+        /// Return Code
+        /// </summary>
+        public byte ReturnCode
+        {
+            get { return this.returnCode; }
+            set { this.returnCode = value; }
+        }
+
+        #endregion
+
+        // return code for CONNACK message
+        private byte returnCode;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgConnack()
+        {
+            this.type = MQTT_MSG_CONNACK_TYPE;
+        }
+
+        /// <summary>
+        /// Parse bytes for a CONNACK message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>CONNACK message instance</returns>
+        public static MqttMsgConnack Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            MqttMsgConnack msg = new MqttMsgConnack();
+
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            buffer = new byte[remainingLength];
+
+            // read bytes from socket...
+            channel.Receive(buffer);
+            // ...and set return code from broker
+            msg.returnCode = buffer[CONN_RETURN_CODE_BYTE_OFFSET];
+
+            return msg;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // topic name compression response and connect return code
+            varHeaderSize += (TOPIC_NAME_COMP_RESP_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE);
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)(MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET);
+            index++;
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // topic name compression response (reserved values. not used);
+            buffer[index++] = 0x00;
+            
+            // connect return code
+            buffer[index++] = this.returnCode;
+
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgConnect.cs

@@ -0,0 +1,509 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+using System.Text;
+using uPLibrary.Networking.M2Mqtt.Exceptions;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for CONNECT message from client to broker
+    /// </summary>
+    public class MqttMsgConnect : MqttMsgBase
+    {
+        #region Constants...
+
+        // protocol name supported
+        internal const string PROTOCOL_NAME = "MQIsdp";
+
+        // max length for client id
+        internal const int CLIENT_ID_MAX_LENGTH = 23;
+
+        // variable header fields
+        internal const byte PROTOCOL_NAME_LEN_SIZE = 2;
+        internal const byte PROTOCOL_NAME_SIZE = 6;
+        internal const byte PROTOCOL_VERSION_NUMBER_SIZE = 1;
+        internal const byte CONNECT_FLAGS_SIZE = 1;
+        internal const byte KEEP_ALIVE_TIME_SIZE = 2;
+
+        internal const byte PROTOCOL_VERSION = 0x03;
+        internal const ushort KEEP_ALIVE_PERIOD_DEFAULT = 60; // seconds
+        internal const ushort MAX_KEEP_ALIVE = 65535; // 16 bit
+
+        // connect flags
+        internal const byte USERNAME_FLAG_MASK = 0x80;
+        internal const byte USERNAME_FLAG_OFFSET = 0x07;
+        internal const byte USERNAME_FLAG_SIZE = 0x01;
+        internal const byte PASSWORD_FLAG_MASK = 0x40;
+        internal const byte PASSWORD_FLAG_OFFSET = 0x06;
+        internal const byte PASSWORD_FLAG_SIZE = 0x01;
+        internal const byte WILL_RETAIN_FLAG_MASK = 0x20;
+        internal const byte WILL_RETAIN_FLAG_OFFSET = 0x05;
+        internal const byte WILL_RETAIN_FLAG_SIZE = 0x01;
+        internal const byte WILL_QOS_FLAG_MASK = 0x18;
+        internal const byte WILL_QOS_FLAG_OFFSET = 0x03;
+        internal const byte WILL_QOS_FLAG_SIZE = 0x02;
+        internal const byte WILL_FLAG_MASK = 0x04;
+        internal const byte WILL_FLAG_OFFSET = 0x02;
+        internal const byte WILL_FLAG_SIZE = 0x01;
+        internal const byte CLEAN_SESSION_FLAG_MASK = 0x02;
+        internal const byte CLEAN_SESSION_FLAG_OFFSET = 0x01;
+        internal const byte CLEAN_SESSION_FLAG_SIZE = 0x01;
+
+        #endregion
+
+        #region Properties...
+
+        /// <summary>
+        /// Protocol name
+        /// </summary>
+        public string ProtocolName
+        {
+            get { return this.protocolName; }
+            set { this.protocolName = value; }
+        }
+
+        /// <summary>
+        /// Protocol version
+        /// </summary>
+        public byte ProtocolVersion
+        {
+            get { return this.protocolVersion; }
+            set { this.protocolVersion = value; }
+        }
+
+        /// <summary>
+        /// Client identifier
+        /// </summary>
+        public string ClientId
+        {
+            get { return this.clientId; }
+            set { this.clientId = value; }
+        }
+
+        /// <summary>
+        /// Will retain flag
+        /// </summary>
+        public bool WillRetain
+        {
+            get { return this.willRetain; }
+            set { this.willRetain = value; }
+        }
+
+        /// <summary>
+        /// Will QOS level
+        /// </summary>
+        public byte WillQosLevel
+        {
+            get { return this.willQosLevel; }
+            set { this.willQosLevel = value; }
+        }
+
+        /// <summary>
+        /// Will flag
+        /// </summary>
+        public bool WillFlag
+        {
+            get { return this.willFlag; }
+            set { this.willFlag = value; }
+        }
+
+        /// <summary>
+        /// Will topic
+        /// </summary>
+        public string WillTopic
+        {
+            get { return this.willTopic; }
+            set { this.willTopic = value; }
+        }
+
+        /// <summary>
+        /// Will message
+        /// </summary>
+        public string WillMessage
+        {
+            get { return this.willMessage; }
+            set { this.willMessage = value; }
+        }
+
+        /// <summary>
+        /// Username
+        /// </summary>
+        public string Username
+        {
+            get { return this.username; }
+            set { this.username = value; }
+        }
+
+        /// <summary>
+        /// Password
+        /// </summary>
+        public string Password
+        {
+            get { return this.password; }
+            set { this.password = value; }
+        }
+
+        /// <summary>
+        /// Clean session flag
+        /// </summary>
+        public bool CleanSession
+        {
+            get { return this.cleanSession; }
+            set { this.cleanSession = value; }
+        }
+
+        /// <summary>
+        /// Keep alive period
+        /// </summary>
+        public ushort KeepAlivePeriod
+        {
+            get { return this.keepAlivePeriod; }
+            set { this.keepAlivePeriod = value; }
+        }
+
+        #endregion
+
+        // protocol name
+        private string protocolName;
+        // protocol version
+        private byte protocolVersion;
+        // client identifier
+        private string clientId;
+        // will retain flag
+        protected bool willRetain;
+        // will quality of service level
+        protected byte willQosLevel;
+        // will flag
+        private bool willFlag;
+        // will topic
+        private string willTopic;
+        // will message
+        private string willMessage;
+        // username
+        private string username;
+        // password
+        private string password;
+        // clean session flag
+        private bool cleanSession;
+        // keep alive period (in sec)
+        private ushort keepAlivePeriod;
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgConnect()
+        {
+            this.type = MQTT_MSG_CONNECT_TYPE;
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="clientId">Client identifier</param>
+        public MqttMsgConnect(string clientId) :
+            this(clientId, null, null, false, QOS_LEVEL_AT_LEAST_ONCE, false, null, null, true, KEEP_ALIVE_PERIOD_DEFAULT)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="clientId">Client identifier</param>
+        /// <param name="username">Username</param>
+        /// <param name="password">Password</param>
+        /// <param name="willRetain">Will retain flag</param>
+        /// <param name="willQosLevel">Will QOS level</param>
+        /// <param name="willFlag">Will flag</param>
+        /// <param name="willTopic">Will topic</param>
+        /// <param name="willMessage">Will message</param>
+        /// <param name="cleanSession">Clean sessione flag</param>
+        /// <param name="keepAlivePeriod">Keep alive period</param>
+        public MqttMsgConnect(string clientId, 
+            string username, 
+            string password,
+            bool willRetain,
+            byte willQosLevel,
+            bool willFlag,
+            string willTopic,
+            string willMessage,
+            bool cleanSession,
+            ushort keepAlivePeriod
+            )
+        {
+            this.type = MQTT_MSG_CONNECT_TYPE;
+
+            this.clientId = clientId;
+            this.username = username;
+            this.password = password;
+            this.willRetain = willRetain;
+            this.willQosLevel = willQosLevel;
+            this.willFlag = willFlag;
+            this.willTopic = willTopic;
+            this.willMessage = willMessage;
+            this.cleanSession = cleanSession;
+            this.keepAlivePeriod = keepAlivePeriod;
+        }
+
+        /// <summary>
+        /// Parse bytes for a CONNECT message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>CONNECT message instance</returns>
+        public static MqttMsgConnect Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            int protNameUtf8Length;
+            byte[] protNameUtf8;
+            bool isUsernameFlag;
+            bool isPasswordFlag;
+            int clientIdUtf8Length;
+            byte[] clientIdUtf8;
+            int willTopicUtf8Length;
+            byte[] willTopicUtf8;
+            int willMessageUtf8Length;
+            byte[] willMessageUtf8;
+            int usernameUtf8Length;
+            byte[] usernameUtf8;
+            int passwordUtf8Length;
+            byte[] passwordUtf8;
+            MqttMsgConnect msg = new MqttMsgConnect();
+            
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            buffer = new byte[remainingLength];
+
+            // read bytes from socket...
+            channel.Receive(buffer);
+
+            // protocol name
+            protNameUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+            protNameUtf8Length |= buffer[index++];
+            protNameUtf8 = new byte[protNameUtf8Length];
+            Array.Copy(buffer, index, protNameUtf8, 0, protNameUtf8Length);
+            index += protNameUtf8Length;
+            msg.protocolName = new String(Encoding.UTF8.GetChars(protNameUtf8));
+
+            // protocol version
+            msg.protocolVersion = buffer[index];
+            index += PROTOCOL_VERSION_NUMBER_SIZE;
+
+            // connect flags
+            isUsernameFlag = (buffer[index] & USERNAME_FLAG_MASK) != 0x00;
+            isPasswordFlag = (buffer[index] & PASSWORD_FLAG_MASK) != 0x00;
+            msg.willRetain = (buffer[index] & WILL_RETAIN_FLAG_MASK) != 0x00;
+            msg.willQosLevel = (byte)((buffer[index] & WILL_QOS_FLAG_MASK) >> WILL_QOS_FLAG_OFFSET);
+            msg.willFlag = (buffer[index] & WILL_FLAG_MASK) != 0x00;
+            msg.cleanSession = (buffer[index] & CLEAN_SESSION_FLAG_MASK) != 0x00;
+            index += CONNECT_FLAGS_SIZE;
+
+            // keep alive timer
+            msg.keepAlivePeriod = (ushort)((buffer[index++] << 8) & 0xFF00);
+            msg.keepAlivePeriod |= buffer[index++];
+
+            // client identifier
+            clientIdUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+            clientIdUtf8Length |= buffer[index++];
+            clientIdUtf8 = new byte[clientIdUtf8Length];
+            Array.Copy(buffer, index, clientIdUtf8, 0, clientIdUtf8Length);
+            index += clientIdUtf8Length;
+            msg.clientId = new String(Encoding.UTF8.GetChars(clientIdUtf8));
+
+            // will topic and will message
+            if (msg.willFlag)
+            {
+                willTopicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+                willTopicUtf8Length |= buffer[index++];
+                willTopicUtf8 = new byte[willTopicUtf8Length];
+                Array.Copy(buffer, index, willTopicUtf8, 0, willTopicUtf8Length);
+                index += willTopicUtf8Length;
+                msg.willTopic = new String(Encoding.UTF8.GetChars(willTopicUtf8));
+
+                willMessageUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+                willMessageUtf8Length |= buffer[index++];
+                willMessageUtf8 = new byte[willMessageUtf8Length];
+                Array.Copy(buffer, index, willMessageUtf8, 0, willMessageUtf8Length);
+                index += willMessageUtf8Length;
+                msg.willMessage = new String(Encoding.UTF8.GetChars(willMessageUtf8));
+            }
+
+            // username
+            if (isUsernameFlag)
+            {
+                usernameUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+                usernameUtf8Length |= buffer[index++];
+                usernameUtf8 = new byte[usernameUtf8Length];
+                Array.Copy(buffer, index, usernameUtf8, 0, usernameUtf8Length);
+                index += usernameUtf8Length;
+                msg.username = new String(Encoding.UTF8.GetChars(usernameUtf8));
+            }
+
+            // password
+            if (isPasswordFlag)
+            {
+                passwordUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+                passwordUtf8Length |= buffer[index++];
+                passwordUtf8 = new byte[passwordUtf8Length];
+                Array.Copy(buffer, index, passwordUtf8, 0, passwordUtf8Length);
+                index += passwordUtf8Length;
+                msg.password = new String(Encoding.UTF8.GetChars(passwordUtf8));
+            }
+
+            return msg;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            byte[] clientIdUtf8 = Encoding.UTF8.GetBytes(this.clientId);
+            byte[] willTopicUtf8 = (this.willTopic != null) ? Encoding.UTF8.GetBytes(this.willTopic) : null;
+            byte[] willMessageUtf8 = (this.willMessage != null) ? Encoding.UTF8.GetBytes(this.willMessage) : null;
+            byte[] usernameUtf8 = (this.username != null) ? Encoding.UTF8.GetBytes(this.username) : null;
+            byte[] passwordUtf8 = (this.password != null) ? Encoding.UTF8.GetBytes(this.password) : null;
+
+            // will flag set but will topic wrong
+            if (this.willFlag && (willTopicUtf8.Length == 0))
+                throw new MqttClientException(MqttClientErrorCode.WillTopicWrong);
+            if (this.keepAlivePeriod > MAX_KEEP_ALIVE)
+                throw new MqttClientException(MqttClientErrorCode.KeepAliveWrong);
+
+            // protocol name field size
+            varHeaderSize += (PROTOCOL_NAME_LEN_SIZE + PROTOCOL_NAME_SIZE);
+            // protocol version number field size
+            varHeaderSize += PROTOCOL_VERSION_NUMBER_SIZE;
+            // connect flags field size
+            varHeaderSize += CONNECT_FLAGS_SIZE;
+            // keep alive timer field size
+            varHeaderSize += KEEP_ALIVE_TIME_SIZE;
+
+            // client identifier field size
+            payloadSize += clientIdUtf8.Length + 2;
+            // will topic field size
+            payloadSize += (willTopicUtf8 != null) ? (willTopicUtf8.Length + 2) : 0;
+            // will message field size
+            payloadSize += (willMessageUtf8 != null) ? (willMessageUtf8.Length + 2) : 0;
+            // username field size
+            payloadSize += (usernameUtf8 != null) ? (usernameUtf8.Length + 2) : 0;
+            // password field size
+            payloadSize += (passwordUtf8 != null) ? (passwordUtf8.Length + 2) : 0;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_CONNECT_TYPE << MSG_TYPE_OFFSET);
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // protocol name
+            buffer[index++] = 0; // MSB protocol name size
+            buffer[index++] = PROTOCOL_NAME_SIZE; // LSB protocol name size
+            buffer[index++] = (byte)'M';
+            buffer[index++] = (byte)'Q';
+            buffer[index++] = (byte)'I';
+            buffer[index++] = (byte)'s';
+            buffer[index++] = (byte)'d';
+            buffer[index++] = (byte)'p';
+
+            // protocol version
+            buffer[index++] = PROTOCOL_VERSION;
+
+            // connect flags
+            byte connectFlags = 0x00;
+            connectFlags |= (this.username != null) ? (byte)(1 << USERNAME_FLAG_OFFSET) : (byte)0x00;
+            connectFlags |= (this.password != null) ? (byte)(1 << PASSWORD_FLAG_OFFSET) : (byte)0x00;
+            connectFlags |= (this.willRetain) ? (byte)(1 << WILL_RETAIN_FLAG_OFFSET) : (byte)0x00;
+            connectFlags |= (byte)(this.willQosLevel << WILL_QOS_FLAG_OFFSET);
+            connectFlags |= (this.willFlag) ? (byte)(1 << WILL_FLAG_OFFSET) : (byte)0x00;
+            connectFlags |= (this.cleanSession) ? (byte)(1 << CLEAN_SESSION_FLAG_OFFSET) : (byte)0x00;
+            buffer[index++] = connectFlags;
+
+            // keep alive period
+            buffer[index++] = (byte)((this.keepAlivePeriod >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.keepAlivePeriod & 0x00FF); // LSB
+
+            // client identifier
+            buffer[index++] = (byte)((clientIdUtf8.Length >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(clientIdUtf8.Length & 0x00FF); // LSB
+            Array.Copy(clientIdUtf8, 0, buffer, index, clientIdUtf8.Length);
+            index += clientIdUtf8.Length;
+
+            // will topic
+            if (this.willFlag && (this.willTopic != null))
+            {
+                buffer[index++] = (byte)((willTopicUtf8.Length >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(willTopicUtf8.Length & 0x00FF); // LSB
+                Array.Copy(willTopicUtf8, 0, buffer, index, willTopicUtf8.Length);
+                index += willTopicUtf8.Length;
+            }
+
+            // will message
+            if (this.willFlag && (this.willMessage != null))
+            {
+                buffer[index++] = (byte)((willMessageUtf8.Length >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(willMessageUtf8.Length & 0x00FF); // LSB
+                Array.Copy(willMessageUtf8, 0, buffer, index, willMessageUtf8.Length);
+                index += willMessageUtf8.Length;
+            }
+
+            // username
+            if (this.username != null)
+            {
+                buffer[index++] = (byte)((usernameUtf8.Length >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(usernameUtf8.Length & 0x00FF); // LSB
+                Array.Copy(usernameUtf8, 0, buffer, index, usernameUtf8.Length);
+                index += usernameUtf8.Length;
+            }
+
+            // password
+            if (this.password != null)
+            {
+                buffer[index++] = (byte)((passwordUtf8.Length >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(passwordUtf8.Length & 0x00FF); // LSB
+                Array.Copy(passwordUtf8, 0, buffer, index, passwordUtf8.Length);
+                index += passwordUtf8.Length;
+            }
+
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgConnectEventArgs.cs

@@ -0,0 +1,46 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for CONNECT message received from client
+    /// </summary>
+    public class MqttMsgConnectEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Message received from client
+        /// </summary>
+        public MqttMsgConnect Message { get; private set; }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="msg">CONNECT message received from client</param>
+        public MqttMsgConnectEventArgs(MqttMsgConnect connect)
+        {
+            this.Message = connect;
+        }
+    }
+} 

M2Mqtt/Messages/MqttMsgContext.cs

@@ -0,0 +1,141 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+using System.Text;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Context for MQTT message
+    /// </summary>
+    public class MqttMsgContext
+    {
+        /// <summary>
+        /// MQTT message
+        /// </summary>
+        public MqttMsgBase Message { get; set; }
+
+        /// <summary>
+        /// MQTT message state
+        /// </summary>
+        public MqttMsgState State { get; set; }
+
+        /// <summary>
+        /// Flow of the message
+        /// </summary>
+        public MqttMsgFlow Flow { get; set; }
+
+        /// <summary>
+        /// Timestamp in ticks (for retry)
+        /// </summary>
+        public int Timestamp { get; set; }
+
+        /// <summary>
+        /// Attempt (for retry)
+        /// </summary>
+        public int Attempt { get; set; }
+    }
+
+    /// <summary>
+    /// Flow of the message
+    /// </summary>
+    public enum MqttMsgFlow
+    {
+        /// <summary>
+        /// To publish to subscribers
+        /// </summary>
+        ToPublish,
+
+        /// <summary>
+        /// To acknowledge to publisher
+        /// </summary>
+        ToAcknowledge
+    }
+
+    /// <summary>
+    /// MQTT message state
+    /// </summary>
+    public enum MqttMsgState
+    {
+        /// <summary>
+        /// QOS = 0, Message queued
+        /// </summary>
+        QueuedQos0,
+
+        /// <summary>
+        /// QOS = 1, Message queued
+        /// </summary>
+        QueuedQos1,
+
+        /// <summary>
+        /// QOS = 2, Message queued
+        /// </summary>
+        QueuedQos2,
+
+        /// <summary>
+        /// QOS = 1, PUBLISH sent, wait for PUBACK
+        /// </summary>
+        WaitForPuback,
+
+        /// <summary>
+        /// QOS = 2, PUBLISH sent, wait for PUBREC
+        /// </summary>
+        WaitForPubrec,
+
+        /// <summary>
+        /// QOS = 2, PUBREC sent, wait for PUBREL
+        /// </summary>
+        WaitForPubrel,
+
+        /// <summary>
+        /// QOS = 2, PUBREL sent, wait for PUBCOMP
+        /// </summary>
+        WaitForPubcomp,
+
+        /// <summary>
+        /// QOS = 2, start first phase handshake send PUBREC
+        /// </summary>
+        SendPubrec,
+        
+        /// <summary>
+        /// QOS = 2, start second phase handshake send PUBREL
+        /// </summary>
+        SendPubrel,
+
+        /// <summary>
+        /// QOS = 2, end second phase handshake send PUBCOMP
+        /// </summary>
+        SendPubcomp,
+
+        /// <summary>
+        /// QOS = 1, PUBLISH received, send PUBACK
+        /// </summary>
+        SendPuback,
+
+        /// <summary>
+        /// (QOS = 1), SUBSCRIBE sent, wait for SUBACK
+        /// </summary>
+        WaitForSuback,
+
+        /// <summary>
+        /// (QOS = 1), UNSUBSCRIBE sent, wait for UNSUBACK
+        /// </summary>
+        WaitForUnsuback
+    }
+}

M2Mqtt/Messages/MqttMsgDisconnect.cs

@@ -0,0 +1,64 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for DISCONNECT message from client to broker
+    /// </summary>
+    public class MqttMsgDisconnect : MqttMsgBase
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgDisconnect()
+        {
+            this.type = MQTT_MSG_DISCONNECT_TYPE;
+        }
+
+        /// <summary>
+        /// Parse bytes for a DISCONNECT message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>DISCONNECT message instance</returns>
+        public static MqttMsgDisconnect Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            MqttMsgDisconnect msg = new MqttMsgDisconnect();
+
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            // NOTE : remainingLength must be 0
+
+            return msg;
+        }
+
+        public override byte[] GetBytes()
+        {
+            byte[] buffer = new byte[2];
+            int index = 0;
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET);
+            buffer[index++] = 0x00;
+
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPingReq.cs

@@ -0,0 +1,64 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PINGREQ message from client to broker
+    /// </summary>
+    public class MqttMsgPingReq : MqttMsgBase
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPingReq()
+        {
+            this.type = MQTT_MSG_PINGREQ_TYPE;
+        }
+
+        public override byte[] GetBytes()
+        {
+            byte[] buffer = new byte[2];
+            int index = 0;
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET);
+            buffer[index++] = 0x00;
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Parse bytes for a PINGREQ message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>PINGREQ message instance</returns>
+        public static MqttMsgPingReq Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            MqttMsgPingReq msg = new MqttMsgPingReq();
+
+            // 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;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPingResp.cs

@@ -0,0 +1,65 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PINGRESP message from client to broker
+    /// </summary>
+    public class MqttMsgPingResp : MqttMsgBase
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPingResp()
+        {
+            this.type = MQTT_MSG_PINGRESP_TYPE;
+        }
+
+        /// <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;
+        }
+
+        public override byte[] GetBytes()
+        {
+            byte[] buffer = new byte[2];
+            int index = 0;
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET);
+            buffer[index++] = 0x00;
+
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPuback.cs

@@ -0,0 +1,119 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PUBACK message from broker to client
+    /// </summary>
+    public class MqttMsgPuback : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier for the publish message
+        /// that is acknowledged
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        private ushort messageId;
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPuback()
+        {
+            this.type = MQTT_MSG_PUBACK_TYPE;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET);
+                              
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // get message identifier
+            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+
+            return buffer;
+        }
+
+        /// <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;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPubcomp.cs

@@ -0,0 +1,118 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PUBCOMP message from broker to client
+    /// </summary>
+    public class MqttMsgPubcomp : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier for the acknowledged publish message
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        private ushort messageId;
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPubcomp()
+        {
+            this.type = MQTT_MSG_PUBCOMP_TYPE;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET);
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // get message identifier
+            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Parse bytes for a PUBCOMP message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>PUBCOMP message instance</returns>
+        public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            MqttMsgPubcomp msg = new MqttMsgPubcomp();
+
+            // 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;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPublish.cs

@@ -0,0 +1,270 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+using System.Text;
+using uPLibrary.Networking.M2Mqtt.Exceptions;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PUBLISH message from client to broker
+    /// </summary>
+    public class MqttMsgPublish : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message topic
+        /// </summary>
+        public string Topic
+        {
+            get { return this.topic; }
+            set { this.topic = value; }
+        }
+
+        /// <summary>
+        /// Message data
+        /// </summary>
+        public byte[] Message
+        {
+            get { return this.message; }
+            set { this.message = value; }
+        }
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message topic
+        private string topic;
+        // message data
+        private byte[] message;
+        // message identifier
+        ushort messageId;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPublish()
+        {
+            this.type = MQTT_MSG_PUBLISH_TYPE;
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="topic">Message topic</param>
+        /// <param name="message">Message data</param>
+        public MqttMsgPublish(string topic, byte[] message) :
+            this(topic, message, false, QOS_LEVEL_AT_MOST_ONCE, false)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="topic">Message topic</param>
+        /// <param name="message">Message data</param>
+        /// <param name="dupFlag">Duplicate flag</param>
+        /// <param name="qosLevel">Quality of Service level</param>
+        /// <param name="retain">Retain flag</param>
+        public MqttMsgPublish(string topic,
+            byte[] message,
+            bool dupFlag,
+            byte qosLevel,
+            bool retain) : base()
+        {
+            this.type = MQTT_MSG_PUBLISH_TYPE;
+
+            this.topic = topic;
+            this.message = message;
+            this.dupFlag = dupFlag;
+            this.qosLevel = qosLevel;
+            this.retain = retain;
+            this.messageId = 0;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // topic can't contain wildcards
+            if ((this.topic.IndexOf('#') != -1) || (this.topic.IndexOf('+') != -1))
+                throw new MqttClientException(MqttClientErrorCode.TopicWildcard);
+
+            // check topic length
+            if ((this.topic.Length < MIN_TOPIC_LENGTH) || (this.topic.Length > MAX_TOPIC_LENGTH))
+                throw new MqttClientException(MqttClientErrorCode.TopicLength);
+
+            byte[] topicUtf8 = Encoding.UTF8.GetBytes(this.topic);
+
+            // topic name
+            varHeaderSize += topicUtf8.Length + 2;
+
+            // message id is valid only with QOS level 1 or QOS level 2
+            if ((this.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) || 
+                (this.qosLevel == QOS_LEVEL_EXACTLY_ONCE))
+            {
+                varHeaderSize += MESSAGE_ID_SIZE;
+            }
+            
+            // check on message with zero length
+            if (this.message != null)
+                // message data
+                payloadSize += this.message.Length;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)((MQTT_MSG_PUBLISH_TYPE << MSG_TYPE_OFFSET) |
+                                   (this.qosLevel << QOS_LEVEL_OFFSET));
+            buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
+            buffer[index] |= this.retain ? (byte)(1 << RETAIN_FLAG_OFFSET) : (byte)0x00;
+            index++;
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // topic name
+            buffer[index++] = (byte)((topicUtf8.Length >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(topicUtf8.Length & 0x00FF); // LSB
+            Array.Copy(topicUtf8, 0, buffer, index, topicUtf8.Length);
+            index += topicUtf8.Length;
+
+            // message id is valid only with QOS level 1 or QOS level 2
+            if ((this.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) ||
+                (this.qosLevel == QOS_LEVEL_EXACTLY_ONCE))
+            {
+                // check message identifier assigned
+                if (this.messageId == 0)
+                    throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
+                buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB
+            }
+
+            // check on message with zero length
+            if (this.message != null)
+            {
+                // message data
+                Array.Copy(this.message, 0, buffer, index, this.message.Length);
+                index += this.message.Length;
+            }
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Parse bytes for a PUBLISH message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>PUBLISH message instance</returns>
+        public static MqttMsgPublish Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            byte[] topicUtf8;
+            int topicUtf8Length;
+            MqttMsgPublish msg = new MqttMsgPublish();
+
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            buffer = new byte[remainingLength];
+
+            // read bytes from socket...
+            int received = channel.Receive(buffer);
+
+            // topic name
+            topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+            topicUtf8Length |= buffer[index++];
+            topicUtf8 = new byte[topicUtf8Length];
+            Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
+            index += topicUtf8Length;
+            msg.topic = new String(Encoding.UTF8.GetChars(topicUtf8));
+
+            // read QoS level from fixed header
+            msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
+            // read DUP flag from fixed header
+            msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
+            // read retain flag from fixed header
+            msg.retain = (((fixedHeaderFirstByte & RETAIN_FLAG_MASK) >> RETAIN_FLAG_OFFSET) == 0x01);
+            
+            // message id is valid only with QOS level 1 or QOS level 2
+            if ((msg.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) ||
+                (msg.qosLevel == QOS_LEVEL_EXACTLY_ONCE))
+            {
+                // message id
+                msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
+                msg.messageId |= (buffer[index++]);
+            }
+
+            // get payload with message data
+            int messageSize = remainingLength - index;
+            int remaining = messageSize;
+            int messageOffset = 0;
+            msg.message = new byte[messageSize];
+
+            // BUG FIX 26/07/2013 : receiving large payload
+
+            // copy first part of payload data received
+            Array.Copy(buffer, index, msg.message, messageOffset, received - index);
+            remaining -= (received - index);
+            messageOffset += (received - index);
+
+            // if payload isn't finished
+            while (remaining > 0)
+            {
+                // receive other payload data
+                received = channel.Receive(buffer);
+                Array.Copy(buffer, 0, msg.message, messageOffset, received);
+                remaining -= received;
+                messageOffset += received;
+            }
+
+            return msg;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPublishEventArgs.cs

@@ -0,0 +1,113 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for PUBLISH message received from broker
+    /// </summary>
+    public class MqttMsgPublishEventArgs : EventArgs
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message topic
+        /// </summary>
+        public string Topic
+        {
+            get { return this.topic; }
+            internal set { this.topic = value; }
+        }
+
+        /// <summary>
+        /// Message data
+        /// </summary>
+        public byte[] Message
+        {
+            get { return this.message; }
+            internal set { this.message = value; }
+        }
+
+        /// <summary>
+        /// Duplicate message flag
+        /// </summary>
+        public bool DupFlag
+        {
+            get { return this.dupFlag; }
+            set { this.dupFlag = value; }
+        }
+
+        /// <summary>
+        /// Quality of Service level
+        /// </summary>
+        public byte QosLevel
+        {
+            get { return this.qosLevel; }
+            internal set { this.qosLevel = value; }
+        }
+
+        /// <summary>
+        /// Retain message flag
+        /// </summary>
+        public bool Retain
+        {
+            get { return this.retain; }
+            internal set { this.retain = value; }
+        }
+
+        #endregion
+
+        // message topic
+        private string topic;
+        // message data
+        private byte[] message;
+        // duplicate delivery
+        private bool dupFlag;
+        // quality of service level
+        private byte qosLevel;
+        // retain flag
+        private bool retain;       
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="topic">Message topic</param>
+        /// <param name="message">Message data</param>
+        /// <param name="dupFlag">Duplicate delivery flag</param>
+        /// <param name="qosLevel">Quality of Service level</param>
+        /// <param name="retain">Retain flag</param>
+        public MqttMsgPublishEventArgs(string topic,
+            byte[] message,
+            bool dupFlag,
+            byte qosLevel,
+            bool retain)
+        {
+            this.topic = topic;
+            this.message = message;
+            this.dupFlag = dupFlag;
+            this.qosLevel = qosLevel;
+            this.retain = retain;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPublishedEventArgs.cs

@@ -0,0 +1,57 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for published message
+    /// </summary>
+    public class MqttMsgPublishedEventArgs : EventArgs
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            internal set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        ushort messageId;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="messageId">Message identifier published</param>
+        public MqttMsgPublishedEventArgs(ushort messageId)
+        {
+            this.messageId = messageId;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPubrec.cs

@@ -0,0 +1,118 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PUBREC message from broker to client
+    /// </summary>
+    public class MqttMsgPubrec : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier for the acknowledged publish message
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        private ushort messageId;
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPubrec()
+        {
+            this.type = MQTT_MSG_PUBREC_TYPE;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index++] = (MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET);
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // get message identifier
+            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Parse bytes for a PUBREC message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>PUBREC message instance</returns>
+        public static MqttMsgPubrec Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            MqttMsgPubrec msg = new MqttMsgPubrec();
+
+            // 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;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgPubrel.cs

@@ -0,0 +1,128 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for PUBREL message from client top broker
+    /// </summary>
+    public class MqttMsgPubrel : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier for the acknowledged publish message
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        private ushort messageId;
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgPubrel()
+        {
+            this.type = MQTT_MSG_PUBREL_TYPE;
+            // PUBREL message use QoS Level 1
+            this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)((MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) |
+                                   (this.qosLevel << QOS_LEVEL_OFFSET));
+            buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
+            index++;
+            
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // get next message identifier
+            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB 
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Parse bytes for a PUBREL message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>PUBREL message instance</returns>
+        public static MqttMsgPubrel Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            MqttMsgPubrel msg = new MqttMsgPubrel();
+
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            buffer = new byte[remainingLength];
+
+            // read bytes from socket...
+            channel.Receive(buffer);
+
+            // read QoS level from fixed header (would be QoS Level 1)
+            msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
+            // read DUP flag from fixed header
+            msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
+
+            // message id
+            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
+            msg.messageId |= (buffer[index++]);
+
+            return msg;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgSuback.cs

@@ -0,0 +1,153 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for SUBACK message from broker to client
+    /// </summary>
+    public class MqttMsgSuback : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier for the subscribe message
+        /// that is acknowledged
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        /// <summary>
+        /// List of granted QOS Levels
+        /// </summary>
+        public byte[] GrantedQoSLevels
+        {
+            get { return this.grantedQosLevels; }
+            set { this.grantedQosLevels = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        private ushort messageId;
+        // granted QOS levels
+        byte[] grantedQosLevels;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgSuback()
+        {
+            this.type = MQTT_MSG_SUBACK_TYPE;
+        }
+
+        /// <summary>
+        /// Parse bytes for a SUBACK message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>SUBACK message instance</returns>
+        public static MqttMsgSuback Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            MqttMsgSuback msg = new MqttMsgSuback();
+
+            // 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++]);
+
+            // payload contains QoS levels granted
+            msg.grantedQosLevels = new byte[remainingLength - MESSAGE_ID_SIZE];
+            int qosIdx = 0;
+            do
+            {
+                msg.grantedQosLevels[qosIdx++] = buffer[index++];
+            } while (index < remainingLength);
+
+            return msg;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            int grantedQosIdx = 0;
+            for (grantedQosIdx = 0; grantedQosIdx < this.grantedQosLevels.Length; grantedQosIdx++)
+            {
+                payloadSize++;
+            }
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)(MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET);
+            index++;
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // message id
+            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB
+
+            // payload contains QoS levels granted
+            for (grantedQosIdx = 0; grantedQosIdx < this.grantedQosLevels.Length; grantedQosIdx++)
+            {
+                buffer[index++] = this.grantedQosLevels[grantedQosIdx];
+            }
+
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgSubscribe.cs

@@ -0,0 +1,255 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+// if NOT .Net Micro Framework
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System.Collections.Generic;
+#endif
+using System.Collections;
+using System.Text;
+using uPLibrary.Networking.M2Mqtt.Exceptions;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for SUBSCRIBE message from client to broker
+    /// </summary>
+    public class MqttMsgSubscribe : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// List of topics to subscribe
+        /// </summary>
+        public string[] Topics
+        {
+            get { return this.topics; }
+            set { this.topics = value; }
+        }
+
+        /// <summary>
+        /// List of QOS Levels related to topics
+        /// </summary>
+        public byte[] QoSLevels
+        {
+            get { return this.qosLevels; }
+            set { this.qosLevels = value; }
+        }
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // topics to subscribe
+        string[] topics;
+        // QOS levels related to topics
+        byte[] qosLevels;
+        // message identifier
+        ushort messageId;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgSubscribe()
+        {
+            this.type = MQTT_MSG_SUBSCRIBE_TYPE;
+        }
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="topics">List of topics to subscribe</param>
+        /// <param name="qosLevels">List of QOS Levels related to topics</param>
+        public MqttMsgSubscribe(string[] topics, byte[] qosLevels)
+        {
+            this.type = MQTT_MSG_SUBSCRIBE_TYPE;
+
+            this.topics = topics;
+            this.qosLevels = qosLevels;
+
+            // SUBSCRIBE message uses QoS Level 1
+            this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+        }
+
+        /// <summary>
+        /// Parse bytes for a SUBSCRIBE message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>SUBSCRIBE message instance</returns>
+        public static MqttMsgSubscribe Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            byte[] topicUtf8;
+            int topicUtf8Length;
+            MqttMsgSubscribe msg = new MqttMsgSubscribe();
+
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            buffer = new byte[remainingLength];
+
+            // read bytes from socket...
+            int received = channel.Receive(buffer);
+
+            // read QoS level from fixed header
+            msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
+            // read DUP flag from fixed header
+            msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
+            // retain flag not used
+            msg.retain = false;
+
+            // message id
+            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
+            msg.messageId |= (buffer[index++]);
+
+            // payload contains topics and QoS levels
+            // NOTE : before, I don't know how many topics will be in the payload (so use List)
+
+// if .Net Micro Framework
+#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+            IList tmpTopics = new ArrayList();
+            IList tmpQosLevels = new ArrayList();
+// else other frameworks (.Net, .Net Compact, Mono, Windows Phone) 
+#else
+            IList<String> tmpTopics = new List<String>();
+            IList<byte> tmpQosLevels = new List<byte>();
+#endif
+            do
+            {
+                // topic name
+                topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+                topicUtf8Length |= buffer[index++];
+                topicUtf8 = new byte[topicUtf8Length];
+                Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
+                index += topicUtf8Length;
+                tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
+
+                // QoS level
+                tmpQosLevels.Add(buffer[index++]);
+
+            } while (index < remainingLength);
+
+            // copy from list to array
+            msg.topics = new string[tmpTopics.Count];
+            msg.qosLevels = new byte[tmpQosLevels.Count];
+            for (int i = 0; i < tmpTopics.Count; i++)
+            {
+                msg.topics[i] = (string)tmpTopics[i];
+                msg.qosLevels[i] = (byte)tmpQosLevels[i];
+            }
+
+            return msg;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // topics list empty
+            if ((this.topics == null) || (this.topics.Length == 0))
+                throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
+
+            // qos levels list empty
+            if ((this.qosLevels == null) || (this.qosLevels.Length == 0))
+                throw new MqttClientException(MqttClientErrorCode.QosLevelsEmpty);
+
+            // topics and qos levels lists length don't match
+            if (this.topics.Length != this.qosLevels.Length)
+                throw new MqttClientException(MqttClientErrorCode.TopicsQosLevelsNotMatch);
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            int topicIdx = 0;
+            byte[][] topicsUtf8 = new byte[this.topics.Length][];
+
+            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
+            {
+                // check topic length
+                if ((this.topics[topicIdx].Length < MIN_TOPIC_LENGTH) || (this.topics[topicIdx].Length > MAX_TOPIC_LENGTH))
+                    throw new MqttClientException(MqttClientErrorCode.TopicLength);
+
+                topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.topics[topicIdx]);
+                payloadSize += 2; // topic size (MSB, LSB)
+                payloadSize += topicsUtf8[topicIdx].Length;
+                payloadSize++; // byte for QoS
+            }
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)((MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) |
+                                   (this.qosLevel << QOS_LEVEL_OFFSET));
+            buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
+            index++;
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // check message identifier assigned (SUBSCRIBE uses QoS Level 1, so message id is mandatory)
+            if (this.messageId == 0)
+                throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
+            buffer[index++] = (byte)((messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(messageId & 0x00FF); // LSB 
+
+            topicIdx = 0;
+            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
+            {
+                // topic name
+                buffer[index++] = (byte)((topicsUtf8[topicIdx].Length >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(topicsUtf8[topicIdx].Length & 0x00FF); // LSB
+                Array.Copy(topicsUtf8[topicIdx], 0, buffer, index, topicsUtf8[topicIdx].Length);
+                index += topicsUtf8[topicIdx].Length;
+
+                // requested QoS
+                buffer[index++] = this.qosLevels[topicIdx];
+            }
+            
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgSubscribeEventArgs.cs

@@ -0,0 +1,83 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for subscribe request on topics
+    /// </summary>
+    public class MqttMsgSubscribeEventArgs : EventArgs
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            internal set { this.messageId = value; }
+        }
+
+        /// <summary>
+        /// Topics requested to subscribe
+        /// </summary>
+        public string[] Topics
+        {
+            get { return this.topics; }
+            internal set { this.topics = value; }
+        }
+
+        /// <summary>
+        /// List of QOS Levels requested
+        /// </summary>
+        public byte[] QoSLevels
+        {
+            get { return this.qosLevels; }
+            internal set { this.qosLevels = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        ushort messageId;
+        // topics requested to subscribe
+        string[] topics;
+        // QoS levels requested
+        byte[] qosLevels;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="messageId">Message identifier for subscribe topics request</param>
+        /// <param name="topics">Topics requested to subscribe</param>
+        /// <param name="qosLevels">List of QOS Levels requested</param>
+        public MqttMsgSubscribeEventArgs(ushort messageId, string[] topics, byte[] qosLevels)
+        {
+            this.messageId = messageId;
+            this.topics = topics;
+            this.qosLevels = qosLevels;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgSubscribedEventArgs.cs

@@ -0,0 +1,70 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for subscribed topics
+    /// </summary>
+    public class MqttMsgSubscribedEventArgs : EventArgs
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            internal set { this.messageId = value; }
+        }
+
+        /// <summary>
+        /// List of granted QOS Levels
+        /// </summary>
+        public byte[] GrantedQoSLevels
+        {
+            get { return this.grantedQosLevels; }
+            internal set { this.grantedQosLevels = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        ushort messageId;
+        // granted QOS levels
+        byte[] grantedQosLevels;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="messageId">Message identifier for subscribed topics</param>
+        /// <param name="grantedQosLevels">List of granted QOS Levels</param>
+        public MqttMsgSubscribedEventArgs(ushort messageId, byte[] grantedQosLevels)
+        {
+            this.messageId = messageId;
+            this.grantedQosLevels = grantedQosLevels;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgUnsuback.cs

@@ -0,0 +1,122 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for UNSUBACK message from broker to client
+    /// </summary>
+    public class MqttMsgUnsuback : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier for the unsubscribe message
+        /// that is acknowledged
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        private ushort messageId;
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgUnsuback()
+        {
+            this.type = MQTT_MSG_UNSUBACK_TYPE;
+        }
+
+        /// <summary>
+        /// Parse bytes for a UNSUBACK message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>UNSUBACK message instance</returns>
+        public static MqttMsgUnsuback Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            MqttMsgUnsuback msg = new MqttMsgUnsuback();
+
+            // 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 override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)(MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET);
+            index++;
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // message id
+            buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB
+
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgUnsubscribe.cs

@@ -0,0 +1,222 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+using System;
+// if NOT .Net Micro Framework
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System.Collections.Generic;
+#endif
+using System.Collections;
+using System.Text;
+using uPLibrary.Networking.M2Mqtt.Exceptions;
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Class for UNSUBSCRIBE message from client to broker
+    /// </summary>
+    public class MqttMsgUnsubscribe : MqttMsgBase
+    {
+        #region Properties...
+
+        /// <summary>
+        /// List of topics to unsubscribe
+        /// </summary>
+        public string[] Topics
+        {
+            get { return this.topics; }
+            set { this.topics = value; }
+        }
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // topics to unsubscribe
+        string[] topics;
+        // message identifier
+        ushort messageId;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public MqttMsgUnsubscribe()
+        {
+            this.type = MQTT_MSG_UNSUBSCRIBE_TYPE;
+        }
+        
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="topics">List of topics to unsubscribe</param>
+        public MqttMsgUnsubscribe(string[] topics)
+        {
+            this.type = MQTT_MSG_UNSUBSCRIBE_TYPE;
+
+            this.topics = topics;
+
+            // UNSUBSCRIBE message uses QoS Level 1
+            this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
+        }
+
+        /// <summary>
+        /// Parse bytes for a UNSUBSCRIBE message
+        /// </summary>
+        /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
+        /// <param name="channel">Channel connected to the broker</param>
+        /// <returns>UNSUBSCRIBE message instance</returns>
+        public static MqttMsgUnsubscribe Parse(byte fixedHeaderFirstByte, IMqttNetworkChannel channel)
+        {
+            byte[] buffer;
+            int index = 0;
+            byte[] topicUtf8;
+            int topicUtf8Length;
+            MqttMsgUnsubscribe msg = new MqttMsgUnsubscribe();
+
+            // get remaining length and allocate buffer
+            int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
+            buffer = new byte[remainingLength];
+
+            // read bytes from socket...
+            int received = channel.Receive(buffer);
+
+            // read QoS level from fixed header
+            msg.qosLevel = (byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
+            // read DUP flag from fixed header
+            msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
+            // retain flag not used
+            msg.retain = false;
+
+            // message id
+            msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
+            msg.messageId |= (buffer[index++]);
+
+            // payload contains topics
+            // NOTE : before, I don't know how many topics will be in the payload (so use List)
+
+// if .Net Micro Framework
+#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
+            IList tmpTopics = new ArrayList();
+// else other frameworks (.Net, .Net Compact, Mono, Windows Phone) 
+#else
+            IList<String> tmpTopics = new List<String>();
+#endif
+            do
+            {
+                // topic name
+                topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
+                topicUtf8Length |= buffer[index++];
+                topicUtf8 = new byte[topicUtf8Length];
+                Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
+                index += topicUtf8Length;
+                tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
+            } while (index < remainingLength);
+
+            // copy from list to array
+            msg.topics = new string[tmpTopics.Count];
+            for (int i = 0; i < tmpTopics.Count; i++)
+            {
+                msg.topics[i] = (string)tmpTopics[i];
+            }
+
+            return msg;
+        }
+
+        public override byte[] GetBytes()
+        {
+            int fixedHeaderSize = 0;
+            int varHeaderSize = 0;
+            int payloadSize = 0;
+            int remainingLength = 0;
+            byte[] buffer;
+            int index = 0;
+
+            // topics list empty
+            if ((this.topics == null) || (this.topics.Length == 0))
+                throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
+
+            // message identifier
+            varHeaderSize += MESSAGE_ID_SIZE;
+
+            int topicIdx = 0;
+            byte[][] topicsUtf8 = new byte[this.topics.Length][];
+
+            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
+            {
+                // check topic length
+                if ((this.topics[topicIdx].Length < MIN_TOPIC_LENGTH) || (this.topics[topicIdx].Length > MAX_TOPIC_LENGTH))
+                    throw new MqttClientException(MqttClientErrorCode.TopicLength);
+
+                topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.topics[topicIdx]);
+                payloadSize += 2; // topic size (MSB, LSB)
+                payloadSize += topicsUtf8[topicIdx].Length;
+            }
+
+            remainingLength += (varHeaderSize + payloadSize);
+
+            // first byte of fixed header
+            fixedHeaderSize = 1;
+
+            int temp = remainingLength;
+            // increase fixed header size based on remaining length
+            // (each remaining length byte can encode until 128)
+            do
+            {
+                fixedHeaderSize++;
+                temp = temp / 128;
+            } while (temp > 0);
+
+            // allocate buffer for message
+            buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
+
+            // first fixed header byte
+            buffer[index] = (byte)((MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) |
+                                   (this.qosLevel << QOS_LEVEL_OFFSET));
+            buffer[index] |= this.dupFlag ? (byte)(1 << DUP_FLAG_OFFSET) : (byte)0x00;
+            index++;
+
+            // encode remaining length
+            index = this.encodeRemainingLength(remainingLength, buffer, index);
+
+            // check message identifier assigned
+            if (this.messageId == 0)
+                throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
+            buffer[index++] = (byte)((messageId >> 8) & 0x00FF); // MSB
+            buffer[index++] = (byte)(messageId & 0x00FF); // LSB 
+
+            topicIdx = 0;
+            for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
+            {
+                // topic name
+                buffer[index++] = (byte)((topicsUtf8[topicIdx].Length >> 8) & 0x00FF); // MSB
+                buffer[index++] = (byte)(topicsUtf8[topicIdx].Length & 0x00FF); // LSB
+                Array.Copy(topicsUtf8[topicIdx], 0, buffer, index, topicsUtf8[topicIdx].Length);
+                index += topicsUtf8[topicIdx].Length;
+            }
+            
+            return buffer;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgUnsubscribeEventArgs.cs

@@ -0,0 +1,70 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for unsubscribe request on topics
+    /// </summary>
+    public class MqttMsgUnsubscribeEventArgs : EventArgs
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            internal set { this.messageId = value; }
+        }
+
+        /// <summary>
+        /// Topics requested to subscribe
+        /// </summary>
+        public string[] Topics
+        {
+            get { return this.topics; }
+            internal set { this.topics = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        ushort messageId;
+        // topics requested to unsubscribe
+        string[] topics;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="messageId">Message identifier for subscribed topics</param>
+        /// <param name="topics">Topics requested to subscribe</param>
+        public MqttMsgUnsubscribeEventArgs(ushort messageId, string[] topics)
+        {
+            this.messageId = messageId;
+            this.topics = topics;
+        }
+    }
+}

M2Mqtt/Messages/MqttMsgUnsubscribedEventArgs.cs

@@ -0,0 +1,57 @@
+/*
+M2Mqtt - MQTT Client Library for .Net
+Copyright (c) 2014, Paolo Patierno, All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 3.0 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library.
+*/
+
+#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
+using System;
+#else
+using Microsoft.SPOT;
+#endif
+
+namespace uPLibrary.Networking.M2Mqtt.Messages
+{
+    /// <summary>
+    /// Event Args class for unsubscribed topic
+    /// </summary>
+    public class MqttMsgUnsubscribedEventArgs : EventArgs
+    {
+        #region Properties...
+
+        /// <summary>
+        /// Message identifier
+        /// </summary>
+        public ushort MessageId
+        {
+            get { return this.messageId; }
+            internal set { this.messageId = value; }
+        }
+
+        #endregion
+
+        // message identifier
+        ushort messageId;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="messageId">Message identifier for unsubscribed topic</param>
+        public MqttMsgUnsubscribedEventArgs(ushort messageId)
+        {
+            this.messageId = messageId;
+        }
+    }
+}