vs_librarys/mqtt
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Compare commits

base: vs_librarys:master
Branches Tags
vs_librarys:master
vs_librarys:v4.3.0.0
..
compare: vs_librarys:v4.3.0.0
Branches Tags
vs_librarys:master
vs_librarys:v4.3.0.0

No commits in common. "master" and "v4.3.0.0" have entirely different histories.
master ... v4.3.0.0

49 changed files with 5463 additions and 5001 deletions
Show Stats Expand all files Collapse all files

203
LICENSE
View File

@ -1,203 +0,0 @@
Eclipse Public License - v 1.0
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial code and documentation
distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program originate from and are
distributed by that particular Contributor. A Contribution 'originates'
from a Contributor if it was added to the Program by such Contributor
itself or anyone acting on such Contributor's behalf. Contributions do not
include additions to the Program which: (i) are separate modules of
software distributed in conjunction with the Program under their own
license agreement, and (ii) are not derivative works of the Program.
"Contributor" means any person or entity that distributes the Program.
"Licensed Patents" mean patent claims licensable by a Contributor which are
necessarily infringed by the use or sale of its Contribution alone or when
combined with the Program.
"Program" means the Contributions distributed in accordance with this
Agreement.
"Recipient" means anyone who receives the Program under this Agreement,
including all Contributors.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free copyright license to
reproduce, prepare derivative works of, publicly display, publicly
perform, distribute and sublicense the Contribution of such Contributor,
if any, and such derivative works, in source code and object code form.
b) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free patent license under
Licensed Patents to make, use, sell, offer to sell, import and otherwise
transfer the Contribution of such Contributor, if any, in source code and
object code form. This patent license shall apply to the combination of
the Contribution and the Program if, at the time the Contribution is
added by the Contributor, such addition of the Contribution causes such
combination to be covered by the Licensed Patents. The patent license
shall not apply to any other combinations which include the Contribution.
No hardware per se is licensed hereunder.
c) Recipient understands that although each Contributor grants the licenses
to its Contributions set forth herein, no assurances are provided by any
Contributor that the Program does not infringe the patent or other
intellectual property rights of any other entity. Each Contributor
disclaims any liability to Recipient for claims brought by any other
entity based on infringement of intellectual property rights or
otherwise. As a condition to exercising the rights and licenses granted
hereunder, each Recipient hereby assumes sole responsibility to secure
any other intellectual property rights needed, if any. For example, if a
third party patent license is required to allow Recipient to distribute
the Program, it is Recipient's responsibility to acquire that license
before distributing the Program.
d) Each Contributor represents that to its knowledge it has sufficient
copyright rights in its Contribution, if any, to grant the copyright
license set forth in this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the Program in object code form under
its own license agreement, provided that:
a) it complies with the terms and conditions of this Agreement; and
b) its license agreement:
i) effectively disclaims on behalf of all Contributors all warranties
and conditions, express and implied, including warranties or
conditions of title and non-infringement, and implied warranties or
conditions of merchantability and fitness for a particular purpose;
ii) effectively excludes on behalf of all Contributors all liability for
damages, including direct, indirect, special, incidental and
consequential damages, such as lost profits;
iii) states that any provisions which differ from this Agreement are
offered by that Contributor alone and not by any other party; and
iv) states that source code for the Program is available from such
Contributor, and informs licensees how to obtain it in a reasonable
manner on or through a medium customarily used for software exchange.
When the Program is made available in source code form:
a) it must be made available under this Agreement; and
b) a copy of this Agreement must be included with each copy of the Program.
Contributors may not remove or alter any copyright notices contained
within the Program.
Each Contributor must identify itself as the originator of its Contribution,
if
any, in a manner that reasonably allows subsequent Recipients to identify the
originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain responsibilities with
respect to end users, business partners and the like. While this license is
intended to facilitate the commercial use of the Program, the Contributor who
includes the Program in a commercial product offering should do so in a manner
which does not create potential liability for other Contributors. Therefore,
if a Contributor includes the Program in a commercial product offering, such
Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
every other Contributor ("Indemnified Contributor") against any losses,
damages and costs (collectively "Losses") arising from claims, lawsuits and
other legal actions brought by a third party against the Indemnified
Contributor to the extent caused by the acts or omissions of such Commercial
Contributor in connection with its distribution of the Program in a commercial
product offering. The obligations in this section do not apply to any claims
or Losses relating to any actual or alleged intellectual property
infringement. In order to qualify, an Indemnified Contributor must:
a) promptly notify the Commercial Contributor in writing of such claim, and
b) allow the Commercial Contributor to control, and cooperate with the
Commercial Contributor in, the defense and any related settlement
negotiations. The Indemnified Contributor may participate in any such claim at
its own expense.
For example, a Contributor might include the Program in a commercial product
offering, Product X. That Contributor is then a Commercial Contributor. If
that Commercial Contributor then makes performance claims, or offers
warranties related to Product X, those performance claims and warranties are
such Commercial Contributor's responsibility alone. Under this section, the
Commercial Contributor would have to defend claims against the other
Contributors related to those performance claims and warranties, and if a
court requires any other Contributor to pay any damages as a result, the
Commercial Contributor must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
Recipient is solely responsible for determining the appropriateness of using
and distributing the Program and assumes all risks associated with its
exercise of rights under this Agreement , including but not limited to the
risks and costs of program errors, compliance with applicable laws, damage to
or loss of data, programs or equipment, and unavailability or interruption of
operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under
applicable law, it shall not affect the validity or enforceability of the
remainder of the terms of this Agreement, and without further action by the
parties hereto, such provision shall be reformed to the minimum extent
necessary to make such provision valid and enforceable.
If Recipient institutes patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Program itself
(excluding combinations of the Program with other software or hardware)
infringes such Recipient's patent(s), then such Recipient's rights granted
under Section 2(b) shall terminate as of the date such litigation is filed.
All Recipient's rights under this Agreement shall terminate if it fails to
comply with any of the material terms or conditions of this Agreement and does
not cure such failure in a reasonable period of time after becoming aware of
such noncompliance. If all Recipient's rights under this Agreement terminate,
Recipient agrees to cease use and distribution of the Program as soon as
reasonably practicable. However, Recipient's obligations under this Agreement
and any licenses granted by Recipient relating to the Program shall continue
and survive.
Everyone is permitted to copy and distribute copies of this Agreement, but in
order to avoid inconsistency the Agreement is copyrighted and may only be
modified in the following manner. The Agreement Steward reserves the right to
publish new versions (including revisions) of this Agreement from time to
time. No one other than the Agreement Steward has the right to modify this
Agreement. The Eclipse Foundation is the initial Agreement Steward. The
Eclipse Foundation may assign the responsibility to serve as the Agreement
Steward to a suitable separate entity. Each new version of the Agreement will
be given a distinguishing version number. The Program (including
Contributions) may always be distributed subject to the version of the
Agreement under which it was received. In addition, after a new version of the
Agreement is published, Contributor may elect to distribute the Program
(including its Contributions) under the new version. Except as expressly
stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
licenses to the intellectual property of any Contributor under this Agreement,
whether expressly, by implication, estoppel or otherwise. All rights in the
Program not expressly granted under this Agreement are reserved.
This Agreement is governed by the laws of the State of New York and the
intellectual property laws of the United States of America. No party to this
Agreement will bring a legal action under this Agreement more than one year
after the cause of action arose. Each party waives its rights to a jury trial in
any resulting litigation.

25
M2Mqtt.sln
View File

@ -1,25 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29519.87
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "M2Mqtt", "M2Mqtt\M2Mqtt.csproj", "{18F706D2-7610-428C-8324-8327F9D7BE90}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{18F706D2-7610-428C-8324-8327F9D7BE90}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{18F706D2-7610-428C-8324-8327F9D7BE90}.Debug|Any CPU.Build.0 = Debug|Any CPU
{18F706D2-7610-428C-8324-8327F9D7BE90}.Release|Any CPU.ActiveCfg = Release|Any CPU
{18F706D2-7610-428C-8324-8327F9D7BE90}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {EBFDF320-2C59-4F89-8211-5B6EF9C310ED}
EndGlobalSection
EndGlobal

175
M2Mqtt/Exceptions/MqttClientException.cs
View File

@ -16,104 +16,117 @@ Contributors:
using System; using System;
namespace uPLibrary.Networking.M2Mqtt.Exceptions { namespace uPLibrary.Networking.M2Mqtt.Exceptions
/// <summary> {
/// MQTT client exception
/// </summary>
public class MqttClientException : Exception {
/// <summary> /// <summary>
/// Constructor /// MQTT client exception
/// </summary> /// </summary>
/// <param name="code">Error code</param> public class MqttClientException : Exception
public MqttClientException(MqttClientErrorCode errorCode) => this.ErrorCode = errorCode; {
/// <summary>
/// Constructor
/// </summary>
/// <param name="code">Error code</param>
public MqttClientException(MqttClientErrorCode errorCode)
{
this.errorCode = errorCode;
}
// error code
private MqttClientErrorCode errorCode;
/// <summary>
/// Error code
/// </summary>
public MqttClientErrorCode ErrorCode
{
get { return this.errorCode; }
set { this.errorCode = value; }
}
}
/// <summary> /// <summary>
/// Error code /// MQTT client erroro code
/// </summary> /// </summary>
public MqttClientErrorCode ErrorCode { get; set; } public enum MqttClientErrorCode
} {
/// <summary>
/// Will error (topic, message or QoS level)
/// </summary>
WillWrong = 1,
/// <summary> /// <summary>
/// MQTT client erroro code /// Keep alive period too large
/// </summary> /// </summary>
public enum MqttClientErrorCode { KeepAliveWrong,
/// <summary>
/// Will error (topic, message or QoS level)
/// </summary>
WillWrong = 1,
/// <summary> /// <summary>
/// Keep alive period too large /// Topic contains wildcards
/// </summary> /// </summary>
KeepAliveWrong, TopicWildcard,
/// <summary> /// <summary>
/// Topic contains wildcards /// Topic length wrong
/// </summary> /// </summary>
TopicWildcard, TopicLength,
/// <summary> /// <summary>
/// Topic length wrong /// QoS level not allowed
/// </summary> /// </summary>
TopicLength, QosNotAllowed,
/// <summary> /// <summary>
/// QoS level not allowed /// Topics list empty for subscribe
/// </summary> /// </summary>
QosNotAllowed, TopicsEmpty,
/// <summary> /// <summary>
/// Topics list empty for subscribe /// Qos levels list empty for subscribe
/// </summary> /// </summary>
TopicsEmpty, QosLevelsEmpty,
/// <summary> /// <summary>
/// Qos levels list empty for subscribe /// Topics / Qos Levels not match in subscribe
/// </summary> /// </summary>
QosLevelsEmpty, TopicsQosLevelsNotMatch,
/// <summary> /// <summary>
/// Topics / Qos Levels not match in subscribe /// Wrong message from broker
/// </summary> /// </summary>
TopicsQosLevelsNotMatch, WrongBrokerMessage,
/// <summary> /// <summary>
/// Wrong message from broker /// Wrong Message Id
/// </summary> /// </summary>
WrongBrokerMessage, WrongMessageId,
/// <summary> /// <summary>
/// Wrong Message Id /// Inflight queue is full
/// </summary> /// </summary>
WrongMessageId, InflightQueueFull,
/// <summary> // [v3.1.1]
/// Inflight queue is full /// <summary>
/// </summary> /// Invalid flag bits received
InflightQueueFull, /// </summary>
InvalidFlagBits,
// [v3.1.1] // [v3.1.1]
/// <summary> /// <summary>
/// Invalid flag bits received /// Invalid connect flags received
/// </summary> /// </summary>
InvalidFlagBits, InvalidConnectFlags,
// [v3.1.1] // [v3.1.1]
/// <summary> /// <summary>
/// Invalid connect flags received /// Invalid client id
/// </summary> /// </summary>
InvalidConnectFlags, InvalidClientId,
// [v3.1.1] // [v3.1.1]
/// <summary> /// <summary>
/// Invalid client id /// Invalid protocol name
/// </summary> /// </summary>
InvalidClientId, InvalidProtocolName
}
// [v3.1.1]
/// <summary>
/// Invalid protocol name
/// </summary>
InvalidProtocolName
}
} }

34
M2Mqtt/Exceptions/MqttCommunicationException.cs
View File

@ -16,23 +16,27 @@ Contributors:
using System; using System;
namespace uPLibrary.Networking.M2Mqtt.Exceptions { namespace uPLibrary.Networking.M2Mqtt.Exceptions
/// <summary> {
/// Exception due to error communication with broker on socket
/// </summary>
public class MqttCommunicationException : Exception {
/// <summary> /// <summary>
/// Default constructor /// Exception due to error communication with broker on socket
/// </summary> /// </summary>
public MqttCommunicationException() { public class MqttCommunicationException : Exception
} {
/// <summary>
/// Default constructor
/// </summary>
public MqttCommunicationException()
{
}
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
/// <param name="e">Inner Exception</param> /// <param name="e">Inner Exception</param>
public MqttCommunicationException(Exception e) public MqttCommunicationException(Exception e)
: base(String.Empty, e) { : base(String.Empty, e)
{
}
} }
}
} }

19
M2Mqtt/Exceptions/MqttConnectionException.cs
View File

@ -16,13 +16,16 @@ Contributors:
using System; using System;
namespace uPLibrary.Networking.M2Mqtt.Exceptions { namespace uPLibrary.Networking.M2Mqtt.Exceptions
/// <summary> {
/// Connection to the broker exception /// <summary>
/// </summary> /// Connection to the broker exception
public class MqttConnectionException : Exception { /// </summary>
public MqttConnectionException(String message, Exception innerException) public class MqttConnectionException : Exception
: base(message, innerException) { {
public MqttConnectionException(string message, Exception innerException)
: base(message, innerException)
{
}
} }
}
} }

14
M2Mqtt/Exceptions/MqttTimeoutException.cs
View File

@ -16,10 +16,12 @@ Contributors:
using System; using System;
namespace uPLibrary.Networking.M2Mqtt.Exceptions { namespace uPLibrary.Networking.M2Mqtt.Exceptions
/// <summary> {
/// Timeout on receiving from broker exception /// <summary>
/// </summary> /// Timeout on receiving from broker exception
public class MqttTimeoutException : Exception { /// </summary>
} public class MqttTimeoutException : Exception
{
}
} }

81
M2Mqtt/IMqttNetworkChannel.cs
View File

@ -15,52 +15,55 @@ Contributors:
*/ */
using System; using System;
using System.Text;
namespace uPLibrary.Networking.M2Mqtt { namespace uPLibrary.Networking.M2Mqtt
/// <summary> {
/// Interface for channel under MQTT library
/// </summary>
public interface IMqttNetworkChannel {
/// <summary> /// <summary>
/// Data available on channel /// Interface for channel under MQTT library
/// </summary> /// </summary>
Boolean DataAvailable { get; } public interface IMqttNetworkChannel
{
/// <summary>
/// Data available on channel
/// </summary>
bool DataAvailable { get; }
/// <summary> /// <summary>
/// Receive data from the network channel /// Receive data from the network channel
/// </summary> /// </summary>
/// <param name="buffer">Data buffer for receiving data</param> /// <param name="buffer">Data buffer for receiving data</param>
/// <returns>Number of bytes received</returns> /// <returns>Number of bytes received</returns>
Int32 Receive(Byte[] buffer); int Receive(byte[] buffer);
/// <summary> /// <summary>
/// Receive data from the network channel with a specified timeout /// Receive data from the network channel with a specified timeout
/// </summary> /// </summary>
/// <param name="buffer">Data buffer for receiving data</param> /// <param name="buffer">Data buffer for receiving data</param>
/// <param name="timeout">Timeout on receiving (in milliseconds)</param> /// <param name="timeout">Timeout on receiving (in milliseconds)</param>
/// <returns>Number of bytes received</returns> /// <returns>Number of bytes received</returns>
Int32 Receive(Byte[] buffer, Int32 timeout); int Receive(byte[] buffer, int timeout);
/// <summary> /// <summary>
/// Send data on the network channel to the broker /// Send data on the network channel to the broker
/// </summary> /// </summary>
/// <param name="buffer">Data buffer to send</param> /// <param name="buffer">Data buffer to send</param>
/// <returns>Number of byte sent</returns> /// <returns>Number of byte sent</returns>
Int32 Send(Byte[] buffer); int Send(byte[] buffer);
/// <summary> /// <summary>
/// Close the network channel /// Close the network channel
/// </summary> /// </summary>
void Close(); void Close();
/// <summary> /// <summary>
/// Connect to remote server /// Connect to remote server
/// </summary> /// </summary>
void Connect(); void Connect();
/// <summary> /// <summary>
/// Accept client connection /// Accept client connection
/// </summary> /// </summary>
void Accept(); void Accept();
} }
} }

14
M2Mqtt/Internal/InternalEvent.cs
View File

@ -14,10 +14,12 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
namespace uPLibrary.Networking.M2Mqtt.Internal { namespace uPLibrary.Networking.M2Mqtt.Internal
/// <summary> {
/// Generic internal event for dispatching /// <summary>
/// </summary> /// Generic internal event for dispatching
public abstract class InternalEvent { /// </summary>
} public abstract class InternalEvent
{
}
} }

44
M2Mqtt/Internal/MsgInternalEvent.cs
View File

@ -16,26 +16,36 @@ Contributors:
using uPLibrary.Networking.M2Mqtt.Messages; using uPLibrary.Networking.M2Mqtt.Messages;
namespace uPLibrary.Networking.M2Mqtt.Internal { namespace uPLibrary.Networking.M2Mqtt.Internal
/// <summary> {
/// Internal event with a message
/// </summary>
public class MsgInternalEvent : InternalEvent {
#region Properties ...
/// <summary> /// <summary>
/// Related message /// Internal event with a message
/// </summary> /// </summary>
public MqttMsgBase Message { get; set; } public class MsgInternalEvent : InternalEvent
{
#region Properties ...
#endregion /// <summary>
/// Related message
/// </summary>
public MqttMsgBase Message
{
get { return this.msg; }
set { this.msg = value; }
}
// related message #endregion
/// <summary> // related message
/// Constructor protected MqttMsgBase msg;
/// </summary>
/// <param name="msg">Related message</param> /// <summary>
public MsgInternalEvent(MqttMsgBase msg) => this.Message = msg; /// Constructor
} /// </summary>
/// <param name="msg">Related message</param>
public MsgInternalEvent(MqttMsgBase msg)
{
this.msg = msg;
}
}
} }

49
M2Mqtt/Internal/MsgPublishedInternalEvent.cs
View File

@ -14,31 +14,40 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using uPLibrary.Networking.M2Mqtt.Messages; using uPLibrary.Networking.M2Mqtt.Messages;
namespace uPLibrary.Networking.M2Mqtt.Internal { namespace uPLibrary.Networking.M2Mqtt.Internal
/// <summary> {
/// Internal event for a published message
/// </summary>
public class MsgPublishedInternalEvent : MsgInternalEvent {
#region Properties...
/// <summary> /// <summary>
/// Message published (or failed due to retries) /// Internal event for a published message
/// </summary> /// </summary>
public Boolean IsPublished { get; internal set; } public class MsgPublishedInternalEvent : MsgInternalEvent
{
#region Properties...
#endregion /// <summary>
/// Message published (or failed due to retries)
/// </summary>
public bool IsPublished
{
get { return this.isPublished; }
internal set { this.isPublished = value; }
}
// published flag #endregion
/// <summary> // published flag
/// Constructor bool isPublished;
/// </summary>
/// <param name="msg">Message published</param> /// <summary>
/// <param name="isPublished">Publish flag</param> /// Constructor
public MsgPublishedInternalEvent(MqttMsgBase msg, Boolean isPublished) /// </summary>
: base(msg) => this.IsPublished = isPublished; /// <param name="msg">Message published</param>
} /// <param name="isPublished">Publish flag</param>
public MsgPublishedInternalEvent(MqttMsgBase msg, bool isPublished)
: base(msg)
{
this.isPublished = isPublished;
}
}
} }

24
M2Mqtt/M2Mqtt.csproj
View File

@ -1,24 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp3.1</TargetFramework>
<AssemblyName>M2Mqtt</AssemblyName>
<RootNamespace>uPLibrary.Networking.M2Mqtt</RootNamespace>
<Description>MQTT Client Library for M2M communication</Description>
<Authors>Paolo Patierno</Authors>
<Company>Paolo Patierno</Company>
<Copyright>Copyright © Paolo Patierno 2014</Copyright>
<Version>4.3.0</Version>
<AssemblyVersion>4.3.0</AssemblyVersion>
<FileVersion>4.3.0</FileVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DefineConstants>TRACE;SSL</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DefineConstants>TRACE;SSL</DefineConstants>
</PropertyGroup>
</Project>

423
M2Mqtt/Messages/MqttMsgBase.cs
View File

@ -17,220 +17,259 @@ Contributors:
using System; using System;
using System.Text; using System.Text;
namespace uPLibrary.Networking.M2Mqtt.Messages { 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 MSG_FLAG_BITS_MASK = 0x0F; // [v3.1.1]
internal const Byte MSG_FLAG_BITS_OFFSET = 0x00; // [v3.1.1]
internal const Byte MSG_FLAG_BITS_SIZE = 0x04; // [v3.1.1]
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;
// [v3.1.1] MQTT flag bits
internal const Byte MQTT_MSG_CONNECT_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_CONNACK_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_PUBLISH_FLAG_BITS = 0x00; // just defined as 0x00 but depends on publish props (dup, qos, retain)
internal const Byte MQTT_MSG_PUBACK_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_PUBREC_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_PUBREL_FLAG_BITS = 0x02;
internal const Byte MQTT_MSG_PUBCOMP_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_SUBSCRIBE_FLAG_BITS = 0x02;
internal const Byte MQTT_MSG_SUBACK_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_UNSUBSCRIBE_FLAG_BITS = 0x02;
internal const Byte MQTT_MSG_UNSUBACK_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_PINGREQ_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_PINGRESP_FLAG_BITS = 0x00;
internal const Byte MQTT_MSG_DISCONNECT_FLAG_BITS = 0x00;
// 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;
// SUBSCRIBE QoS level granted failure [v3.1.1]
public const Byte QOS_LEVEL_GRANTED_FAILURE = 0x80;
internal const UInt16 MAX_TOPIC_LENGTH = 65535;
internal const UInt16 MIN_TOPIC_LENGTH = 1;
internal const Byte MESSAGE_ID_SIZE = 2;
#endregion
#region Properties...
/// <summary> /// <summary>
/// Message type /// Base class for all MQTT messages
/// </summary> /// </summary>
public Byte Type { get; set; } public abstract class MqttMsgBase
{
#region Constants...
/// <summary> // mask, offset and size for fixed header fields
/// Duplicate message flag internal const byte MSG_TYPE_MASK = 0xF0;
/// </summary> internal const byte MSG_TYPE_OFFSET = 0x04;
public Boolean DupFlag { get; set; } internal const byte MSG_TYPE_SIZE = 0x04;
internal const byte MSG_FLAG_BITS_MASK = 0x0F; // [v3.1.1]
internal const byte MSG_FLAG_BITS_OFFSET = 0x00; // [v3.1.1]
internal const byte MSG_FLAG_BITS_SIZE = 0x04; // [v3.1.1]
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;
/// <summary> // MQTT message types
/// Quality of Service level internal const byte MQTT_MSG_CONNECT_TYPE = 0x01;
/// </summary> internal const byte MQTT_MSG_CONNACK_TYPE = 0x02;
public Byte QosLevel { get; set; } 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;
/// <summary> // [v3.1.1] MQTT flag bits
/// Retain message flag internal const byte MQTT_MSG_CONNECT_FLAG_BITS = 0x00;
/// </summary> internal const byte MQTT_MSG_CONNACK_FLAG_BITS = 0x00;
public Boolean Retain { get; set; } internal const byte MQTT_MSG_PUBLISH_FLAG_BITS = 0x00; // just defined as 0x00 but depends on publish props (dup, qos, retain)
internal const byte MQTT_MSG_PUBACK_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_PUBREC_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_PUBREL_FLAG_BITS = 0x02;
internal const byte MQTT_MSG_PUBCOMP_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_SUBSCRIBE_FLAG_BITS = 0x02;
internal const byte MQTT_MSG_SUBACK_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_UNSUBSCRIBE_FLAG_BITS = 0x02;
internal const byte MQTT_MSG_UNSUBACK_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_PINGREQ_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_PINGRESP_FLAG_BITS = 0x00;
internal const byte MQTT_MSG_DISCONNECT_FLAG_BITS = 0x00;
/// <summary> // QOS levels
/// Message identifier for the message public const byte QOS_LEVEL_AT_MOST_ONCE = 0x00;
/// </summary> public const byte QOS_LEVEL_AT_LEAST_ONCE = 0x01;
public UInt16 MessageId { get; set; } public const byte QOS_LEVEL_EXACTLY_ONCE = 0x02;
#endregion // SUBSCRIBE QoS level granted failure [v3.1.1]
public const byte QOS_LEVEL_GRANTED_FAILURE = 0x80;
// message type internal const ushort MAX_TOPIC_LENGTH = 65535;
// duplicate delivery internal const ushort MIN_TOPIC_LENGTH = 1;
// quality of service level internal const byte MESSAGE_ID_SIZE = 2;
// retain flag
// message identifier
/// <summary> #endregion
/// Returns message bytes rapresentation
/// </summary>
/// <param name="protocolVersion">Protocol version</param>
/// <returns>Bytes rapresentation</returns>
public abstract Byte[] GetBytes(Byte protocolVersion);
/// <summary> #region Properties...
/// Encode remaining length and insert it into message buffer
/// </summary> /// <summary>
/// <param name="remainingLength">Remaining length value to encode</param> /// Message type
/// <param name="buffer">Message buffer for inserting encoded value</param> /// </summary>
/// <param name="index">Index from which insert encoded value into buffer</param> public byte Type
/// <returns>Index updated</returns> {
protected Int32 EncodeRemainingLength(Int32 remainingLength, Byte[] buffer, Int32 index) { get { return this.type; }
do { set { this.type = value; }
Int32 digit = remainingLength % 128;
remainingLength /= 128;
if (remainingLength > 0) {
digit |= 0x80;
} }
buffer[index++] = (Byte)digit; /// <summary>
} while (remainingLength > 0); /// Duplicate message flag
return index; /// </summary>
} public bool DupFlag
{
get { return this.dupFlag; }
set { this.dupFlag = value; }
}
/// <summary> /// <summary>
/// Decode remaining length reading bytes from socket /// Quality of Service level
/// </summary> /// </summary>
/// <param name="channel">Channel from reading bytes</param> public byte QosLevel
/// <returns>Decoded remaining length</returns> {
protected static Int32 DecodeRemainingLength(IMqttNetworkChannel channel) { get { return this.qosLevel; }
Int32 multiplier = 1; set { this.qosLevel = value; }
Int32 value = 0; }
Byte[] nextByte = new Byte[1];
Int32 digit; /// <summary>
do { /// Retain message flag
// next digit from stream /// </summary>
_ = channel.Receive(nextByte); public bool Retain
digit = nextByte[0]; {
value += (digit & 127) * multiplier; get { return this.retain; }
multiplier *= 128; set { this.retain = value; }
} while ((digit & 128) != 0); }
return value;
} /// <summary>
/// Message identifier for the message
/// </summary>
public ushort MessageId
{
get { return this.messageId; }
set { this.messageId = value; }
}
#endregion
// message type
protected byte type;
// duplicate delivery
protected bool dupFlag;
// quality of service level
protected byte qosLevel;
// retain flag
protected bool retain;
// message identifier
protected ushort messageId;
/// <summary>
/// Returns message bytes rapresentation
/// </summary>
/// <param name="protocolVersion">Protocol version</param>
/// <returns>Bytes rapresentation</returns>
public abstract byte[] GetBytes(byte protocolVersion);
/// <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;
}
#if TRACE #if TRACE
/// <summary> /// <summary>
/// Returns a string representation of the message for tracing /// Returns a string representation of the message for tracing
/// </summary> /// </summary>
/// <param name="name">Message name</param> /// <param name="name">Message name</param>
/// <param name="fieldNames">Message fields name</param> /// <param name="fieldNames">Message fields name</param>
/// <param name="fieldValues">Message fields value</param> /// <param name="fieldValues">Message fields value</param>
/// <returns>String representation of the message</returns> /// <returns>String representation of the message</returns>
protected String GetTraceString(String name, Object[] fieldNames, Object[] fieldValues) { protected string GetTraceString(string name, object[] fieldNames, object[] fieldValues)
StringBuilder sb = new StringBuilder(); {
_ = sb.Append(name); StringBuilder sb = new StringBuilder();
sb.Append(name);
if (fieldNames != null && fieldValues != null) { if ((fieldNames != null) && (fieldValues != null))
_ = sb.Append("("); {
Boolean addComma = false; sb.Append("(");
for (Int32 i = 0; i < fieldValues.Length; i++) { bool addComma = false;
if (fieldValues[i] != null) { for (int i = 0; i < fieldValues.Length; i++)
if (addComma) { {
_ = sb.Append(","); if (fieldValues[i] != null)
{
if (addComma)
{
sb.Append(",");
}
sb.Append(fieldNames[i]);
sb.Append(":");
sb.Append(GetStringObject(fieldValues[i]));
addComma = true;
}
}
sb.Append(")");
} }
_ = sb.Append(fieldNames[i]); return sb.ToString();
_ = sb.Append(":");
_ = sb.Append(this.GetStringObject(fieldValues[i]));
addComma = true;
}
}
_ = sb.Append(")");
}
return sb.ToString();
}
Object GetStringObject(Object value) {
if (value is Byte[] binary) {
String hexChars = "0123456789ABCDEF";
StringBuilder sb = new StringBuilder(binary.Length * 2);
for (Int32 i = 0; i < binary.Length; ++i) {
_ = sb.Append(hexChars[binary[i] >> 4]);
_ = sb.Append(hexChars[binary[i] & 0x0F]);
} }
return sb.ToString(); object GetStringObject(object value)
} {
byte[] binary = value as byte[];
if (binary != null)
{
string hexChars = "0123456789ABCDEF";
StringBuilder sb = new StringBuilder(binary.Length * 2);
for (int i = 0; i < binary.Length; ++i)
{
sb.Append(hexChars[binary[i] >> 4]);
sb.Append(hexChars[binary[i] & 0x0F]);
}
if (value is Object[] list) { return sb.ToString();
StringBuilder sb = new StringBuilder(); }
_ = sb.Append('[');
for (Int32 i = 0; i < list.Length; ++i) {
if (i > 0) {
_ = sb.Append(',');
}
_ = sb.Append(list[i]); object[] list = value as object[];
if (list != null)
{
StringBuilder sb = new StringBuilder();
sb.Append('[');
for (int i = 0; i < list.Length; ++i)
{
if (i > 0) sb.Append(',');
sb.Append(list[i]);
}
sb.Append(']');
return sb.ToString();
}
return value;
} }
_ = sb.Append(']');
return sb.ToString();
}
return value;
}
#endif #endif
} }
} }

298
M2Mqtt/Messages/MqttMsgConnack.cs
View File

@ -17,153 +17,175 @@ Contributors:
using System; using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { 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;
// [v3.1.1] connect acknowledge flags replace "old" topic name compression respone (not used in 3.1)
private const Byte CONN_ACK_FLAGS_BYTE_OFFSET = 0;
private const Byte CONN_ACK_FLAGS_BYTE_SIZE = 1;
// [v3.1.1] session present flag
private const Byte SESSION_PRESENT_FLAG_MASK = 0x01;
private const Byte SESSION_PRESENT_FLAG_OFFSET = 0x00;
//private const Byte SESSION_PRESENT_FLAG_SIZE = 0x01;
private const Byte CONN_RETURN_CODE_BYTE_OFFSET = 1;
private const Byte CONN_RETURN_CODE_BYTE_SIZE = 1;
#endregion
#region Properties...
// [v3.1.1] session present flag
/// <summary> /// <summary>
/// Session present flag /// Class for CONNACK message from broker to client
/// </summary> /// </summary>
public Boolean SessionPresent { get; set; } public class MqttMsgConnack : MqttMsgBase
{
#region Constants...
/// <summary> // return codes for CONNACK message
/// Return Code public const byte CONN_ACCEPTED = 0x00;
/// </summary> public const byte CONN_REFUSED_PROT_VERS = 0x01;
public Byte ReturnCode { get; set; } 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;
#endregion private const byte TOPIC_NAME_COMP_RESP_BYTE_OFFSET = 0;
private const byte TOPIC_NAME_COMP_RESP_BYTE_SIZE = 1;
// [v3.1.1] session present flag // [v3.1.1] connect acknowledge flags replace "old" topic name compression respone (not used in 3.1)
private const byte CONN_ACK_FLAGS_BYTE_OFFSET = 0;
/// <summary> private const byte CONN_ACK_FLAGS_BYTE_SIZE = 1;
/// 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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>CONNACK message instance</returns>
public static MqttMsgConnack Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
MqttMsgConnack msg = new MqttMsgConnack();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_CONNACK_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
}
// get remaining length and allocate buffer
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
buffer = new Byte[remainingLength];
// read bytes from socket...
_ = channel.Receive(buffer);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] ... set session present flag ...
msg.SessionPresent = (buffer[CONN_ACK_FLAGS_BYTE_OFFSET] & SESSION_PRESENT_FLAG_MASK) != 0x00;
}
// ...and set return code from broker
msg.ReturnCode = buffer[CONN_RETURN_CODE_BYTE_OFFSET];
return msg;
}
public override Byte[] GetBytes(Byte ProtocolVersion) {
Int32 varHeaderSize = 0;
Int32 payloadSize = 0;
Int32 remainingLength = 0;
Byte[] buffer;
Int32 index = 0;
if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// flags byte and connect return code
varHeaderSize += CONN_ACK_FLAGS_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE;
} else {
// 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
Int32 fixedHeaderSize = 1;
Int32 temp = remainingLength;
// increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
// first fixed header byte
buffer[index++] = ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
? (Byte)((MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_CONNACK_FLAG_BITS)
: (Byte)(MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET);
// encode remaining length
index = this.EncodeRemainingLength(remainingLength, buffer, index);
if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] session present flag // [v3.1.1] session present flag
buffer[index++] = this.SessionPresent ? (Byte)(1 << SESSION_PRESENT_FLAG_OFFSET) : (Byte)0x00; private const byte SESSION_PRESENT_FLAG_MASK = 0x01;
} else { private const byte SESSION_PRESENT_FLAG_OFFSET = 0x00;
// topic name compression response (reserved values. not used); private const byte SESSION_PRESENT_FLAG_SIZE = 0x01;
buffer[index++] = 0x00; private const byte CONN_RETURN_CODE_BYTE_OFFSET = 1;
} private const byte CONN_RETURN_CODE_BYTE_SIZE = 1;
// connect return code #endregion
buffer[index++] = this.ReturnCode;
return buffer; #region Properties...
}
public override String ToString() => // [v3.1.1] session present flag
/// <summary>
/// Session present flag
/// </summary>
public bool SessionPresent
{
get { return this.sessionPresent; }
set { this.sessionPresent = value; }
}
/// <summary>
/// Return Code
/// </summary>
public byte ReturnCode
{
get { return this.returnCode; }
set { this.returnCode = value; }
}
#endregion
// [v3.1.1] session present flag
private bool sessionPresent;
// 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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>CONNACK message instance</returns>
public static MqttMsgConnack Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
MqttMsgConnack msg = new MqttMsgConnack();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_CONNACK_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] ... set session present flag ...
msg.sessionPresent = (buffer[CONN_ACK_FLAGS_BYTE_OFFSET] & SESSION_PRESENT_FLAG_MASK) != 0x00;
}
// ...and set return code from broker
msg.returnCode = buffer[CONN_RETURN_CODE_BYTE_OFFSET];
return msg;
}
public override byte[] GetBytes(byte ProtocolVersion)
{
int fixedHeaderSize = 0;
int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
// flags byte and connect return code
varHeaderSize += (CONN_ACK_FLAGS_BYTE_SIZE + CONN_RETURN_CODE_BYTE_SIZE);
else
// 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
if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_CONNACK_FLAG_BITS; // [v.3.1.1]
else
buffer[index++] = (byte)(MQTT_MSG_CONNACK_TYPE << MSG_TYPE_OFFSET);
// encode remaining length
index = this.encodeRemainingLength(remainingLength, buffer, index);
if (ProtocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
// [v3.1.1] session present flag
buffer[index++] = this.sessionPresent ? (byte)(1 << SESSION_PRESENT_FLAG_OFFSET) : (byte)0x00;
else
// topic name compression response (reserved values. not used);
buffer[index++] = 0x00;
// connect return code
buffer[index++] = this.returnCode;
return buffer;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"CONNACK", "CONNACK",
new Object[] { "returnCode" }, new object[] { "returnCode" },
new Object[] { this.ReturnCode }); new object[] { this.returnCode });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

966
M2Mqtt/Messages/MqttMsgConnect.cs
View File

File diff suppressed because it is too large Load Diff

33
M2Mqtt/Messages/MqttMsgConnectEventArgs.cs
View File

@ -14,26 +14,31 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for CONNECT message received from client
/// </summary>
public class MqttMsgConnectEventArgs : EventArgs {
/// <summary> /// <summary>
/// Message received from client /// Event Args class for CONNECT message received from client
/// </summary> /// </summary>
public MqttMsgConnect Message { get; private set; } public class MqttMsgConnectEventArgs : EventArgs
{
/// <summary>
/// Message received from client
/// </summary>
public MqttMsgConnect Message { get; private set; }
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
/// <param name="msg">CONNECT message received from client</param> /// <param name="msg">CONNECT message received from client</param>
public MqttMsgConnectEventArgs(MqttMsgConnect connect) => this.Message = connect; public MqttMsgConnectEventArgs(MqttMsgConnect connect)
} {
this.Message = connect;
}
}
} }

224
M2Mqtt/Messages/MqttMsgContext.cs
View File

@ -15,137 +15,145 @@ Contributors:
*/ */
using System; using System;
using System.Text;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Context for MQTT message
/// </summary>
public class MqttMsgContext {
/// <summary> /// <summary>
/// MQTT message /// Context for MQTT message
/// </summary> /// </summary>
public MqttMsgBase Message { get; set; } public class MqttMsgContext
{
/// <summary>
/// MQTT message
/// </summary>
public MqttMsgBase Message { get; set; }
/// <summary> /// <summary>
/// MQTT message state /// MQTT message state
/// </summary> /// </summary>
public MqttMsgState State { get; set; } 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>
/// Unique key
/// </summary>
public string Key
{
get { return this.Flow + "_" + this.Message.MessageId; }
}
}
/// <summary> /// <summary>
/// Flow of the message /// Flow of the message
/// </summary> /// </summary>
public MqttMsgFlow Flow { get; set; } public enum MqttMsgFlow
{
/// <summary>
/// To publish to subscribers
/// </summary>
ToPublish,
/// <summary>
/// To acknowledge to publisher
/// </summary>
ToAcknowledge
}
/// <summary> /// <summary>
/// Timestamp in ticks (for retry) /// MQTT message state
/// </summary> /// </summary>
public Int32 Timestamp { get; set; } public enum MqttMsgState
{
/// <summary>
/// QOS = 0, Message queued
/// </summary>
QueuedQos0,
/// <summary> /// <summary>
/// Attempt (for retry) /// QOS = 1, Message queued
/// </summary> /// </summary>
public Int32 Attempt { get; set; } QueuedQos1,
/// <summary> /// <summary>
/// Unique key /// QOS = 2, Message queued
/// </summary> /// </summary>
public String Key => this.Flow + "_" + this.Message.MessageId; QueuedQos2,
}
/// <summary> /// <summary>
/// Flow of the message /// QOS = 1, PUBLISH sent, wait for PUBACK
/// </summary> /// </summary>
public enum MqttMsgFlow { WaitForPuback,
/// <summary>
/// To publish to subscribers
/// </summary>
ToPublish,
/// <summary> /// <summary>
/// To acknowledge to publisher /// QOS = 2, PUBLISH sent, wait for PUBREC
/// </summary> /// </summary>
ToAcknowledge WaitForPubrec,
}
/// <summary> /// <summary>
/// MQTT message state /// QOS = 2, PUBREC sent, wait for PUBREL
/// </summary> /// </summary>
public enum MqttMsgState { WaitForPubrel,
/// <summary>
/// QOS = 0, Message queued
/// </summary>
QueuedQos0,
/// <summary> /// <summary>
/// QOS = 1, Message queued /// QOS = 2, PUBREL sent, wait for PUBCOMP
/// </summary> /// </summary>
QueuedQos1, WaitForPubcomp,
/// <summary> /// <summary>
/// QOS = 2, Message queued /// QOS = 2, start first phase handshake send PUBREC
/// </summary> /// </summary>
QueuedQos2, SendPubrec,
/// <summary> /// <summary>
/// QOS = 1, PUBLISH sent, wait for PUBACK /// QOS = 2, start second phase handshake send PUBREL
/// </summary> /// </summary>
WaitForPuback, SendPubrel,
/// <summary> /// <summary>
/// QOS = 2, PUBLISH sent, wait for PUBREC /// QOS = 2, end second phase handshake send PUBCOMP
/// </summary> /// </summary>
WaitForPubrec, SendPubcomp,
/// <summary> /// <summary>
/// QOS = 2, PUBREC sent, wait for PUBREL /// QOS = 1, PUBLISH received, send PUBACK
/// </summary> /// </summary>
WaitForPubrel, SendPuback,
/// <summary> // [v3.1.1] SUBSCRIBE isn't "officially" QOS = 1
/// QOS = 2, PUBREL sent, wait for PUBCOMP /// <summary>
/// </summary> /// Send SUBSCRIBE message
WaitForPubcomp, /// </summary>
SendSubscribe,
/// <summary> // [v3.1.1] UNSUBSCRIBE isn't "officially" QOS = 1
/// QOS = 2, start first phase handshake send PUBREC /// <summary>
/// </summary> /// Send UNSUBSCRIBE message
SendPubrec, /// </summary>
SendUnsubscribe,
/// <summary> /// <summary>
/// QOS = 2, start second phase handshake send PUBREL /// (QOS = 1), SUBSCRIBE sent, wait for SUBACK
/// </summary> /// </summary>
SendPubrel, WaitForSuback,
/// <summary> /// <summary>
/// QOS = 2, end second phase handshake send PUBCOMP /// (QOS = 1), UNSUBSCRIBE sent, wait for UNSUBACK
/// </summary> /// </summary>
SendPubcomp, WaitForUnsuback
}
/// <summary>
/// QOS = 1, PUBLISH received, send PUBACK
/// </summary>
SendPuback,
// [v3.1.1] SUBSCRIBE isn't "officially" QOS = 1
/// <summary>
/// Send SUBSCRIBE message
/// </summary>
SendSubscribe,
// [v3.1.1] UNSUBSCRIBE isn't "officially" QOS = 1
/// <summary>
/// Send UNSUBSCRIBE message
/// </summary>
SendUnsubscribe,
/// <summary>
/// (QOS = 1), SUBSCRIBE sent, wait for SUBACK
/// </summary>
WaitForSuback,
/// <summary>
/// (QOS = 1), UNSUBSCRIBE sent, wait for UNSUBACK
/// </summary>
WaitForUnsuback
}
} }

101
M2Mqtt/Messages/MqttMsgDisconnect.cs
View File

@ -14,66 +14,73 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for DISCONNECT message from client to broker
/// </summary>
public class MqttMsgDisconnect : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for DISCONNECT message from client to broker
/// </summary> /// </summary>
public MqttMsgDisconnect() => this.Type = MQTT_MSG_DISCONNECT_TYPE; public class MqttMsgDisconnect : MqttMsgBase
{
/// <summary> /// <summary>
/// Parse bytes for a DISCONNECT message /// Constructor
/// </summary> /// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param> public MqttMsgDisconnect()
/// <param name="protocolVersion">Protocol Version</param> {
/// <param name="channel">Channel connected to the broker</param> this.type = MQTT_MSG_DISCONNECT_TYPE;
/// <returns>DISCONNECT message instance</returns>
public static MqttMsgDisconnect Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
MqttMsgDisconnect msg = new MqttMsgDisconnect();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_DISCONNECT_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer /// <summary>
_ = DecodeRemainingLength(channel); /// Parse bytes for a DISCONNECT message
// NOTE : remainingLength must be 0 /// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>DISCONNECT message instance</returns>
public static MqttMsgDisconnect Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
MqttMsgDisconnect msg = new MqttMsgDisconnect();
return msg; if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
} {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_DISCONNECT_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
public override Byte[] GetBytes(Byte protocolVersion) { // get remaining length and allocate buffer
Byte[] buffer = new Byte[2]; int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
Int32 index = 0; // NOTE : remainingLength must be 0
// first fixed header byte return msg;
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1 }
? (Byte)((MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_DISCONNECT_FLAG_BITS)
: (Byte)(MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET);
buffer[index++] = 0x00; public override byte[] GetBytes(byte protocolVersion)
{
byte[] buffer = new byte[2];
int index = 0;
return buffer; // first fixed header byte
} if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_DISCONNECT_FLAG_BITS; // [v.3.1.1]
else
buffer[index++] = (MQTT_MSG_DISCONNECT_TYPE << MSG_TYPE_OFFSET);
buffer[index++] = 0x00;
public override String ToString() => return buffer;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"DISCONNECT", "DISCONNECT",
null, null,
null); null);
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

109
M2Mqtt/Messages/MqttMsgPingReq.cs
View File

@ -14,66 +14,73 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for PINGREQ message from client to broker
/// </summary>
public class MqttMsgPingReq : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for PINGREQ message from client to broker
/// </summary> /// </summary>
public MqttMsgPingReq() => this.Type = MQTT_MSG_PINGREQ_TYPE; public class MqttMsgPingReq : MqttMsgBase
{
public override Byte[] GetBytes(Byte protocolVersion) { /// <summary>
Byte[] buffer = new Byte[2]; /// Constructor
Int32 index = 0; /// </summary>
public MqttMsgPingReq()
// first fixed header byte {
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1 this.type = MQTT_MSG_PINGREQ_TYPE;
? (Byte)((MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGREQ_FLAG_BITS)
: (Byte)(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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PINGREQ message instance</returns>
public static MqttMsgPingReq Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
MqttMsgPingReq msg = new MqttMsgPingReq();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGREQ_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// already know remaininglength is zero (MQTT specification), public override byte[] GetBytes(byte protocolVersion)
// so it isn't necessary to read other data from socket {
_ = DecodeRemainingLength(channel); byte[] buffer = new byte[2];
int index = 0;
return msg; // first fixed header byte
} if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGREQ_FLAG_BITS; // [v.3.1.1]
else
buffer[index++] = (MQTT_MSG_PINGREQ_TYPE << MSG_TYPE_OFFSET);
buffer[index++] = 0x00;
public override String ToString() => return buffer;
}
/// <summary>
/// Parse bytes for a PINGREQ message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PINGREQ message instance</returns>
public static MqttMsgPingReq Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
MqttMsgPingReq msg = new MqttMsgPingReq();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGREQ_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// already know remaininglength is zero (MQTT specification),
// so it isn't necessary to read other data from socket
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
return msg;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PINGREQ", "PINGREQ",
null, null,
null); null);
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

100
M2Mqtt/Messages/MqttMsgPingResp.cs
View File

@ -17,63 +17,71 @@ Contributors:
using System; using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for PINGRESP message from client to broker
/// </summary>
public class MqttMsgPingResp : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for PINGRESP message from client to broker
/// </summary> /// </summary>
public MqttMsgPingResp() => this.Type = MQTT_MSG_PINGRESP_TYPE; public class MqttMsgPingResp : MqttMsgBase
{
/// <summary> /// <summary>
/// Parse bytes for a PINGRESP message /// Constructor
/// </summary> /// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param> public MqttMsgPingResp()
/// <param name="protocolVersion">Protocol Version</param> {
/// <param name="channel">Channel connected to the broker</param> this.type = MQTT_MSG_PINGRESP_TYPE;
/// <returns>PINGRESP message instance</returns>
public static MqttMsgPingResp Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
MqttMsgPingResp msg = new MqttMsgPingResp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGRESP_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// already know remaininglength is zero (MQTT specification), /// <summary>
// so it isn't necessary to read other data from socket /// Parse bytes for a PINGRESP message
_ = DecodeRemainingLength(channel); /// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PINGRESP message instance</returns>
public static MqttMsgPingResp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
MqttMsgPingResp msg = new MqttMsgPingResp();
return msg; if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
} {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PINGRESP_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
public override Byte[] GetBytes(Byte protocolVersion) { // already know remaininglength is zero (MQTT specification),
Byte[] buffer = new Byte[2]; // so it isn't necessary to read other data from socket
Int32 index = 0; int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
// first fixed header byte return msg;
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1 }
? (Byte)((MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGRESP_FLAG_BITS)
: (Byte)(MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET);
buffer[index++] = 0x00; public override byte[] GetBytes(byte protocolVersion)
{
byte[] buffer = new byte[2];
int index = 0;
return buffer; // first fixed header byte
} if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PINGRESP_FLAG_BITS; // [v.3.1.1]
else
buffer[index++] = (MQTT_MSG_PINGRESP_TYPE << MSG_TYPE_OFFSET);
buffer[index++] = 0x00;
public override String ToString() => return buffer;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PINGRESP", "PINGRESP",
null, null,
null); null);
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

180
M2Mqtt/Messages/MqttMsgPuback.cs
View File

@ -14,102 +14,112 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for PUBACK message from broker to client
/// </summary>
public class MqttMsgPuback : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for PUBACK message from broker to client
/// </summary> /// </summary>
public MqttMsgPuback() => this.Type = MQTT_MSG_PUBACK_TYPE; public class MqttMsgPuback : MqttMsgBase
{
public override Byte[] GetBytes(Byte protocolVersion) { /// <summary>
Int32 varHeaderSize = 0; /// Constructor
Int32 payloadSize = 0; /// </summary>
Int32 remainingLength = 0; public MqttMsgPuback()
Byte[] buffer; {
Int32 index = 0; this.type = MQTT_MSG_PUBACK_TYPE;
// message identifier
varHeaderSize += MESSAGE_ID_SIZE;
remainingLength += varHeaderSize + payloadSize;
// first byte of fixed header
Int32 fixedHeaderSize = 1;
Int32 temp = remainingLength;
// increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
// first fixed header byte
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
? (Byte)((MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBACK_FLAG_BITS)
: (Byte)(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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBACK message instance</returns>
public static MqttMsgPuback Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
MqttMsgPuback msg = new MqttMsgPuback();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBACK_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer public override byte[] GetBytes(byte protocolVersion)
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel); {
buffer = new Byte[remainingLength]; int fixedHeaderSize = 0;
int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
// read bytes from socket... // message identifier
_ = channel.Receive(buffer); varHeaderSize += MESSAGE_ID_SIZE;
// message id remainingLength += (varHeaderSize + payloadSize);
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
msg.MessageId |= buffer[index++];
return msg; // first byte of fixed header
} fixedHeaderSize = 1;
public override String ToString() => 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
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_PUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBACK_FLAG_BITS; // [v.3.1.1]
else
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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBACK message instance</returns>
public static MqttMsgPuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPuback msg = new MqttMsgPuback();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBACK_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return msg;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PUBACK", "PUBACK",
new Object[] { "messageId" }, new object[] { "messageId" },
new Object[] { this.MessageId }); new object[] { this.messageId });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

180
M2Mqtt/Messages/MqttMsgPubcomp.cs
View File

@ -14,102 +14,112 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for PUBCOMP message from broker to client
/// </summary>
public class MqttMsgPubcomp : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for PUBCOMP message from broker to client
/// </summary> /// </summary>
public MqttMsgPubcomp() => this.Type = MQTT_MSG_PUBCOMP_TYPE; public class MqttMsgPubcomp : MqttMsgBase
{
public override Byte[] GetBytes(Byte protocolVersion) { /// <summary>
Int32 varHeaderSize = 0; /// Constructor
Int32 payloadSize = 0; /// </summary>
Int32 remainingLength = 0; public MqttMsgPubcomp()
Byte[] buffer; {
Int32 index = 0; this.type = MQTT_MSG_PUBCOMP_TYPE;
// message identifier
varHeaderSize += MESSAGE_ID_SIZE;
remainingLength += varHeaderSize + payloadSize;
// first byte of fixed header
Int32 fixedHeaderSize = 1;
Int32 temp = remainingLength;
// increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
// first fixed header byte
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
? (Byte)((MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBCOMP_FLAG_BITS)
: (Byte)(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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBCOMP message instance</returns>
public static MqttMsgPubcomp Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
MqttMsgPubcomp msg = new MqttMsgPubcomp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer public override byte[] GetBytes(byte protocolVersion)
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel); {
buffer = new Byte[remainingLength]; int fixedHeaderSize = 0;
int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
// read bytes from socket... // message identifier
_ = channel.Receive(buffer); varHeaderSize += MESSAGE_ID_SIZE;
// message id remainingLength += (varHeaderSize + payloadSize);
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
msg.MessageId |= buffer[index++];
return msg; // first byte of fixed header
} fixedHeaderSize = 1;
public override String ToString() => 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
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_PUBCOMP_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBCOMP_FLAG_BITS; // [v.3.1.1]
else
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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBCOMP message instance</returns>
public static MqttMsgPubcomp Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPubcomp msg = new MqttMsgPubcomp();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBCOMP_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return msg;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PUBCOMP", "PUBCOMP",
new Object[] { "messageId" }, new object[] { "messageId" },
new Object[] { this.MessageId }); new object[] { this.messageId });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

83
M2Mqtt/Messages/MqttMsgPublish.cs
View File

@ -40,7 +40,9 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
public MqttMsgPublish() => this.Type = MQTT_MSG_PUBLISH_TYPE; public MqttMsgPublish() {
this.type = MQTT_MSG_PUBLISH_TYPE;
}
/// <summary> /// <summary>
/// Constructor /// Constructor
@ -59,16 +61,17 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
/// <param name="qosLevel">Quality of Service level</param> /// <param name="qosLevel">Quality of Service level</param>
/// <param name="retain">Retain flag</param> /// <param name="retain">Retain flag</param>
public MqttMsgPublish(String topic, Byte[] message, Boolean dupFlag, Byte qosLevel, Boolean retain) : base() { public MqttMsgPublish(String topic, Byte[] message, Boolean dupFlag, Byte qosLevel, Boolean retain) : base() {
this.Type = MQTT_MSG_PUBLISH_TYPE; this.type = MQTT_MSG_PUBLISH_TYPE;
this.Topic = topic; this.Topic = topic;
this.Message = message; this.Message = message;
this.DupFlag = dupFlag; this.dupFlag = dupFlag;
this.QosLevel = qosLevel; this.qosLevel = qosLevel;
this.Retain = retain; this.retain = retain;
this.MessageId = 0; this.messageId = 0;
} }
public override Byte[] GetBytes(Byte protocolVersion) { public override Byte[] GetBytes(Byte protocolVersion) {
Int32 fixedHeaderSize = 0;
Int32 varHeaderSize = 0; Int32 varHeaderSize = 0;
Int32 payloadSize = 0; Int32 payloadSize = 0;
Int32 remainingLength = 0; Int32 remainingLength = 0;
@ -76,17 +79,17 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
Int32 index = 0; Int32 index = 0;
// topic can't contain wildcards // topic can't contain wildcards
if (this.Topic.IndexOf('#') != -1 || this.Topic.IndexOf('+') != -1) { if ((this.Topic.IndexOf('#') != -1) || (this.Topic.IndexOf('+') != -1)) {
throw new MqttClientException(MqttClientErrorCode.TopicWildcard); throw new MqttClientException(MqttClientErrorCode.TopicWildcard);
} }
// check topic length // check topic length
if (this.Topic.Length < MIN_TOPIC_LENGTH || this.Topic.Length > MAX_TOPIC_LENGTH) { if ((this.Topic.Length < MIN_TOPIC_LENGTH) || (this.Topic.Length > MAX_TOPIC_LENGTH)) {
throw new MqttClientException(MqttClientErrorCode.TopicLength); throw new MqttClientException(MqttClientErrorCode.TopicLength);
} }
// check wrong QoS level (both bits can't be set 1) // check wrong QoS level (both bits can't be set 1)
if (this.QosLevel > QOS_LEVEL_EXACTLY_ONCE) { if (this.qosLevel > QOS_LEVEL_EXACTLY_ONCE) {
throw new MqttClientException(MqttClientErrorCode.QosNotAllowed); throw new MqttClientException(MqttClientErrorCode.QosNotAllowed);
} }
@ -96,7 +99,7 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
varHeaderSize += topicUtf8.Length + 2; varHeaderSize += topicUtf8.Length + 2;
// message id is valid only with QOS level 1 or QOS level 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) { if ((this.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) || (this.qosLevel == QOS_LEVEL_EXACTLY_ONCE)) {
varHeaderSize += MESSAGE_ID_SIZE; varHeaderSize += MESSAGE_ID_SIZE;
} }
@ -106,30 +109,30 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
payloadSize += this.Message.Length; payloadSize += this.Message.Length;
} }
remainingLength += varHeaderSize + payloadSize; remainingLength += (varHeaderSize + payloadSize);
// first byte of fixed header // first byte of fixed header
Int32 fixedHeaderSize = 1; fixedHeaderSize = 1;
Int32 temp = remainingLength; Int32 temp = remainingLength;
// increase fixed header size based on remaining length // increase fixed header size based on remaining length
// (each remaining length byte can encode until 128) // (each remaining length byte can encode until 128)
do { do {
fixedHeaderSize++; fixedHeaderSize++;
temp /= 128; temp = temp / 128;
} while (temp > 0); } while (temp > 0);
// allocate buffer for message // allocate buffer for message
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize]; buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
// first fixed header byte // first fixed header byte
buffer[index] = (Byte)((MQTT_MSG_PUBLISH_TYPE << MSG_TYPE_OFFSET) | (this.QosLevel << QOS_LEVEL_OFFSET)); 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.dupFlag ? (Byte)(1 << DUP_FLAG_OFFSET) : (Byte)0x00;
buffer[index] |= this.Retain ? (Byte)(1 << RETAIN_FLAG_OFFSET) : (Byte)0x00; buffer[index] |= this.retain ? (Byte)(1 << RETAIN_FLAG_OFFSET) : (Byte)0x00;
index++; index++;
// encode remaining length // encode remaining length
index = this.EncodeRemainingLength(remainingLength, buffer, index); index = this.encodeRemainingLength(remainingLength, buffer, index);
// topic name // topic name
buffer[index++] = (Byte)((topicUtf8.Length >> 8) & 0x00FF); // MSB buffer[index++] = (Byte)((topicUtf8.Length >> 8) & 0x00FF); // MSB
@ -138,22 +141,22 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
index += topicUtf8.Length; index += topicUtf8.Length;
// message id is valid only with QOS level 1 or QOS level 2 // message id is valid only with QOS level 1 or QOS level 2
if (this.QosLevel == QOS_LEVEL_AT_LEAST_ONCE || if ((this.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) ||
this.QosLevel == QOS_LEVEL_EXACTLY_ONCE) { (this.qosLevel == QOS_LEVEL_EXACTLY_ONCE)) {
// check message identifier assigned // check message identifier assigned
if (this.MessageId == 0) { if (this.messageId == 0) {
throw new MqttClientException(MqttClientErrorCode.WrongMessageId); throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
} }
buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB buffer[index++] = (Byte)((this.messageId >> 8) & 0x00FF); // MSB
buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB buffer[index++] = (Byte)(this.messageId & 0x00FF); // LSB
} }
// check on message with zero length // check on message with zero length
if (this.Message != null) { if (this.Message != null) {
// message data // message data
Array.Copy(this.Message, 0, buffer, index, this.Message.Length); Array.Copy(this.Message, 0, buffer, index, this.Message.Length);
_ = this.Message.Length; index += this.Message.Length;
} }
return buffer; return buffer;
@ -174,14 +177,14 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
MqttMsgPublish msg = new MqttMsgPublish(); MqttMsgPublish msg = new MqttMsgPublish();
// get remaining length and allocate buffer // get remaining length and allocate buffer
Int32 remainingLength = DecodeRemainingLength(channel); Int32 remainingLength = decodeRemainingLength(channel);
buffer = new Byte[remainingLength]; buffer = new Byte[remainingLength];
// read bytes from socket... // read bytes from socket...
Int32 received = channel.Receive(buffer); Int32 received = channel.Receive(buffer);
// topic name // topic name
topicUtf8Length = (buffer[index++] << 8) & 0xFF00; topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
topicUtf8Length |= buffer[index++]; topicUtf8Length |= buffer[index++];
topicUtf8 = new Byte[topicUtf8Length]; topicUtf8 = new Byte[topicUtf8Length];
Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length); Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
@ -189,22 +192,22 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
msg.Topic = new String(Encoding.UTF8.GetChars(topicUtf8)); msg.Topic = new String(Encoding.UTF8.GetChars(topicUtf8));
// read QoS level from fixed header // read QoS level from fixed header
msg.QosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET); msg.qosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET);
// check wrong QoS level (both bits can't be set 1) // check wrong QoS level (both bits can't be set 1)
if (msg.QosLevel > QOS_LEVEL_EXACTLY_ONCE) { if (msg.qosLevel > QOS_LEVEL_EXACTLY_ONCE) {
throw new MqttClientException(MqttClientErrorCode.QosNotAllowed); throw new MqttClientException(MqttClientErrorCode.QosNotAllowed);
} }
// read DUP flag from fixed header // read DUP flag from fixed header
msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01; msg.dupFlag = (((fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET) == 0x01);
// read retain flag from fixed header // read retain flag from fixed header
msg.Retain = (fixedHeaderFirstByte & RETAIN_FLAG_MASK) >> RETAIN_FLAG_OFFSET == 0x01; msg.retain = (((fixedHeaderFirstByte & RETAIN_FLAG_MASK) >> RETAIN_FLAG_OFFSET) == 0x01);
// message id is valid only with QOS level 1 or QOS level 2 // message id is valid only with QOS level 1 or QOS level 2
if (msg.QosLevel == QOS_LEVEL_AT_LEAST_ONCE || if ((msg.qosLevel == QOS_LEVEL_AT_LEAST_ONCE) ||
msg.QosLevel == QOS_LEVEL_EXACTLY_ONCE) { (msg.qosLevel == QOS_LEVEL_EXACTLY_ONCE)) {
// message id // message id
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00); msg.messageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
msg.MessageId |= buffer[index++]; msg.messageId |= (buffer[index++]);
} }
// get payload with message data // get payload with message data
@ -217,8 +220,8 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
// copy first part of payload data received // copy first part of payload data received
Array.Copy(buffer, index, msg.Message, messageOffset, received - index); Array.Copy(buffer, index, msg.Message, messageOffset, received - index);
remaining -= received - index; remaining -= (received - index);
messageOffset += received - index; messageOffset += (received - index);
// if payload isn't finished // if payload isn't finished
while (remaining > 0) { while (remaining > 0) {
@ -232,15 +235,15 @@ namespace uPLibrary.Networking.M2Mqtt.Messages {
return msg; return msg;
} }
public override String ToString() => public override String ToString() {
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PUBLISH", "PUBLISH",
new Object[] { "messageId", "topic", "message" }, new Object[] { "messageId", "topic", "message" },
new Object[] { this.MessageId, this.Topic, this.Message }); new Object[] { this.messageId, this.Topic, this.Message });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

126
M2Mqtt/Messages/MqttMsgPublishEventArgs.cs
View File

@ -14,66 +14,98 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for PUBLISH message received from broker
/// </summary>
public class MqttMsgPublishEventArgs : EventArgs {
#region Properties...
/// <summary> /// <summary>
/// Message topic /// Event Args class for PUBLISH message received from broker
/// </summary> /// </summary>
public String Topic { get; internal set; } public class MqttMsgPublishEventArgs : EventArgs
{
#region Properties...
/// <summary> /// <summary>
/// Message data /// Message topic
/// </summary> /// </summary>
public Byte[] Message { get; internal set; } public string Topic
{
get { return this.topic; }
internal set { this.topic = value; }
}
/// <summary> /// <summary>
/// Duplicate message flag /// Message data
/// </summary> /// </summary>
public Boolean DupFlag { get; set; } public byte[] Message
{
get { return this.message; }
internal set { this.message = value; }
}
/// <summary> /// <summary>
/// Quality of Service level /// Duplicate message flag
/// </summary> /// </summary>
public Byte QosLevel { get; internal set; } public bool DupFlag
{
get { return this.dupFlag; }
set { this.dupFlag = value; }
}
/// <summary> /// <summary>
/// Retain message flag /// Quality of Service level
/// </summary> /// </summary>
public Boolean Retain { get; internal set; } public byte QosLevel
{
get { return this.qosLevel; }
internal set { this.qosLevel = value; }
}
#endregion /// <summary>
/// Retain message flag
/// </summary>
public bool Retain
{
get { return this.retain; }
internal set { this.retain = value; }
}
// message topic #endregion
/// <summary> // message topic
/// Constructor private string topic;
/// </summary> // message data
/// <param name="topic">Message topic</param> private byte[] message;
/// <param name="message">Message data</param> // duplicate delivery
/// <param name="dupFlag">Duplicate delivery flag</param> private bool dupFlag;
/// <param name="qosLevel">Quality of Service level</param> // quality of service level
/// <param name="retain">Retain flag</param> private byte qosLevel;
public MqttMsgPublishEventArgs(String topic, // retain flag
Byte[] message, private bool retain;
Boolean dupFlag,
Byte qosLevel, /// <summary>
Boolean retain) { /// Constructor
this.Topic = topic; /// </summary>
this.Message = message; /// <param name="topic">Message topic</param>
this.DupFlag = dupFlag; /// <param name="message">Message data</param>
this.QosLevel = qosLevel; /// <param name="dupFlag">Duplicate delivery flag</param>
this.Retain = retain; /// <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;
}
} }
}
} }

82
M2Mqtt/Messages/MqttMsgPublishedEventArgs.cs
View File

@ -14,49 +14,65 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for published message
/// </summary>
public class MqttMsgPublishedEventArgs : EventArgs {
#region Properties...
/// <summary> /// <summary>
/// Message identifier /// Event Args class for published message
/// </summary> /// </summary>
public UInt16 MessageId { get; internal set; } public class MqttMsgPublishedEventArgs : EventArgs
{
#region Properties...
/// <summary> /// <summary>
/// Message published (or failed due to retries) /// Message identifier
/// </summary> /// </summary>
public Boolean IsPublished { get; internal set; } public ushort MessageId
{
get { return this.messageId; }
internal set { this.messageId = value; }
}
#endregion /// <summary>
/// Message published (or failed due to retries)
/// </summary>
public bool IsPublished
{
get { return this.isPublished; }
internal set { this.isPublished = value; }
}
// message identifier #endregion
/// <summary> // message identifier
/// Constructor (published message) ushort messageId;
/// </summary>
/// <param name="messageId">Message identifier published</param> // published flag
public MqttMsgPublishedEventArgs(UInt16 messageId) bool isPublished;
: this(messageId, true) {
/// <summary>
/// Constructor (published message)
/// </summary>
/// <param name="messageId">Message identifier published</param>
public MqttMsgPublishedEventArgs(ushort messageId)
: this(messageId, true)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="messageId">Message identifier</param>
/// <param name="isPublished">Publish flag</param>
public MqttMsgPublishedEventArgs(ushort messageId, bool isPublished)
{
this.messageId = messageId;
this.isPublished = isPublished;
}
} }
/// <summary>
/// Constructor
/// </summary>
/// <param name="messageId">Message identifier</param>
/// <param name="isPublished">Publish flag</param>
public MqttMsgPublishedEventArgs(UInt16 messageId, Boolean isPublished) {
this.MessageId = messageId;
this.IsPublished = isPublished;
}
}
} }

180
M2Mqtt/Messages/MqttMsgPubrec.cs
View File

@ -14,102 +14,112 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for PUBREC message from broker to client
/// </summary>
public class MqttMsgPubrec : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for PUBREC message from broker to client
/// </summary> /// </summary>
public MqttMsgPubrec() => this.Type = MQTT_MSG_PUBREC_TYPE; public class MqttMsgPubrec : MqttMsgBase
{
public override Byte[] GetBytes(Byte protocolVersion) { /// <summary>
Int32 varHeaderSize = 0; /// Constructor
Int32 payloadSize = 0; /// </summary>
Int32 remainingLength = 0; public MqttMsgPubrec()
Byte[] buffer; {
Int32 index = 0; this.type = MQTT_MSG_PUBREC_TYPE;
// message identifier
varHeaderSize += MESSAGE_ID_SIZE;
remainingLength += varHeaderSize + payloadSize;
// first byte of fixed header
Int32 fixedHeaderSize = 1;
Int32 temp = remainingLength;
// increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize];
// first fixed header byte
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1
? (Byte)((MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREC_FLAG_BITS)
: (Byte)(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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBREC message instance</returns>
public static MqttMsgPubrec Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
MqttMsgPubrec msg = new MqttMsgPubrec();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREC_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer public override byte[] GetBytes(byte protocolVersion)
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel); {
buffer = new Byte[remainingLength]; int fixedHeaderSize = 0;
int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
// read bytes from socket... // message identifier
_ = channel.Receive(buffer); varHeaderSize += MESSAGE_ID_SIZE;
// message id remainingLength += (varHeaderSize + payloadSize);
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
msg.MessageId |= buffer[index++];
return msg; // first byte of fixed header
} fixedHeaderSize = 1;
public override String ToString() => 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
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_PUBREC_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREC_FLAG_BITS; // [v.3.1.1]
else
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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBREC message instance</returns>
public static MqttMsgPubrec Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPubrec msg = new MqttMsgPubrec();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREC_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
// message id
msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
msg.messageId |= (buffer[index++]);
return msg;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PUBREC", "PUBREC",
new Object[] { "messageId" }, new object[] { "messageId" },
new Object[] { this.MessageId }); new object[] { this.messageId });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

210
M2Mqtt/Messages/MqttMsgPubrel.cs
View File

@ -16,117 +16,127 @@ Contributors:
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for PUBREL message from client top broker
/// </summary>
public class MqttMsgPubrel : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for PUBREL message from client top broker
/// </summary> /// </summary>
public MqttMsgPubrel() { public class MqttMsgPubrel : MqttMsgBase
this.Type = MQTT_MSG_PUBREL_TYPE; {
// PUBREL message use QoS Level 1 (not "officially" in 3.1.1) /// <summary>
this.QosLevel = QOS_LEVEL_AT_LEAST_ONCE; /// Constructor
} /// </summary>
public MqttMsgPubrel()
public override System.Byte[] GetBytes(System.Byte protocolVersion) { {
System.Int32 varHeaderSize = 0; this.type = MQTT_MSG_PUBREL_TYPE;
System.Int32 payloadSize = 0; // PUBREL message use QoS Level 1 (not "officially" in 3.1.1)
System.Int32 remainingLength = 0; this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
System.Byte[] buffer;
System.Int32 index = 0;
// message identifier
varHeaderSize += MESSAGE_ID_SIZE;
remainingLength += varHeaderSize + payloadSize;
// first byte of fixed header
System.Int32 fixedHeaderSize = 1;
System.Int32 temp = remainingLength;
// increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message
buffer = new System.Byte[fixedHeaderSize + varHeaderSize + payloadSize];
// first fixed header byte
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
buffer[index++] = (MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREL_FLAG_BITS; // [v.3.1.1]
} else {
buffer[index] = (System.Byte)((MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) |
(this.QosLevel << QOS_LEVEL_OFFSET));
buffer[index] |= this.DupFlag ? (System.Byte)(1 << DUP_FLAG_OFFSET) : (System.Byte)0x00;
index++;
}
// encode remaining length
index = this.EncodeRemainingLength(remainingLength, buffer, index);
// get next message identifier
buffer[index++] = (System.Byte)((this.MessageId >> 8) & 0x00FF); // MSB
buffer[index++] = (System.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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBREL message instance</returns>
public static MqttMsgPubrel Parse(System.Byte fixedHeaderFirstByte, System.Byte protocolVersion, IMqttNetworkChannel channel) {
System.Byte[] buffer;
System.Int32 index = 0;
MqttMsgPubrel msg = new MqttMsgPubrel();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREL_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer public override byte[] GetBytes(byte protocolVersion)
System.Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel); {
buffer = new System.Byte[remainingLength]; int fixedHeaderSize = 0;
int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
// read bytes from socket... // message identifier
_ = channel.Receive(buffer); varHeaderSize += MESSAGE_ID_SIZE;
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1) { remainingLength += (varHeaderSize + payloadSize);
// only 3.1.0
// read QoS level from fixed header (would be QoS Level 1) // first byte of fixed header
msg.QosLevel = (System.Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET); fixedHeaderSize = 1;
// read DUP flag from fixed header
msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01;
}
// message id int temp = remainingLength;
msg.MessageId = (System.UInt16)((buffer[index++] << 8) & 0xFF00); // increase fixed header size based on remaining length
msg.MessageId |= buffer[index++]; // (each remaining length byte can encode until 128)
do
{
fixedHeaderSize++;
temp = temp / 128;
} while (temp > 0);
return msg; // allocate buffer for message
} buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
public override System.String ToString() => // first fixed header byte
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_PUBREL_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_PUBREL_FLAG_BITS; // [v.3.1.1]
else
{
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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>PUBREL message instance</returns>
public static MqttMsgPubrel Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgPubrel msg = new MqttMsgPubrel();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_PUBREL_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
channel.Receive(buffer);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1)
{
// only 3.1.0
// 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;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"PUBREL", "PUBREL",
new System.Object[] { "messageId" }, new object[] { "messageId" },
new System.Object[] { this.MessageId }); new object[] { this.messageId });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

215
M2Mqtt/Messages/MqttMsgSuback.cs
View File

@ -17,127 +17,146 @@ Contributors:
using System; using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for SUBACK message from broker to client
/// </summary>
public class MqttMsgSuback : MqttMsgBase {
#region Properties...
/// <summary> /// <summary>
/// List of granted QOS Levels /// Class for SUBACK message from broker to client
/// </summary> /// </summary>
public Byte[] GrantedQoSLevels { get; set; } public class MqttMsgSuback : MqttMsgBase
{
#region Properties...
#endregion /// <summary>
/// List of granted QOS Levels
// granted QOS levels /// </summary>
public byte[] GrantedQoSLevels
/// <summary> {
/// Constructor get { return this.grantedQosLevels; }
/// </summary> set { this.grantedQosLevels = value; }
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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>SUBACK message instance</returns>
public static MqttMsgSuback Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
MqttMsgSuback msg = new MqttMsgSuback();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBACK_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer #endregion
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel);
buffer = new Byte[remainingLength];
// read bytes from socket... // granted QOS levels
_ = channel.Receive(buffer); byte[] grantedQosLevels;
// message id /// <summary>
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00); /// Constructor
msg.MessageId |= buffer[index++]; /// </summary>
public MqttMsgSuback()
{
this.type = MQTT_MSG_SUBACK_TYPE;
}
// payload contains QoS levels granted /// <summary>
msg.GrantedQoSLevels = new Byte[remainingLength - MESSAGE_ID_SIZE]; /// Parse bytes for a SUBACK message
Int32 qosIdx = 0; /// </summary>
do { /// <param name="fixedHeaderFirstByte">First fixed header byte</param>
msg.GrantedQoSLevels[qosIdx++] = buffer[index++]; /// <param name="protocolVersion">Protocol Version</param>
} while (index < remainingLength); /// <param name="channel">Channel connected to the broker</param>
/// <returns>SUBACK message instance</returns>
public static MqttMsgSuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgSuback msg = new MqttMsgSuback();
return msg; if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
} {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBACK_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
public override Byte[] GetBytes(Byte protocolVersion) { // get remaining length and allocate buffer
Int32 varHeaderSize = 0; int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
Int32 payloadSize = 0; buffer = new byte[remainingLength];
Int32 remainingLength = 0;
Byte[] buffer;
Int32 index = 0;
// message identifier // read bytes from socket...
varHeaderSize += MESSAGE_ID_SIZE; channel.Receive(buffer);
Int32 grantedQosIdx; // message id
for (grantedQosIdx = 0; grantedQosIdx < this.GrantedQoSLevels.Length; grantedQosIdx++) { msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
payloadSize++; msg.messageId |= (buffer[index++]);
}
remainingLength += varHeaderSize + payloadSize; // 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);
// first byte of fixed header return msg;
Int32 fixedHeaderSize = 1; }
Int32 temp = remainingLength; public override byte[] GetBytes(byte protocolVersion)
// increase fixed header size based on remaining length {
// (each remaining length byte can encode until 128) int fixedHeaderSize = 0;
do { int varHeaderSize = 0;
fixedHeaderSize++; int payloadSize = 0;
temp /= 128; int remainingLength = 0;
} while (temp > 0); byte[] buffer;
int index = 0;
// allocate buffer for message // message identifier
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize]; varHeaderSize += MESSAGE_ID_SIZE;
// first fixed header byte int grantedQosIdx = 0;
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1 for (grantedQosIdx = 0; grantedQosIdx < this.grantedQosLevels.Length; grantedQosIdx++)
? (Byte)((MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBACK_FLAG_BITS) {
: (Byte)(MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET); payloadSize++;
}
// encode remaining length remainingLength += (varHeaderSize + payloadSize);
index = this.EncodeRemainingLength(remainingLength, buffer, index);
// message id // first byte of fixed header
buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB fixedHeaderSize = 1;
buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB
// payload contains QoS levels granted int temp = remainingLength;
for (grantedQosIdx = 0; grantedQosIdx < this.GrantedQoSLevels.Length; grantedQosIdx++) { // increase fixed header size based on remaining length
buffer[index++] = this.GrantedQoSLevels[grantedQosIdx]; // (each remaining length byte can encode until 128)
} do
{
fixedHeaderSize++;
temp = temp / 128;
} while (temp > 0);
return buffer; // allocate buffer for message
} buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
public override String ToString() => // first fixed header byte
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBACK_FLAG_BITS; // [v.3.1.1]
else
buffer[index++] = (byte)(MQTT_MSG_SUBACK_TYPE << MSG_TYPE_OFFSET);
// 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;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"SUBACK", "SUBACK",
new Object[] { "messageId", "grantedQosLevels" }, new object[] { "messageId", "grantedQosLevels" },
new Object[] { this.MessageId, this.GrantedQoSLevels }); new object[] { this.messageId, this.grantedQosLevels });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

397
M2Mqtt/Messages/MqttMsgSubscribe.cs
View File

@ -16,234 +16,257 @@ Contributors:
using System; using System;
// if NOT .Net Micro Framework // if NOT .Net Micro Framework
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System.Collections.Generic; using System.Collections.Generic;
#endif #endif
using System.Collections; using System.Collections;
using System.Text; using System.Text;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for SUBSCRIBE message from client to broker
/// </summary>
public class MqttMsgSubscribe : MqttMsgBase {
#region Properties...
/// <summary> /// <summary>
/// List of topics to subscribe /// Class for SUBSCRIBE message from client to broker
/// </summary> /// </summary>
public String[] Topics { get; set; } public class MqttMsgSubscribe : MqttMsgBase
{
#region Properties...
/// <summary> /// <summary>
/// List of QOS Levels related to topics /// List of topics to subscribe
/// </summary> /// </summary>
public Byte[] QoSLevels { get; set; } public string[] Topics
{
#endregion get { return this.topics; }
set { this.topics = value; }
// topics to subscribe
/// <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 (not "officially" in 3.1.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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>SUBSCRIBE message instance</returns>
public static MqttMsgSubscribe Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
Byte[] topicUtf8;
Int32 topicUtf8Length;
MqttMsgSubscribe msg = new MqttMsgSubscribe();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBSCRIBE_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer /// <summary>
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel); /// List of QOS Levels related to topics
buffer = new Byte[remainingLength]; /// </summary>
public byte[] QoSLevels
{
get { return this.qosLevels; }
set { this.qosLevels = value; }
}
// read bytes from socket... #endregion
Int32 received = channel.Receive(buffer);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1) { // topics to subscribe
// only 3.1.0 string[] topics;
// QOS levels related to topics
byte[] qosLevels;
// read QoS level from fixed header /// <summary>
msg.QosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET); /// Constructor
// read DUP flag from fixed header /// </summary>
msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01; public MqttMsgSubscribe()
// retain flag not used {
msg.Retain = false; this.type = MQTT_MSG_SUBSCRIBE_TYPE;
} }
// message id /// <summary>
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00); /// Constructor
msg.MessageId |= buffer[index++]; /// </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;
// payload contains topics and QoS levels this.topics = topics;
// NOTE : before, I don't know how many topics will be in the payload (so use List) this.qosLevels = qosLevels;
// if .Net Micro Framework // SUBSCRIBE message uses QoS Level 1 (not "officially" in 3.1.1)
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>SUBSCRIBE message instance</returns>
public static MqttMsgSubscribe Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
byte[] topicUtf8;
int topicUtf8Length;
MqttMsgSubscribe msg = new MqttMsgSubscribe();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_SUBSCRIBE_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
int received = channel.Receive(buffer);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1)
{
// only 3.1.0
// 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 tmpTopics = new ArrayList();
IList tmpQosLevels = new ArrayList(); IList tmpQosLevels = new ArrayList();
// else other frameworks (.Net, .Net Compact, Mono, Windows Phone) // else other frameworks (.Net, .Net Compact, Mono, Windows Phone)
#else #else
IList<String> tmpTopics = new List<String>(); IList<String> tmpTopics = new List<String>();
IList<Byte> tmpQosLevels = new List<Byte>(); IList<byte> tmpQosLevels = new List<byte>();
#endif #endif
do { do
// topic name {
topicUtf8Length = (buffer[index++] << 8) & 0xFF00; // topic name
topicUtf8Length |= buffer[index++]; topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
topicUtf8 = new Byte[topicUtf8Length]; topicUtf8Length |= buffer[index++];
Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length); topicUtf8 = new byte[topicUtf8Length];
index += topicUtf8Length; Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8))); index += topicUtf8Length;
tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
// QoS level // QoS level
tmpQosLevels.Add(buffer[index++]); tmpQosLevels.Add(buffer[index++]);
} while (index < remainingLength); } while (index < remainingLength);
// copy from list to array // copy from list to array
msg.Topics = new String[tmpTopics.Count]; msg.topics = new string[tmpTopics.Count];
msg.QoSLevels = new Byte[tmpQosLevels.Count]; msg.qosLevels = new byte[tmpQosLevels.Count];
for (Int32 i = 0; i < tmpTopics.Count; i++) { for (int i = 0; i < tmpTopics.Count; i++)
msg.Topics[i] = (String)tmpTopics[i]; {
msg.QoSLevels[i] = (Byte)tmpQosLevels[i]; msg.topics[i] = (string)tmpTopics[i];
} msg.qosLevels[i] = (byte)tmpQosLevels[i];
}
return msg; return msg;
}
public override Byte[] GetBytes(Byte protocolVersion) {
Int32 varHeaderSize = 0;
Int32 payloadSize = 0;
Int32 remainingLength = 0;
Byte[] buffer;
Int32 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;
Byte[][] topicsUtf8 = new Byte[this.Topics.Length][];
Int32 topicIdx;
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]); public override byte[] GetBytes(byte protocolVersion)
payloadSize += 2; // topic size (MSB, LSB) {
payloadSize += topicsUtf8[topicIdx].Length; int fixedHeaderSize = 0;
payloadSize++; // byte for QoS int varHeaderSize = 0;
} int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
remainingLength += varHeaderSize + payloadSize; // topics list empty
if ((this.topics == null) || (this.topics.Length == 0))
throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
// first byte of fixed header // qos levels list empty
Int32 fixedHeaderSize = 1; if ((this.qosLevels == null) || (this.qosLevels.Length == 0))
throw new MqttClientException(MqttClientErrorCode.QosLevelsEmpty);
Int32 temp = remainingLength; // topics and qos levels lists length don't match
// increase fixed header size based on remaining length if (this.topics.Length != this.qosLevels.Length)
// (each remaining length byte can encode until 128) throw new MqttClientException(MqttClientErrorCode.TopicsQosLevelsNotMatch);
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message // message identifier
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize]; varHeaderSize += MESSAGE_ID_SIZE;
// first fixed header byte int topicIdx = 0;
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) { byte[][] topicsUtf8 = new byte[this.topics.Length][];
buffer[index++] = (MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBSCRIBE_FLAG_BITS; // [v.3.1.1]
} else {
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 for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
index = this.EncodeRemainingLength(remainingLength, buffer, index); {
// check topic length
if ((this.topics[topicIdx].Length < MIN_TOPIC_LENGTH) || (this.topics[topicIdx].Length > MAX_TOPIC_LENGTH))
throw new MqttClientException(MqttClientErrorCode.TopicLength);
// check message identifier assigned (SUBSCRIBE uses QoS Level 1, so message id is mandatory) topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.topics[topicIdx]);
if (this.MessageId == 0) { payloadSize += 2; // topic size (MSB, LSB)
throw new MqttClientException(MqttClientErrorCode.WrongMessageId); payloadSize += topicsUtf8[topicIdx].Length;
} payloadSize++; // byte for QoS
}
buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB remainingLength += (varHeaderSize + payloadSize);
buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB
for (topicIdx = 0; topicIdx < this.Topics.Length; topicIdx++) { // first byte of fixed header
// topic name fixedHeaderSize = 1;
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 int temp = remainingLength;
buffer[index++] = this.QoSLevels[topicIdx]; // increase fixed header size based on remaining length
} // (each remaining length byte can encode until 128)
do
{
fixedHeaderSize++;
temp = temp / 128;
} while (temp > 0);
return buffer; // allocate buffer for message
} buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
public override String ToString() => // first fixed header byte
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_SUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_SUBSCRIBE_FLAG_BITS; // [v.3.1.1]
else
{
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;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"SUBSCRIBE", "SUBSCRIBE",
new Object[] { "messageId", "topics", "qosLevels" }, new object[] { "messageId", "topics", "qosLevels" },
new Object[] { this.MessageId, this.Topics, this.QoSLevels }); new object[] { this.messageId, this.topics, this.qosLevels });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

82
M2Mqtt/Messages/MqttMsgSubscribeEventArgs.cs
View File

@ -14,48 +14,68 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for subscribe request on topics
/// </summary>
public class MqttMsgSubscribeEventArgs : EventArgs {
#region Properties...
/// <summary> /// <summary>
/// Message identifier /// Event Args class for subscribe request on topics
/// </summary> /// </summary>
public UInt16 MessageId { get; internal set; } public class MqttMsgSubscribeEventArgs : EventArgs
{
#region Properties...
/// <summary> /// <summary>
/// Topics requested to subscribe /// Message identifier
/// </summary> /// </summary>
public String[] Topics { get; internal set; } public ushort MessageId
{
get { return this.messageId; }
internal set { this.messageId = value; }
}
/// <summary> /// <summary>
/// List of QOS Levels requested /// Topics requested to subscribe
/// </summary> /// </summary>
public Byte[] QoSLevels { get; internal set; } public string[] Topics
{
get { return this.topics; }
internal set { this.topics = value; }
}
#endregion /// <summary>
/// List of QOS Levels requested
/// </summary>
public byte[] QoSLevels
{
get { return this.qosLevels; }
internal set { this.qosLevels = value; }
}
// message identifier #endregion
/// <summary> // message identifier
/// Constructor ushort messageId;
/// </summary> // topics requested to subscribe
/// <param name="messageId">Message identifier for subscribe topics request</param> string[] topics;
/// <param name="topics">Topics requested to subscribe</param> // QoS levels requested
/// <param name="qosLevels">List of QOS Levels requested</param> byte[] qosLevels;
public MqttMsgSubscribeEventArgs(UInt16 messageId, String[] topics, Byte[] qosLevels) {
this.MessageId = messageId; /// <summary>
this.Topics = topics; /// Constructor
this.QoSLevels = qosLevels; /// </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;
}
} }
}
} }

64
M2Mqtt/Messages/MqttMsgSubscribedEventArgs.cs
View File

@ -14,41 +14,55 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for subscribed topics
/// </summary>
public class MqttMsgSubscribedEventArgs : EventArgs {
#region Properties...
/// <summary> /// <summary>
/// Message identifier /// Event Args class for subscribed topics
/// </summary> /// </summary>
public UInt16 MessageId { get; internal set; } public class MqttMsgSubscribedEventArgs : EventArgs
{
#region Properties...
/// <summary> /// <summary>
/// List of granted QOS Levels /// Message identifier
/// </summary> /// </summary>
public Byte[] GrantedQoSLevels { get; internal set; } public ushort MessageId
{
get { return this.messageId; }
internal set { this.messageId = value; }
}
#endregion /// <summary>
/// List of granted QOS Levels
/// </summary>
public byte[] GrantedQoSLevels
{
get { return this.grantedQosLevels; }
internal set { this.grantedQosLevels = value; }
}
// message identifier #endregion
/// <summary> // message identifier
/// Constructor ushort messageId;
/// </summary> // granted QOS levels
/// <param name="messageId">Message identifier for subscribed topics</param> byte[] grantedQosLevels;
/// <param name="grantedQosLevels">List of granted QOS Levels</param>
public MqttMsgSubscribedEventArgs(UInt16 messageId, Byte[] grantedQosLevels) { /// <summary>
this.MessageId = messageId; /// Constructor
this.GrantedQoSLevels = grantedQosLevels; /// </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;
}
} }
}
} }

159
M2Mqtt/Messages/MqttMsgUnsuback.cs
View File

@ -17,99 +17,110 @@ Contributors:
using System; using System;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for UNSUBACK message from broker to client
/// </summary>
public class MqttMsgUnsuback : MqttMsgBase {
/// <summary> /// <summary>
/// Constructor /// Class for UNSUBACK message from broker to client
/// </summary> /// </summary>
public MqttMsgUnsuback() => this.Type = MQTT_MSG_UNSUBACK_TYPE; public class MqttMsgUnsuback : MqttMsgBase
{
/// <summary> /// <summary>
/// Parse bytes for a UNSUBACK message /// Constructor
/// </summary> /// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param> public MqttMsgUnsuback()
/// <param name="protocolVersion">Protocol Version</param> {
/// <param name="channel">Channel connected to the broker</param> this.type = MQTT_MSG_UNSUBACK_TYPE;
/// <returns>UNSUBACK message instance</returns>
public static MqttMsgUnsuback Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
MqttMsgUnsuback msg = new MqttMsgUnsuback();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBACK_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer /// <summary>
Int32 remainingLength = MqttMsgBase.DecodeRemainingLength(channel); /// Parse bytes for a UNSUBACK message
buffer = new Byte[remainingLength]; /// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>UNSUBACK message instance</returns>
public static MqttMsgUnsuback Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
MqttMsgUnsuback msg = new MqttMsgUnsuback();
// read bytes from socket... if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
_ = channel.Receive(buffer); {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBACK_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// message id // get remaining length and allocate buffer
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00); int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
msg.MessageId |= buffer[index++]; buffer = new byte[remainingLength];
return msg; // read bytes from socket...
} channel.Receive(buffer);
public override Byte[] GetBytes(Byte protocolVersion) { // message id
Int32 varHeaderSize = 0; msg.messageId = (ushort)((buffer[index++] << 8) & 0xFF00);
Int32 payloadSize = 0; msg.messageId |= (buffer[index++]);
Int32 remainingLength = 0;
Byte[] buffer;
Int32 index = 0;
// message identifier return msg;
varHeaderSize += MESSAGE_ID_SIZE; }
remainingLength += varHeaderSize + payloadSize; public override byte[] GetBytes(byte protocolVersion)
{
int fixedHeaderSize = 0;
int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
// first byte of fixed header // message identifier
Int32 fixedHeaderSize = 1; varHeaderSize += MESSAGE_ID_SIZE;
Int32 temp = remainingLength; remainingLength += (varHeaderSize + payloadSize);
// increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message // first byte of fixed header
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize]; fixedHeaderSize = 1;
// first fixed header byte int temp = remainingLength;
buffer[index++] = protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1 // increase fixed header size based on remaining length
? (Byte)((MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBACK_FLAG_BITS) // (each remaining length byte can encode until 128)
: (Byte)(MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET); do
{
fixedHeaderSize++;
temp = temp / 128;
} while (temp > 0);
// encode remaining length // allocate buffer for message
index = this.EncodeRemainingLength(remainingLength, buffer, index); buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
// message id // first fixed header byte
buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB buffer[index++] = (MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBACK_FLAG_BITS; // [v.3.1.1]
else
buffer[index++] = (byte)(MQTT_MSG_UNSUBACK_TYPE << MSG_TYPE_OFFSET);
return buffer; // encode remaining length
} index = this.encodeRemainingLength(remainingLength, buffer, index);
public override String ToString() => // message id
buffer[index++] = (byte)((this.messageId >> 8) & 0x00FF); // MSB
buffer[index++] = (byte)(this.messageId & 0x00FF); // LSB
return buffer;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"UNSUBACK", "UNSUBACK",
new Object[] { "messageId" }, new object[] { "messageId" },
new Object[] { this.MessageId }); new object[] { this.messageId });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

343
M2Mqtt/Messages/MqttMsgUnsubscribe.cs
View File

@ -16,205 +16,224 @@ Contributors:
using System; using System;
// if NOT .Net Micro Framework // if NOT .Net Micro Framework
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System.Collections.Generic; using System.Collections.Generic;
#endif #endif
using System.Collections; using System.Collections;
using System.Text; using System.Text;
using uPLibrary.Networking.M2Mqtt.Exceptions; using uPLibrary.Networking.M2Mqtt.Exceptions;
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Class for UNSUBSCRIBE message from client to broker
/// </summary>
public class MqttMsgUnsubscribe : MqttMsgBase {
#region Properties...
/// <summary> /// <summary>
/// List of topics to unsubscribe /// Class for UNSUBSCRIBE message from client to broker
/// </summary> /// </summary>
public String[] Topics { get; set; } public class MqttMsgUnsubscribe : MqttMsgBase
{
#region Properties...
#endregion /// <summary>
/// List of topics to unsubscribe
// topics to unsubscribe /// </summary>
public string[] Topics
/// <summary> {
/// Constructor get { return this.topics; }
/// </summary> set { this.topics = value; }
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 (not "officially" in 3.1.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="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>UNSUBSCRIBE message instance</returns>
public static MqttMsgUnsubscribe Parse(Byte fixedHeaderFirstByte, Byte protocolVersion, IMqttNetworkChannel channel) {
Byte[] buffer;
Int32 index = 0;
Byte[] topicUtf8;
Int32 topicUtf8Length;
MqttMsgUnsubscribe msg = new MqttMsgUnsubscribe();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) {
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBSCRIBE_FLAG_BITS) {
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
} }
}
// get remaining length and allocate buffer #endregion
Int32 remainingLength = DecodeRemainingLength(channel);
buffer = new Byte[remainingLength];
// read bytes from socket... // topics to unsubscribe
Int32 received = channel.Receive(buffer); string[] topics;
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1) { /// <summary>
// only 3.1.0 /// Constructor
/// </summary>
public MqttMsgUnsubscribe()
{
this.type = MQTT_MSG_UNSUBSCRIBE_TYPE;
}
// read QoS level from fixed header /// <summary>
msg.QosLevel = (Byte)((fixedHeaderFirstByte & QOS_LEVEL_MASK) >> QOS_LEVEL_OFFSET); /// Constructor
// read DUP flag from fixed header /// </summary>
msg.DupFlag = (fixedHeaderFirstByte & DUP_FLAG_MASK) >> DUP_FLAG_OFFSET == 0x01; /// <param name="topics">List of topics to unsubscribe</param>
// retain flag not used public MqttMsgUnsubscribe(string[] topics)
msg.Retain = false; {
} this.type = MQTT_MSG_UNSUBSCRIBE_TYPE;
// message id this.topics = topics;
msg.MessageId = (UInt16)((buffer[index++] << 8) & 0xFF00);
msg.MessageId |= buffer[index++];
// payload contains topics // UNSUBSCRIBE message uses QoS Level 1 (not "officially" in 3.1.1)
// NOTE : before, I don't know how many topics will be in the payload (so use List) this.qosLevel = QOS_LEVEL_AT_LEAST_ONCE;
}
// if .Net Micro Framework /// <summary>
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 /// Parse bytes for a UNSUBSCRIBE message
/// </summary>
/// <param name="fixedHeaderFirstByte">First fixed header byte</param>
/// <param name="protocolVersion">Protocol Version</param>
/// <param name="channel">Channel connected to the broker</param>
/// <returns>UNSUBSCRIBE message instance</returns>
public static MqttMsgUnsubscribe Parse(byte fixedHeaderFirstByte, byte protocolVersion, IMqttNetworkChannel channel)
{
byte[] buffer;
int index = 0;
byte[] topicUtf8;
int topicUtf8Length;
MqttMsgUnsubscribe msg = new MqttMsgUnsubscribe();
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
{
// [v3.1.1] check flag bits
if ((fixedHeaderFirstByte & MSG_FLAG_BITS_MASK) != MQTT_MSG_UNSUBSCRIBE_FLAG_BITS)
throw new MqttClientException(MqttClientErrorCode.InvalidFlagBits);
}
// get remaining length and allocate buffer
int remainingLength = MqttMsgBase.decodeRemainingLength(channel);
buffer = new byte[remainingLength];
// read bytes from socket...
int received = channel.Receive(buffer);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1)
{
// only 3.1.0
// 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(); IList tmpTopics = new ArrayList();
// else other frameworks (.Net, .Net Compact, Mono, Windows Phone) // else other frameworks (.Net, .Net Compact, Mono, Windows Phone)
#else #else
IList<String> tmpTopics = new List<String>(); IList<String> tmpTopics = new List<String>();
#endif #endif
do { do
// topic name {
topicUtf8Length = (buffer[index++] << 8) & 0xFF00; // topic name
topicUtf8Length |= buffer[index++]; topicUtf8Length = ((buffer[index++] << 8) & 0xFF00);
topicUtf8 = new Byte[topicUtf8Length]; topicUtf8Length |= buffer[index++];
Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length); topicUtf8 = new byte[topicUtf8Length];
index += topicUtf8Length; Array.Copy(buffer, index, topicUtf8, 0, topicUtf8Length);
tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8))); index += topicUtf8Length;
} while (index < remainingLength); tmpTopics.Add(new String(Encoding.UTF8.GetChars(topicUtf8)));
} while (index < remainingLength);
// copy from list to array // copy from list to array
msg.Topics = new String[tmpTopics.Count]; msg.topics = new string[tmpTopics.Count];
for (Int32 i = 0; i < tmpTopics.Count; i++) { for (int i = 0; i < tmpTopics.Count; i++)
msg.Topics[i] = (String)tmpTopics[i]; {
} msg.topics[i] = (string)tmpTopics[i];
}
return msg; return msg;
}
public override Byte[] GetBytes(Byte protocolVersion) {
Int32 varHeaderSize = 0;
Int32 payloadSize = 0;
Int32 remainingLength = 0;
Byte[] buffer;
Int32 index = 0;
// topics list empty
if (this.Topics == null || this.Topics.Length == 0) {
throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
}
// message identifier
varHeaderSize += MESSAGE_ID_SIZE;
Byte[][] topicsUtf8 = new Byte[this.Topics.Length][];
Int32 topicIdx;
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]); public override byte[] GetBytes(byte protocolVersion)
payloadSize += 2; // topic size (MSB, LSB) {
payloadSize += topicsUtf8[topicIdx].Length; int fixedHeaderSize = 0;
} int varHeaderSize = 0;
int payloadSize = 0;
int remainingLength = 0;
byte[] buffer;
int index = 0;
remainingLength += varHeaderSize + payloadSize; // topics list empty
if ((this.topics == null) || (this.topics.Length == 0))
throw new MqttClientException(MqttClientErrorCode.TopicsEmpty);
// first byte of fixed header // message identifier
Int32 fixedHeaderSize = 1; varHeaderSize += MESSAGE_ID_SIZE;
Int32 temp = remainingLength; int topicIdx = 0;
// increase fixed header size based on remaining length byte[][] topicsUtf8 = new byte[this.topics.Length][];
// (each remaining length byte can encode until 128)
do {
fixedHeaderSize++;
temp /= 128;
} while (temp > 0);
// allocate buffer for message for (topicIdx = 0; topicIdx < this.topics.Length; topicIdx++)
buffer = new Byte[fixedHeaderSize + varHeaderSize + payloadSize]; {
// check topic length
if ((this.topics[topicIdx].Length < MIN_TOPIC_LENGTH) || (this.topics[topicIdx].Length > MAX_TOPIC_LENGTH))
throw new MqttClientException(MqttClientErrorCode.TopicLength);
// first fixed header byte topicsUtf8[topicIdx] = Encoding.UTF8.GetBytes(this.topics[topicIdx]);
if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1) { payloadSize += 2; // topic size (MSB, LSB)
buffer[index++] = (MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBSCRIBE_FLAG_BITS; // [v.3.1.1] payloadSize += topicsUtf8[topicIdx].Length;
} else { }
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 remainingLength += (varHeaderSize + payloadSize);
index = this.EncodeRemainingLength(remainingLength, buffer, index);
// check message identifier assigned // first byte of fixed header
if (this.MessageId == 0) { fixedHeaderSize = 1;
throw new MqttClientException(MqttClientErrorCode.WrongMessageId);
}
buffer[index++] = (Byte)((this.MessageId >> 8) & 0x00FF); // MSB int temp = remainingLength;
buffer[index++] = (Byte)(this.MessageId & 0x00FF); // LSB // increase fixed header size based on remaining length
// (each remaining length byte can encode until 128)
do
{
fixedHeaderSize++;
temp = temp / 128;
} while (temp > 0);
for (topicIdx = 0; topicIdx < this.Topics.Length; topicIdx++) { // allocate buffer for message
// topic name buffer = new byte[fixedHeaderSize + varHeaderSize + payloadSize];
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; // first fixed header byte
} if (protocolVersion == MqttMsgConnect.PROTOCOL_VERSION_V3_1_1)
buffer[index++] = (MQTT_MSG_UNSUBSCRIBE_TYPE << MSG_TYPE_OFFSET) | MQTT_MSG_UNSUBSCRIBE_FLAG_BITS; // [v.3.1.1]
else
{
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++;
}
public override String ToString() => // 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;
}
public override string ToString()
{
#if TRACE #if TRACE
this.GetTraceString( return this.GetTraceString(
"UNSUBSCRIBE", "UNSUBSCRIBE",
new Object[] { "messageId", "topics" }, new object[] { "messageId", "topics" },
new Object[] { this.MessageId, this.Topics }); new object[] { this.messageId, this.topics });
#else #else
base.ToString(); return base.ToString();
#endif #endif
}
} }
} }

64
M2Mqtt/Messages/MqttMsgUnsubscribeEventArgs.cs
View File

@ -14,41 +14,55 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for unsubscribe request on topics
/// </summary>
public class MqttMsgUnsubscribeEventArgs : EventArgs {
#region Properties...
/// <summary> /// <summary>
/// Message identifier /// Event Args class for unsubscribe request on topics
/// </summary> /// </summary>
public UInt16 MessageId { get; internal set; } public class MqttMsgUnsubscribeEventArgs : EventArgs
{
#region Properties...
/// <summary> /// <summary>
/// Topics requested to subscribe /// Message identifier
/// </summary> /// </summary>
public String[] Topics { get; internal set; } public ushort MessageId
{
get { return this.messageId; }
internal set { this.messageId = value; }
}
#endregion /// <summary>
/// Topics requested to subscribe
/// </summary>
public string[] Topics
{
get { return this.topics; }
internal set { this.topics = value; }
}
// message identifier #endregion
/// <summary> // message identifier
/// Constructor ushort messageId;
/// </summary> // topics requested to unsubscribe
/// <param name="messageId">Message identifier for subscribed topics</param> string[] topics;
/// <param name="topics">Topics requested to subscribe</param>
public MqttMsgUnsubscribeEventArgs(UInt16 messageId, String[] topics) { /// <summary>
this.MessageId = messageId; /// Constructor
this.Topics = topics; /// </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;
}
} }
}
} }

46
M2Mqtt/Messages/MqttMsgUnsubscribedEventArgs.cs
View File

@ -14,32 +14,42 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
using System; using System;
#else #else
using Microsoft.SPOT; using Microsoft.SPOT;
#endif #endif
namespace uPLibrary.Networking.M2Mqtt.Messages { namespace uPLibrary.Networking.M2Mqtt.Messages
/// <summary> {
/// Event Args class for unsubscribed topic
/// </summary>
public class MqttMsgUnsubscribedEventArgs : EventArgs {
#region Properties...
/// <summary> /// <summary>
/// Message identifier /// Event Args class for unsubscribed topic
/// </summary> /// </summary>
public UInt16 MessageId { get; internal set; } public class MqttMsgUnsubscribedEventArgs : EventArgs
{
#region Properties...
#endregion /// <summary>
/// Message identifier
/// </summary>
public ushort MessageId
{
get { return this.messageId; }
internal set { this.messageId = value; }
}
// message identifier #endregion
/// <summary> // message identifier
/// Constructor ushort messageId;
/// </summary>
/// <param name="messageId">Message identifier for unsubscribed topic</param> /// <summary>
public MqttMsgUnsubscribedEventArgs(UInt16 messageId) => this.MessageId = messageId; /// Constructor
} /// </summary>
/// <param name="messageId">Message identifier for unsubscribed topic</param>
public MqttMsgUnsubscribedEventArgs(ushort messageId)
{
this.messageId = messageId;
}
}
} }

3456
M2Mqtt/MqttClient.cs
View File

File diff suppressed because it is too large Load Diff

24
M2Mqtt/MqttSecurity.cs
View File

@ -14,15 +14,17 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
namespace uPLibrary.Networking.M2Mqtt { namespace uPLibrary.Networking.M2Mqtt
/// <summary> {
/// Supported SSL/TLS protocol versions /// <summary>
/// </summary> /// Supported SSL/TLS protocol versions
public enum MqttSslProtocols { /// </summary>
None, public enum MqttSslProtocols
SSLv3, {
TLSv1_0, None,
TLSv1_1, SSLv3,
TLSv1_2 TLSv1_0,
} TLSv1_1,
TLSv1_2
}
} }

147
M2Mqtt/MqttSettings.cs
View File

@ -14,90 +14,91 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System; namespace uPLibrary.Networking.M2Mqtt
{
namespace uPLibrary.Networking.M2Mqtt {
/// <summary>
/// Settings class for the MQTT broker
/// </summary>
public class MqttSettings {
// default port for MQTT protocol
public const Int32 MQTT_BROKER_DEFAULT_PORT = 1883;
public const Int32 MQTT_BROKER_DEFAULT_SSL_PORT = 8883;
// default timeout on receiving from client
public const Int32 MQTT_DEFAULT_TIMEOUT = 30000;
// max publish, subscribe and unsubscribe retry for QoS Level 1 or 2
public const Int32 MQTT_ATTEMPTS_RETRY = 3;
// delay for retry publish, subscribe and unsubscribe for QoS Level 1 or 2
public const Int32 MQTT_DELAY_RETRY = 10000;
// broker need to receive the first message (CONNECT)
// within a reasonable amount of time after TCP/IP connection
public const Int32 MQTT_CONNECT_TIMEOUT = 30000;
// default inflight queue size
public const Int32 MQTT_MAX_INFLIGHT_QUEUE_SIZE = Int32.MaxValue;
/// <summary> /// <summary>
/// Listening connection port /// Settings class for the MQTT broker
/// </summary> /// </summary>
public Int32 Port { get; internal set; } public class MqttSettings
{
// default port for MQTT protocol
public const int MQTT_BROKER_DEFAULT_PORT = 1883;
public const int MQTT_BROKER_DEFAULT_SSL_PORT = 8883;
// default timeout on receiving from client
public const int MQTT_DEFAULT_TIMEOUT = 30000;
// max publish, subscribe and unsubscribe retry for QoS Level 1 or 2
public const int MQTT_ATTEMPTS_RETRY = 3;
// delay for retry publish, subscribe and unsubscribe for QoS Level 1 or 2
public const int MQTT_DELAY_RETRY = 10000;
// broker need to receive the first message (CONNECT)
// within a reasonable amount of time after TCP/IP connection
public const int MQTT_CONNECT_TIMEOUT = 30000;
// default inflight queue size
public const int MQTT_MAX_INFLIGHT_QUEUE_SIZE = int.MaxValue;
/// <summary> /// <summary>
/// Listening connection SSL port /// Listening connection port
/// </summary> /// </summary>
public Int32 SslPort { get; internal set; } public int Port { get; internal set; }
/// <summary> /// <summary>
/// Timeout on client connection (before receiving CONNECT message) /// Listening connection SSL port
/// </summary> /// </summary>
public Int32 TimeoutOnConnection { get; internal set; } public int SslPort { get; internal set; }
/// <summary> /// <summary>
/// Timeout on receiving /// Timeout on client connection (before receiving CONNECT message)
/// </summary> /// </summary>
public Int32 TimeoutOnReceiving { get; internal set; } public int TimeoutOnConnection { get; internal set; }
/// <summary> /// <summary>
/// Attempts on retry /// Timeout on receiving
/// </summary> /// </summary>
public Int32 AttemptsOnRetry { get; internal set; } public int TimeoutOnReceiving { get; internal set; }
/// <summary> /// <summary>
/// Delay on retry /// Attempts on retry
/// </summary> /// </summary>
public Int32 DelayOnRetry { get; internal set; } public int AttemptsOnRetry { get; internal set; }
/// <summary> /// <summary>
/// Inflight queue size /// Delay on retry
/// </summary> /// </summary>
public Int32 InflightQueueSize { get; set; } public int DelayOnRetry { get; internal set; }
/// <summary> /// <summary>
/// Singleton instance of settings /// Inflight queue size
/// </summary> /// </summary>
public static MqttSettings Instance { public int InflightQueueSize { get; set; }
get {
if (instance == null) { /// <summary>
instance = new MqttSettings(); /// Singleton instance of settings
/// </summary>
public static MqttSettings Instance
{
get
{
if (instance == null)
instance = new MqttSettings();
return instance;
}
} }
return instance; // singleton instance
} private static MqttSettings instance;
}
// singleton instance /// <summary>
private static MqttSettings instance; /// Constructor
/// </summary>
/// <summary> private MqttSettings()
/// Constructor {
/// </summary> this.Port = MQTT_BROKER_DEFAULT_PORT;
private MqttSettings() { this.SslPort = MQTT_BROKER_DEFAULT_SSL_PORT;
this.Port = MQTT_BROKER_DEFAULT_PORT; this.TimeoutOnReceiving = MQTT_DEFAULT_TIMEOUT;
this.SslPort = MQTT_BROKER_DEFAULT_SSL_PORT; this.AttemptsOnRetry = MQTT_ATTEMPTS_RETRY;
this.TimeoutOnReceiving = MQTT_DEFAULT_TIMEOUT; this.DelayOnRetry = MQTT_DELAY_RETRY;
this.AttemptsOnRetry = MQTT_ATTEMPTS_RETRY; this.TimeoutOnConnection = MQTT_CONNECT_TIMEOUT;
this.DelayOnRetry = MQTT_DELAY_RETRY; this.InflightQueueSize = MQTT_MAX_INFLIGHT_QUEUE_SIZE;
this.TimeoutOnConnection = MQTT_CONNECT_TIMEOUT; }
this.InflightQueueSize = MQTT_MAX_INFLIGHT_QUEUE_SIZE;
} }
}
} }

25
M2Mqtt/Net/Fx.cs
View File

@ -14,16 +14,23 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using System.Threading; using System.Threading;
namespace uPLibrary.Networking.M2Mqtt { namespace uPLibrary.Networking.M2Mqtt
/// <summary> {
/// Support methods fos specific framework /// <summary>
/// </summary> /// Support methods fos specific framework
public class Fx { /// </summary>
public static void StartThread(ThreadStart threadStart) => new Thread(threadStart).Start(); public class Fx
{
public static void StartThread(ThreadStart threadStart)
{
new Thread(threadStart).Start();
}
public static void SleepThread(Int32 millisecondsTimeout) => Thread.Sleep(millisecondsTimeout); public static void SleepThread(int millisecondsTimeout)
} {
Thread.Sleep(millisecondsTimeout);
}
}
} }

585
M2Mqtt/Net/MqttNetworkChannel.cs
View File

@ -15,17 +15,13 @@ Contributors:
*/ */
#if SSL #if SSL
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 #if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
using Microsoft.SPOT.Net.Security; using Microsoft.SPOT.Net.Security;
#else #else
using System.Security.Authentication;
#if NETCOREAPP
using System.Net.Security; using System.Net.Security;
#endif using System.Security.Authentication;
#endif #endif
#endif #endif
using System.Net.Sockets; using System.Net.Sockets;
using System.Net; using System.Net;
using System.Security.Cryptography.X509Certificates; using System.Security.Cryptography.X509Certificates;
@ -33,74 +29,90 @@ using System;
//using System.Security.Authentication; //using System.Security.Authentication;
//using System.Net.Security; //using System.Net.Security;
namespace uPLibrary.Networking.M2Mqtt { namespace uPLibrary.Networking.M2Mqtt
/// <summary> {
/// Channel to communicate over the network /// <summary>
/// </summary> /// Channel to communicate over the network
public class MqttNetworkChannel : IMqttNetworkChannel { /// </summary>
public class MqttNetworkChannel : IMqttNetworkChannel
{
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
private readonly RemoteCertificateValidationCallback userCertificateValidationCallback; private readonly RemoteCertificateValidationCallback userCertificateValidationCallback;
private readonly LocalCertificateSelectionCallback userCertificateSelectionCallback; private readonly LocalCertificateSelectionCallback userCertificateSelectionCallback;
#endif #endif
// remote host information // remote host information
private string remoteHostName;
private IPAddress remoteIpAddress;
private int remotePort;
// socket for communication // socket for communication
private Socket socket; private Socket socket;
// using SSL // using SSL
private readonly Boolean secure; private bool secure;
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
// CA certificate (on client)
private readonly X509Certificate caCert;
#endif
// Server certificate (on broker)
private readonly X509Certificate serverCert;
// client certificate (on client)
private readonly X509Certificate clientCert;
// SSL/TLS protocol version // CA certificate (on client)
private readonly MqttSslProtocols sslProtocol; private X509Certificate caCert;
// Server certificate (on broker)
private X509Certificate serverCert;
// client certificate (on client)
private X509Certificate clientCert;
/// <summary> // SSL/TLS protocol version
/// Remote host name private MqttSslProtocols sslProtocol;
/// </summary>
public String RemoteHostName { get; }
/// <summary> /// <summary>
/// Remote IP address /// Remote host name
/// </summary> /// </summary>
public IPAddress RemoteIpAddress { get; } public string RemoteHostName { get { return this.remoteHostName; } }
/// <summary> /// <summary>
/// Remote port /// Remote IP address
/// </summary> /// </summary>
public Int32 RemotePort { get; } public IPAddress RemoteIpAddress { get { return this.remoteIpAddress; } }
/// <summary>
/// Remote port
/// </summary>
public int RemotePort { get { return this.remotePort; } }
#if SSL #if SSL
// SSL stream // SSL stream
private SslStream sslStream; private SslStream sslStream;
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
private NetworkStream netStream; private NetworkStream netStream;
#endif #endif
#endif #endif
/// <summary> /// <summary>
/// Data available on the channel /// Data available on the channel
/// </summary> /// </summary>
public bool DataAvailable
{
get
{
#if SSL #if SSL
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 #if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
public Boolean DataAvailable => this.secure ? this.sslStream.DataAvailable : this.socket.Available > 0; if (secure)
return this.sslStream.DataAvailable;
else
return (this.socket.Available > 0);
#else #else
public Boolean DataAvailable => this.secure ? this.netStream.DataAvailable : this.socket.Available > 0; if (secure)
return this.netStream.DataAvailable;
else
return (this.socket.Available > 0);
#endif #endif
#else #else
public Boolean DataAvailable => this.socket.Available > 0; return (this.socket.Available > 0);
#endif #endif
}
}
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
/// <param name="socket">Socket opened with the client</param> /// <param name="socket">Socket opened with the client</param>
public MqttNetworkChannel(Socket socket) public MqttNetworkChannel(Socket socket)
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
: this(socket, false, null, MqttSslProtocols.None, null, null) : this(socket, false, null, MqttSslProtocols.None, null, null)
#else #else
@ -108,205 +120,212 @@ namespace uPLibrary.Networking.M2Mqtt {
#endif #endif
{ {
} }
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
/// <param name="socket">Socket opened with the client</param> /// <param name="socket">Socket opened with the client</param>
/// <param name="secure">Secure connection (SSL/TLS)</param> /// <param name="secure">Secure connection (SSL/TLS)</param>
/// <param name="serverCert">Server X509 certificate for secure connection</param> /// <param name="serverCert">Server X509 certificate for secure connection</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param> /// <param name="sslProtocol">SSL/TLS protocol version</param>
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
/// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param> /// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param>
/// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param> /// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param>
public MqttNetworkChannel(Socket socket, Boolean secure, X509Certificate serverCert, MqttSslProtocols sslProtocol, public MqttNetworkChannel(Socket socket, bool secure, X509Certificate serverCert, MqttSslProtocols sslProtocol,
RemoteCertificateValidationCallback userCertificateValidationCallback, RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback) LocalCertificateSelectionCallback userCertificateSelectionCallback)
#else #else
public MqttNetworkChannel(Socket socket, bool secure, X509Certificate serverCert, MqttSslProtocols sslProtocol) public MqttNetworkChannel(Socket socket, bool secure, X509Certificate serverCert, MqttSslProtocols sslProtocol)
#endif #endif
{ {
this.socket = socket; this.socket = socket;
this.secure = secure; this.secure = secure;
this.serverCert = serverCert; this.serverCert = serverCert;
this.sslProtocol = sslProtocol; this.sslProtocol = sslProtocol;
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
this.userCertificateValidationCallback = userCertificateValidationCallback; this.userCertificateValidationCallback = userCertificateValidationCallback;
this.userCertificateSelectionCallback = userCertificateSelectionCallback; this.userCertificateSelectionCallback = userCertificateSelectionCallback;
#endif #endif
} }
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
/// <param name="remoteHostName">Remote Host name</param> /// <param name="remoteHostName">Remote Host name</param>
/// <param name="remotePort">Remote port</param> /// <param name="remotePort">Remote port</param>
public MqttNetworkChannel(String remoteHostName, Int32 remotePort) public MqttNetworkChannel(string remoteHostName, int remotePort)
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
: this(remoteHostName, remotePort, false, null, null, MqttSslProtocols.None, null, null) : this(remoteHostName, remotePort, false, null, null, MqttSslProtocols.None, null, null)
#else #else
: this(remoteHostName, remotePort, false, null, null, MqttSslProtocols.None) : this(remoteHostName, remotePort, false, null, null, MqttSslProtocols.None)
#endif #endif
{ {
} }
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
/// <param name="remoteHostName">Remote Host name</param> /// <param name="remoteHostName">Remote Host name</param>
/// <param name="remotePort">Remote port</param> /// <param name="remotePort">Remote port</param>
/// <param name="secure">Using SSL</param> /// <param name="secure">Using SSL</param>
/// <param name="caCert">CA certificate</param> /// <param name="caCert">CA certificate</param>
/// <param name="clientCert">Client certificate</param> /// <param name="clientCert">Client certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param> /// <param name="sslProtocol">SSL/TLS protocol version</param>
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
/// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param> /// <param name="userCertificateSelectionCallback">A RemoteCertificateValidationCallback delegate responsible for validating the certificate supplied by the remote party</param>
/// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param> /// <param name="userCertificateValidationCallback">A LocalCertificateSelectionCallback delegate responsible for selecting the certificate used for authentication</param>
public MqttNetworkChannel(String remoteHostName, Int32 remotePort, Boolean secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol, public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol,
RemoteCertificateValidationCallback userCertificateValidationCallback, RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback) LocalCertificateSelectionCallback userCertificateSelectionCallback)
#else #else
public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol) public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol)
#endif #endif
{ {
IPAddress remoteIpAddress = null; IPAddress remoteIpAddress = null;
try { try
// check if remoteHostName is a valid IP address and get it {
remoteIpAddress = IPAddress.Parse(remoteHostName); // check if remoteHostName is a valid IP address and get it
} catch { remoteIpAddress = IPAddress.Parse(remoteHostName);
} }
catch
{
}
// in this case the parameter remoteHostName isn't a valid IP address // in this case the parameter remoteHostName isn't a valid IP address
if (remoteIpAddress == null) { if (remoteIpAddress == null)
IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName); {
if (hostEntry != null && hostEntry.AddressList.Length > 0) { IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName);
// check for the first address not null if ((hostEntry != null) && (hostEntry.AddressList.Length > 0))
// it seems that with .Net Micro Framework, the IPV6 addresses aren't supported and return "null" {
Int32 i = 0; // check for the first address not null
while (hostEntry.AddressList[i] == null) { // it seems that with .Net Micro Framework, the IPV6 addresses aren't supported and return "null"
i++; int i = 0;
} while (hostEntry.AddressList[i] == null) i++;
remoteIpAddress = hostEntry.AddressList[i];
}
else
{
throw new Exception("No address found for the remote host name");
}
}
remoteIpAddress = hostEntry.AddressList[i]; this.remoteHostName = remoteHostName;
} else { this.remoteIpAddress = remoteIpAddress;
throw new Exception("No address found for the remote host name"); this.remotePort = remotePort;
} this.secure = secure;
} this.caCert = caCert;
this.clientCert = clientCert;
this.RemoteHostName = remoteHostName; this.sslProtocol = sslProtocol;
this.RemoteIpAddress = remoteIpAddress;
this.RemotePort = remotePort;
this.secure = secure;
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3
this.caCert = caCert;
#endif
this.clientCert = clientCert;
this.sslProtocol = sslProtocol;
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
this.userCertificateValidationCallback = userCertificateValidationCallback; this.userCertificateValidationCallback = userCertificateValidationCallback;
this.userCertificateSelectionCallback = userCertificateSelectionCallback; this.userCertificateSelectionCallback = userCertificateSelectionCallback;
#endif #endif
} }
/// <summary> /// <summary>
/// Connect to remote server /// Connect to remote server
/// </summary> /// </summary>
public void Connect() { public void Connect()
this.socket = new Socket(IPAddressUtility.GetAddressFamily(this.RemoteIpAddress), SocketType.Stream, ProtocolType.Tcp); {
// try connection to the broker this.socket = new Socket(IPAddressUtility.GetAddressFamily(this.remoteIpAddress), SocketType.Stream, ProtocolType.Tcp);
this.socket.Connect(new IPEndPoint(this.RemoteIpAddress, this.RemotePort)); // try connection to the broker
this.socket.Connect(new IPEndPoint(this.remoteIpAddress, this.remotePort));
#if SSL #if SSL
// secure channel requested // secure channel requested
if (this.secure) { if (secure)
// create SSL stream {
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 // create SSL stream
#if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
this.sslStream = new SslStream(this.socket); this.sslStream = new SslStream(this.socket);
#else #else
this.netStream = new NetworkStream(this.socket); this.netStream = new NetworkStream(this.socket);
this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback); this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback);
#endif #endif
// server authentication (SSL/TLS handshake) // server authentication (SSL/TLS handshake)
#if MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 #if (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
this.sslStream.AuthenticateAsClient(this.remoteHostName, this.sslStream.AuthenticateAsClient(this.remoteHostName,
this.clientCert, this.clientCert,
new X509Certificate[] { this.caCert }, new X509Certificate[] { this.caCert },
SslVerification.CertificateRequired, SslVerification.CertificateRequired,
MqttSslUtility.ToSslPlatformEnum(this.sslProtocol)); MqttSslUtility.ToSslPlatformEnum(this.sslProtocol));
#else #else
X509CertificateCollection clientCertificates = null; X509CertificateCollection clientCertificates = null;
// check if there is a client certificate to add to the collection, otherwise it's null (as empty) // check if there is a client certificate to add to the collection, otherwise it's null (as empty)
if (this.clientCert != null) { if (this.clientCert != null)
clientCertificates = new X509CertificateCollection(new X509Certificate[] { this.clientCert }); clientCertificates = new X509CertificateCollection(new X509Certificate[] { this.clientCert });
this.sslStream.AuthenticateAsClient(this.remoteHostName,
clientCertificates,
MqttSslUtility.ToSslPlatformEnum(this.sslProtocol),
false);
#endif
}
#endif
} }
this.sslStream.AuthenticateAsClient(this.RemoteHostName, /// <summary>
clientCertificates, /// Send data on the network channel
MqttSslUtility.ToSslPlatformEnum(this.sslProtocol), /// </summary>
false); /// <param name="buffer">Data buffer to send</param>
/// <returns>Number of byte sent</returns>
#endif public int Send(byte[] buffer)
} {
#endif
}
/// <summary>
/// Send data on the network channel
/// </summary>
/// <param name="buffer">Data buffer to send</param>
/// <returns>Number of byte sent</returns>
public Int32 Send(Byte[] buffer) {
#if SSL #if SSL
if (this.secure) { if (this.secure)
this.sslStream.Write(buffer, 0, buffer.Length); {
this.sslStream.Flush(); this.sslStream.Write(buffer, 0, buffer.Length);
return buffer.Length; this.sslStream.Flush();
} else { return buffer.Length;
return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None); }
} else
return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None);
#else #else
return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None); return this.socket.Send(buffer, 0, buffer.Length, SocketFlags.None);
#endif #endif
} }
/// <summary> /// <summary>
/// Receive data from the network /// Receive data from the network
/// </summary> /// </summary>
/// <param name="buffer">Data buffer for receiving data</param> /// <param name="buffer">Data buffer for receiving data</param>
/// <returns>Number of bytes received</returns> /// <returns>Number of bytes received</returns>
public Int32 Receive(Byte[] buffer) { public int Receive(byte[] buffer)
{
#if SSL #if SSL
if (this.secure) { if (this.secure)
// read all data needed (until fill buffer) {
Int32 idx = 0, read = 0; // read all data needed (until fill buffer)
while (idx < buffer.Length) { int idx = 0, read = 0;
// fixed scenario with socket closed gracefully by peer/broker and while (idx < buffer.Length)
// Read return 0. Avoid infinite loop. {
read = this.sslStream.Read(buffer, idx, buffer.Length - idx); // fixed scenario with socket closed gracefully by peer/broker and
if (read == 0) { // Read return 0. Avoid infinite loop.
return 0; read = this.sslStream.Read(buffer, idx, buffer.Length - idx);
} if (read == 0)
return 0;
idx += read; idx += read;
} }
return buffer.Length; return buffer.Length;
} else { }
// read all data needed (until fill buffer) else
Int32 idx = 0, read = 0; {
while (idx < buffer.Length) { // read all data needed (until fill buffer)
// fixed scenario with socket closed gracefully by peer/broker and int idx = 0, read = 0;
// Read return 0. Avoid infinite loop. while (idx < buffer.Length)
read = this.socket.Receive(buffer, idx, buffer.Length - idx, SocketFlags.None); {
if (read == 0) { // fixed scenario with socket closed gracefully by peer/broker and
return 0; // Read return 0. Avoid infinite loop.
} read = this.socket.Receive(buffer, idx, buffer.Length - idx, SocketFlags.None);
if (read == 0)
idx += read; return 0;
} idx += read;
return buffer.Length; }
} return buffer.Length;
}
#else #else
// read all data needed (until fill buffer) // read all data needed (until fill buffer)
int idx = 0, read = 0; int idx = 0, read = 0;
@ -321,94 +340,118 @@ namespace uPLibrary.Networking.M2Mqtt {
} }
return buffer.Length; return buffer.Length;
#endif #endif
} }
/// <summary> /// <summary>
/// Receive data from the network channel with a specified timeout /// Receive data from the network channel with a specified timeout
/// </summary> /// </summary>
/// <param name="buffer">Data buffer for receiving data</param> /// <param name="buffer">Data buffer for receiving data</param>
/// <param name="timeout">Timeout on receiving (in milliseconds)</param> /// <param name="timeout">Timeout on receiving (in milliseconds)</param>
/// <returns>Number of bytes received</returns> /// <returns>Number of bytes received</returns>
public Int32 Receive(Byte[] buffer, Int32 timeout) => public int Receive(byte[] buffer, int timeout)
// check data availability (timeout is in microseconds) {
this.socket.Poll(timeout * 1000, SelectMode.SelectRead) ? this.Receive(buffer) : 0; // check data availability (timeout is in microseconds)
if (this.socket.Poll(timeout * 1000, SelectMode.SelectRead))
{
return this.Receive(buffer);
}
else
{
return 0;
}
}
/// <summary> /// <summary>
/// Close the network channel /// Close the network channel
/// </summary> /// </summary>
public void Close() { public void Close()
{
#if SSL #if SSL
if (this.secure) { if (this.secure)
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 {
this.netStream.Close(); #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
this.netStream.Close();
#endif #endif
this.sslStream.Close(); this.sslStream.Close();
} }
this.socket.Close(); this.socket.Close();
#else #else
this.socket.Close(); this.socket.Close();
#endif #endif
} }
/// <summary> /// <summary>
/// Accept connection from a remote client /// Accept connection from a remote client
/// </summary> /// </summary>
public void Accept() { public void Accept()
{
#if SSL #if SSL
// secure channel requested // secure channel requested
if (this.secure) { if (secure)
{
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3) #if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
this.netStream = new NetworkStream(this.socket); this.netStream = new NetworkStream(this.socket);
this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback); this.sslStream = new SslStream(this.netStream, false, this.userCertificateValidationCallback, this.userCertificateSelectionCallback);
this.sslStream.AuthenticateAsServer(this.serverCert, false, MqttSslUtility.ToSslPlatformEnum(this.sslProtocol), false); this.sslStream.AuthenticateAsServer(this.serverCert, false, MqttSslUtility.ToSslPlatformEnum(this.sslProtocol), false);
#endif #endif
} }
return; return;
#else #else
return; return;
#endif #endif
}
} }
}
/// <summary>
/// IPAddress Utility class
/// </summary>
public static class IPAddressUtility {
/// <summary> /// <summary>
/// Return AddressFamily for the IP address /// IPAddress Utility class
/// </summary> /// </summary>
/// <param name="ipAddress">IP address to check</param> public static class IPAddressUtility
/// <returns>Address family</returns> {
public static AddressFamily GetAddressFamily(IPAddress ipAddress) => /// <summary>
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 /// Return AddressFamily for the IP address
ipAddress.AddressFamily; /// </summary>
/// <param name="ipAddress">IP address to check</param>
/// <returns>Address family</returns>
public static AddressFamily GetAddressFamily(IPAddress ipAddress)
{
#if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3)
return ipAddress.AddressFamily;
#else #else
return (ipAddress.ToString().IndexOf(':') != -1) ? return (ipAddress.ToString().IndexOf(':') != -1) ?
AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork; AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork;
#endif #endif
}
}
} /// <summary>
/// MQTT SSL utility class
/// <summary> /// </summary>
/// MQTT SSL utility class public static class MqttSslUtility
/// </summary>
public static class MqttSslUtility {
#if !MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 && !COMPACT_FRAMEWORK
public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol) => mqttSslProtocol switch
{ {
MqttSslProtocols.None => SslProtocols.None, #if (!MF_FRAMEWORK_VERSION_V4_2 && !MF_FRAMEWORK_VERSION_V4_3 && !COMPACT_FRAMEWORK)
//MqttSslProtocols.SSLv3 => SslProtocols.Ssl3, public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
MqttSslProtocols.TLSv1_0 => SslProtocols.Tls, {
MqttSslProtocols.TLSv1_1 => SslProtocols.Tls11, switch (mqttSslProtocol)
MqttSslProtocols.TLSv1_2 => SslProtocols.Tls12, {
_ => throw new ArgumentException("SSL/TLS protocol version not supported"), case MqttSslProtocols.None:
}; return SslProtocols.None;
#elif MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 case MqttSslProtocols.SSLv3:
public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol) return SslProtocols.Ssl3;
case MqttSslProtocols.TLSv1_0:
return SslProtocols.Tls;
/*case MqttSslProtocols.TLSv1_1:
return SslProtocols.Tls11;
case MqttSslProtocols.TLSv1_2:
return SslProtocols.Tls12;*/
default:
throw new ArgumentException("SSL/TLS protocol version not supported");
}
}
#elif (MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3)
public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
{ {
switch (mqttSslProtocol) switch (mqttSslProtocol)
{ {
@ -425,5 +468,5 @@ namespace uPLibrary.Networking.M2Mqtt {
} }
} }
#endif #endif
} }
} }

3
M2Mqtt/Properties/AssemblyInfo.cs
View File

@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
Contributors: Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !NETCOREAPP
using System.Reflection; using System.Reflection;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
@ -42,4 +42,3 @@ using System.Runtime.InteropServices;
#if !WindowsCE #if !WindowsCE
[assembly: AssemblyFileVersion("4.3.0.0")] [assembly: AssemblyFileVersion("4.3.0.0")]
#endif #endif
#endif

24
M2Mqtt/Session/MqttClientSession.cs
View File

@ -14,18 +14,20 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System; namespace uPLibrary.Networking.M2Mqtt.Session
{
namespace uPLibrary.Networking.M2Mqtt.Session {
/// <summary>
/// MQTT Client Session
/// </summary>
public class MqttClientSession : MqttSession {
/// <summary> /// <summary>
/// Constructor /// MQTT Client Session
/// </summary> /// </summary>
/// <param name="clientId">Client Id to create session</param> public class MqttClientSession : MqttSession
public MqttClientSession(String clientId) : base(clientId) { {
/// <summary>
/// Constructor
/// </summary>
/// <param name="clientId">Client Id to create session</param>
public MqttClientSession(string clientId)
: base(clientId)
{
}
} }
}
} }

74
M2Mqtt/Session/MqttSession.cs
View File

@ -14,46 +14,50 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using System.Collections; using System.Collections;
namespace uPLibrary.Networking.M2Mqtt.Session { namespace uPLibrary.Networking.M2Mqtt.Session
/// <summary> {
/// MQTT Session base class
/// </summary>
public abstract class MqttSession {
/// <summary> /// <summary>
/// Client Id /// MQTT Session base class
/// </summary> /// </summary>
public String ClientId { get; set; } public abstract class MqttSession
{
/// <summary>
/// Client Id
/// </summary>
public string ClientId { get; set; }
/// <summary> /// <summary>
/// Messages inflight during session /// Messages inflight during session
/// </summary> /// </summary>
public Hashtable InflightMessages { get; set; } public Hashtable InflightMessages { get; set; }
/// <summary> /// <summary>
/// Constructor /// Constructor
/// </summary> /// </summary>
public MqttSession() public MqttSession()
: this(null) { : this(null)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="clientId">Client Id to create session</param>
public MqttSession(string clientId)
{
this.ClientId = clientId;
this.InflightMessages = new Hashtable();
}
/// <summary>
/// Clean session
/// </summary>
public virtual void Clear()
{
this.ClientId = null;
this.InflightMessages.Clear();
}
} }
/// <summary>
/// Constructor
/// </summary>
/// <param name="clientId">Client Id to create session</param>
public MqttSession(String clientId) {
this.ClientId = clientId;
this.InflightMessages = new Hashtable();
}
/// <summary>
/// Clean session
/// </summary>
public virtual void Clear() {
this.ClientId = null;
this.InflightMessages.Clear();
}
}
} }

47
M2Mqtt/Utility/QueueExtension.cs
View File

@ -17,31 +17,34 @@ Contributors:
using System; using System;
using System.Collections; using System.Collections;
namespace uPLibrary.Networking.M2Mqtt.Utility { namespace uPLibrary.Networking.M2Mqtt.Utility
/// <summary> {
/// Extension class for a Queue
/// </summary>
internal static class QueueExtension {
/// <summary> /// <summary>
/// Predicate for searching inside a queue /// Extension class for a Queue
/// </summary> /// </summary>
/// <param name="item">Item of the queue</param> internal static class QueueExtension
/// <returns>Result of predicate</returns> {
internal delegate Boolean QueuePredicate(Object item); /// <summary>
/// Predicate for searching inside a queue
/// </summary>
/// <param name="item">Item of the queue</param>
/// <returns>Result of predicate</returns>
internal delegate bool QueuePredicate(object item);
/// <summary> /// <summary>
/// Get (without removing) an item from queue based on predicate /// Get (without removing) an item from queue based on predicate
/// </summary> /// </summary>
/// <param name="queue">Queue in which to search</param> /// <param name="queue">Queue in which to search</param>
/// <param name="predicate">Predicate to verify to get item</param> /// <param name="predicate">Predicate to verify to get item</param>
/// <returns>Item matches the predicate</returns> /// <returns>Item matches the predicate</returns>
internal static Object Get(Queue queue, QueuePredicate predicate) { internal static object Get(Queue queue, QueuePredicate predicate)
foreach (Object item in queue) { {
if (predicate(item)) { foreach (var item in queue)
return item; {
if (predicate(item))
return item;
}
return null;
} }
}
return null;
} }
}
} }

108
M2Mqtt/Utility/Trace.cs
View File

@ -14,57 +14,73 @@ Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
using System;
using System.Diagnostics; using System.Diagnostics;
namespace uPLibrary.Networking.M2Mqtt.Utility { namespace uPLibrary.Networking.M2Mqtt.Utility
/// <summary> {
/// Tracing levels /// <summary>
/// </summary> /// Tracing levels
public enum TraceLevel { /// </summary>
Error = 0x01, public enum TraceLevel
Warning = 0x02, {
Information = 0x04, Error = 0x01,
Verbose = 0x0F, Warning = 0x02,
Frame = 0x10, Information = 0x04,
Queuing = 0x20 Verbose = 0x0F,
} Frame = 0x10,
Queuing = 0x20
// delegate for writing trace
public delegate void WriteTrace(String format, params Object[] args);
/// <summary>
/// Tracing class
/// </summary>
public static class Trace {
public static TraceLevel TraceLevel;
public static WriteTrace TraceListener;
[Conditional("DEBUG")]
public static void Debug(String format, params Object[] args) => TraceListener?.Invoke(format, args);
public static void WriteLine(TraceLevel level, String format) {
if ((level & TraceLevel) > 0) {
TraceListener.Invoke(format);
}
} }
public static void WriteLine(TraceLevel level, String format, Object arg1) { // delegate for writing trace
if ( (level & TraceLevel) > 0) { public delegate void WriteTrace(string format, params object[] args);
TraceListener.Invoke(format, arg1);
}
}
public static void WriteLine(TraceLevel level, String format, Object arg1, Object arg2) { /// <summary>
if ((level & TraceLevel) > 0) { /// Tracing class
TraceListener.Invoke(format, arg1, arg2); /// </summary>
} public static class Trace
} {
public static TraceLevel TraceLevel;
public static WriteTrace TraceListener;
public static void WriteLine(TraceLevel level, String format, Object arg1, Object arg2, Object arg3) { [Conditional("DEBUG")]
if ((level & TraceLevel) > 0) { public static void Debug(string format, params object[] args)
TraceListener.Invoke(format, arg1, arg2, arg3); {
} if (TraceListener != null)
{
TraceListener(format, args);
}
}
public static void WriteLine(TraceLevel level, string format)
{
if (TraceListener != null && (level & TraceLevel) > 0)
{
TraceListener(format);
}
}
public static void WriteLine(TraceLevel level, string format, object arg1)
{
if (TraceListener != null && (level & TraceLevel) > 0)
{
TraceListener(format, arg1);
}
}
public static void WriteLine(TraceLevel level, string format, object arg1, object arg2)
{
if (TraceListener != null && (level & TraceLevel) > 0)
{
TraceListener(format, arg1, arg2);
}
}
public static void WriteLine(TraceLevel level, string format, object arg1, object arg2, object arg3)
{
if (TraceListener != null && (level & TraceLevel) > 0)
{
TraceListener(format, arg1, arg2, arg3);
}
}
} }
}
} }

3
M2Mqtt/WinRT/Fx.cs
View File

@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
Contributors: Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !NETCOREAPP
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
@ -34,4 +34,3 @@ namespace uPLibrary.Networking.M2Mqtt
public static void SleepThread(int millisecondsTimeout) { Task.Delay(millisecondsTimeout).RunSynchronously(); } public static void SleepThread(int millisecondsTimeout) { Task.Delay(millisecondsTimeout).RunSynchronously(); }
} }
} }
#endif

3
M2Mqtt/WinRT/Hashtable.cs
View File

@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
Contributors: Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !NETCOREAPP
using System.Collections.Generic; using System.Collections.Generic;
namespace uPLibrary.Networking.M2Mqtt namespace uPLibrary.Networking.M2Mqtt
@ -25,4 +25,3 @@ namespace uPLibrary.Networking.M2Mqtt
{ {
} }
} }
#endif

3
M2Mqtt/WinRT/MqttNetworkChannel.cs
View File

@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
Contributors: Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !NETCOREAPP
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
@ -177,4 +177,3 @@ namespace uPLibrary.Networking.M2Mqtt
} }
} }
} }
#endif

3
M2Mqtt/WinRT/Queue.cs
View File

@ -13,7 +13,7 @@ and the Eclipse Distribution License is available at
Contributors: Contributors:
Paolo Patierno - initial API and implementation and/or initial documentation Paolo Patierno - initial API and implementation and/or initial documentation
*/ */
#if !NETCOREAPP
using System.Collections.Generic; using System.Collections.Generic;
namespace uPLibrary.Networking.M2Mqtt namespace uPLibrary.Networking.M2Mqtt
@ -25,4 +25,3 @@ namespace uPLibrary.Networking.M2Mqtt
{ {
} }
} }
#endif

4
README.md
View File

@ -1,4 +0,0 @@
# M2Mqtt
Based on https://github.com/eclipse/paho.mqtt.m2mqtt
Maybe you find this Repo on Github. This is a mirror from [here](https://git.blubbfish.net/vs_librarys/mqtt).