// Constructor
public MqttManager(string IoTEndpoint, string Name, bool Security, int BrokerPort, X509Certificate pCaCert, X509Certificate2 pClientCert, MqttSslProtocols SslProtocol)
{
InitializeQueue();
HasEventhandler = false;
_ioTEndPoint = IoTEndpoint;
_brokerPort = BrokerPort;
_name = Name;
_security = Security;
_caCert = pCaCert;
_clientCert = pClientCert;
_sslProtocol = SslProtocol;
if (_ioTEndPoint != null)
{
if (Security)
{
client = new MqttClient(_ioTEndPoint, _brokerPort, true, _caCert, _clientCert, MqttSslProtocols.TLSv1_2 /*this is what AWS IoT uses*/);
}
else
{
client = new MqttClient(_ioTEndPoint);
}
_hasClient = true;
client.ConnectionClosed += Client_ConnectionClosed;
client.MqttMsgSubscribed += Client_MqttMsgSubscribed;
client.MqttMsgUnsubscribed += Client_MqttMsgUnsubscribed;
client.MqttMsgPublished += Client_MqttMsgPublished;
client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
}
}
/// <summary>
/// Start is called before the first frame update.
/// </summary>
private void Start()
{
//Set up default Mqtt properties for https://github.com/khilscher/MqttClient
broker = "mqtt.eclipse.org";
port = 1883;
secure = false;
sslprotocol = MqttSslProtocols.None;
protocolversion = MqttProtocolVersion.Version_3_1_1;
username = "";
password = "";
clientId = "client123abcd";
topic = "vehicle/telemetry";
publish = false;
qos = (byte)2;
retain = false;
cleansession = false;
keepalive = 60;
//Update the settings menu with default values
settings.MQTTBrokerTextInputButton.TextObject.text = broker;
settings.DeviceIDTextInputButton.TextObject.text = clientId;
settings.TopicTextInputButton.TextObject.text = topic;
//Default data properties
data = null;
dataHasBeenUpdated = false;
//Add callback methods for setting ui
settings.ConnectButton.OnClick.AddListener(() => MqttConnect());
settings.DisconnectButton.OnClick.AddListener(() => MqttDisconnect());
settings.SubscribeButton.OnClick.AddListener(() => MqttSubscribe());
settings.UnsubscribeButton.OnClick.AddListener(() => MqttUnsubscribe());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="remoteHostName">Remote Host name</param>
/// <param name="remotePort">Remote port</param>
/// <param name="secure">Using SSL</param>
/// <param name="caCert">CA certificate</param>
/// <param name="clientCert">Client certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param>
public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol)
{
IPAddress hostIpAddress = null;
IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName);
if ((hostEntry != null) && (hostEntry.AddressList.Length > 0))
{
// check for the first address not null
// it seems that with .Net Micro Framework, the IPV6 addresses aren't supported and return "null"
int i = 0;
while (hostEntry.AddressList[i] == null)
{
i++;
}
hostIpAddress = hostEntry.AddressList[i];
}
else
{
throw new Exception("No address found for the remote host name");
}
_remoteHostName = remoteHostName;
_remoteIpAddress = hostIpAddress;
_remotePort = remotePort;
_secure = secure;
_caCert = caCert;
_clientCert = clientCert;
_sslProtocol = sslProtocol;
}
public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol, RemoteCertificateValidationCallback userCertificateValidationCallback, LocalCertificateSelectionCallback userCertificateSelectionCallback)
{
IPAddress ipAddress = (IPAddress)null;
try
{
ipAddress = IPAddress.Parse(remoteHostName);
}
catch
{
}
if (ipAddress == null)
{
IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName);
if (hostEntry == null || (uint)hostEntry.AddressList.Length <= 0U)
{
throw new Exception("No address found for the remote host name");
}
int index = 0;
while (hostEntry.AddressList[index] == null)
{
checked { ++index; }
}
ipAddress = hostEntry.AddressList[index];
}
this.remoteHostName = remoteHostName;
this.remoteIpAddress = ipAddress;
this.remotePort = remotePort;
this.secure = secure;
this.caCert = caCert;
this.clientCert = clientCert;
this.sslProtocol = sslProtocol;
this.userCertificateValidationCallback = userCertificateValidationCallback;
this.userCertificateSelectionCallback = userCertificateSelectionCallback;
}
public MqttNetworkChannel(Socket socket, bool secure, X509Certificate serverCert, MqttSslProtocols sslProtocol, RemoteCertificateValidationCallback userCertificateValidationCallback, LocalCertificateSelectionCallback userCertificateSelectionCallback)
{
this.socket = socket;
this.secure = secure;
this.serverCert = serverCert;
this.sslProtocol = sslProtocol;
this.userCertificateValidationCallback = userCertificateValidationCallback;
this.userCertificateSelectionCallback = userCertificateSelectionCallback;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="remoteHostName">Remote Host name</param>
/// <param name="remotePort">Remote port</param>
/// <param name="secure">Using SSL</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param>
public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, MqttSslProtocols sslProtocol)
{
this.remoteHostName = new HostName(remoteHostName);
this.remotePort = remotePort;
this.secure = secure;
this.sslProtocol = sslProtocol;
if (secure && (sslProtocol == MqttSslProtocols.None))
throw new ArgumentException("For secure connection, an SSL/TLS protocol version is needed");
}
public MqttBroker(string host, int port, bool secure, MqttSslProtocols sslprotocol, MqttProtocolVersion protocolversion, string username, string password)
{
this.host = host;
this.port = port;
this.secure = secure;
this.sslprotocol = sslprotocol;
this.protocolversion = protocolversion;
this.username = username;
this.password = password;
Initialize();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="remoteHostName">Remote Host name</param>
/// <param name="remotePort">Remote port</param>
/// <param name="secure">Using SSL</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param>
public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, MqttSslProtocols sslProtocol)
{
this.remoteHostName = new HostName(remoteHostName);
this.remotePort = remotePort;
this.secure = secure;
this.sslProtocol = sslProtocol;
if (secure && (sslProtocol == MqttSslProtocols.None))
{
throw new ArgumentException("For secure connection, an SSL/TLS protocol version is needed");
}
}
public void Create(Configuration configuration)
{
this.config = configuration;
this.client = CreateClient();
this.client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
MqttClient CreateClient()
{
X509Certificate2 caCert = null;
X509Certificate2 clientCert = null;
MqttSslProtocols protocol = MqttSslProtocols.None;
bool secure = bool.TryParse(this.config[SecureParam], out secure) && secure;
if (secure)
{
//MQTT can be made secure by a certificate from a Certificate Authority alone, or a CA certificate and a client certificate
//The CA certificate should never need a password
caCert = LoadCertificate(File.Parse(this.config[CACertParam]), string.Empty);
//The Client certificate should always require a password
if (!string.IsNullOrWhiteSpace(this.config[ClientCertParam]))
{
OnDecryptRequestArgs certDecryptArgs = new OnDecryptRequestArgs(this.config[CertPasswordParam]);
OnDecryptRequest(this, certDecryptArgs);
string clientPassword = certDecryptArgs.DecryptedValue;
clientCert = LoadCertificate(File.Parse(this.config[ClientCertParam]), clientPassword);
}
if (Enum.TryParse(this.config[SecureProtocolParam], out MqttSslProtocols parsedProtocol))
{
protocol = parsedProtocol;
}
}
return(new MqttClient(
this.config[BrokerParam]
, Int32.TryParse(this.config[BrokerPortParam], out int port) && port > 0 ? port : 1883
, secure
, caCert
, clientCert
, protocol
, null));
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="remoteHostName">Remote Host name</param>
/// <param name="remotePort">Remote port</param>
/// <param name="secure">Using SSL</param>
/// <param name="caCert">CA certificate</param>
/// <param name="clientCert">Client certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol version</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>
public MqttNetworkChannel(string remoteHostName, int remotePort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol,
RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback)
{
IPAddress remoteIpAddress = null;
try
{
// check if remoteHostName is a valid IP address and get it
remoteIpAddress = IPAddress.Parse(remoteHostName);
}
catch
{
}
// in this case the parameter remoteHostName isn't a valid IP address
if (remoteIpAddress == null)
{
IPHostEntry hostEntry = Dns.GetHostEntry(remoteHostName);
if ((hostEntry != null) && (hostEntry.AddressList.Length > 0))
{
// check for the first address not null
// it seems that with .Net Micro Framework, the IPV6 addresses aren't supported and return "null"
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");
}
}
this.RemoteHostName = remoteHostName;
this.RemoteIpAddress = remoteIpAddress;
this.RemotePort = remotePort;
this.secure = secure;
this.caCert = caCert;
this.clientCert = clientCert;
this.sslProtocol = sslProtocol;
this.userCertificateValidationCallback = userCertificateValidationCallback;
this.userCertificateSelectionCallback = userCertificateSelectionCallback;
}
public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
{
switch (mqttSslProtocol)
{
case MqttSslProtocols.None:
return(SslProtocols.None);
case MqttSslProtocols.SSLv3:
return(SslProtocols.Ssl3);
case MqttSslProtocols.TLSv1_0:
return(SslProtocols.Tls);
default:
throw new ArgumentException("SSL/TLS protocol version not supported");
}
}
public IResult Start()
{
Uri endpoint = new Uri(MqttConfig.BrokerEndpoint);
MqttSslProtocols protocols = MqttConfig.SecureConnection ? MqttSslProtocols.TLSv1_2 : MqttSslProtocols.None;
X509Certificate caCert = null;
X509Certificate clientCert = null;
if (MqttConfig.Security != null && MqttConfig.Security is MqttSecurity security)
{
caCert = security.CaCert ?? null;
clientCert = security.ClientCert ?? null;
}
mqttClient = new MqttClient(endpoint.Host, endpoint.Port, MqttConfig.SecureConnection, caCert, clientCert, protocols, null, null);
mqttClient.ConnectionClosed += MqttClient_ConnectionClosed;
try
{
byte success;
MqttConnectConfig config = MqttConfig.MqttConnectConfig;
if (MqttConfig.Credentials is MqttCredentials mqttCreds)
{
success = mqttClient.Connect(Guid.NewGuid().ToString(), mqttCreds.UserName, mqttCreds.Password, config.WillRetain, config.WillQosLevel, config.WillFlag, config.WillTopic, config.WillMessage, config.CleanSession, config.KeepAlivePeriod);
}
else
{
success = mqttClient.Connect(Guid.NewGuid().ToString(), null, null, config.WillRetain, config.WillQosLevel, config.WillFlag, config.WillTopic, config.WillMessage, config.CleanSession, config.KeepAlivePeriod);
}
if (success != 0)
{
return(new Result(false, new Message(MessageType.Error, "Could not connect to MQTT Broker", success.ToString())));
}
mqttClient.MqttMsgPublishReceived += MqttClient_MqttMsgPublishReceived;
return(new Result(true));
}
catch (Exception e)
{
logger.Error(e, "Could not connect MQTT-Broker");
return(new Result(e));
}
}
void BntEscrever(object sender, EventArgs e)
{
// create client instance
X509Certificate caCert = new X509Certificate();
X509Certificate caCert2 = new X509Certificate();
MqttSslProtocols mqttSslProtocols = new MqttSslProtocols();
MqttClient client = new MqttClient("m12.cloudmqtt.com", 19337, false, caCert, caCert2, mqttSslProtocols);
string clientId = Guid.NewGuid().ToString();
client.Connect(clientId, "dmsjvruj", "miXaqhWnTVA9");
string strValue = Convert.ToString("tetetet");
// publish a message on "/home/temperature" topic with QoS 2
client.Publish("/home/temperature", Encoding.UTF8.GetBytes(strValue), MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE, false);
txtCampo.Text = "TUDO SIM LINDO";
}
//[END iot_mqtt_jwt]
// [START iot_mqtt_client]
public static MqttClient GetClient(string projectId, string cloudRegion,
string registryId, string deviceId, string privateKeyFile,
string algorithm, string caCert, string mqttBridgeHostname,
int mqttBridgePort)
{
// Enable SSL/TLS support.
MqttSslProtocols mqttSslProtocols = MqttSslProtocols.TLSv1_2;
byte[] data;
using (FileStream fs = File.OpenRead(caCert))
{
data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
if (data[0] != 0x30)
{
// maybe it's ASCII PEM base64 encoded ?
data = PEM("CERTIFICATE", data);
}
fs.Close();
}
X509Certificate x509Certificate = new X509Certificate(data);
// Create client instance, Connect to the Google MQTT bridge.
MqttClient client = new MqttClient(mqttBridgeHostname, mqttBridgePort,
true, x509Certificate, null, mqttSslProtocols, null)
{
ProtocolVersion = MqttProtocolVersion.Version_3_1_1
};
Console.WriteLine("Creating the client {0}", client);
// register to message received
client.ConnectionClosed += Client_ConnectionClosed;
client.MqttMsgSubscribed += Client_MqttMsgSubscribed;
client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
client.MqttMsgPublished += Client_MqttMsgPublished;
return(client);
}
/// <summary>
/// Defines the possible versions of Secure Sockets Layer (SSL).
/// </summary>
/// <remarks>
/// Note: Following the recommendation of the .NET documentation, nanoFramework implementation does not have SSL3 nor Default because those are deprecated and unsecure.
/// </remarks>
public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
{
switch (mqttSslProtocol)
{
case MqttSslProtocols.None:
return(SslProtocols.None);
case MqttSslProtocols.TLSv1_0:
return(SslProtocols.Tls);
case MqttSslProtocols.TLSv1_1:
return(SslProtocols.Tls11);
case MqttSslProtocols.TLSv1_2:
return(SslProtocols.Tls12);
case MqttSslProtocols.TLSv1_3:
throw new ArgumentException("TLS 1.3 is currently disabled, awaiting support from OS/Device Firmware.");
default:
throw new ArgumentException("SSL/TLS protocol version not supported");
}
}
public static SocketProtectionLevel ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
{
switch (mqttSslProtocol)
{
case MqttSslProtocols.None:
return(SocketProtectionLevel.PlainSocket);
case MqttSslProtocols.SSLv3:
return(SocketProtectionLevel.SslAllowNullEncryption);
case MqttSslProtocols.TLSv1_0:
return(SocketProtectionLevel.Tls10);
case MqttSslProtocols.TLSv1_1:
return(SocketProtectionLevel.Tls11);
case MqttSslProtocols.TLSv1_2:
return(SocketProtectionLevel.Tls12);
default:
throw new ArgumentException("SSL/TLS protocol version not supported");
}
}
protected override void OnStart(string[] args)
{
// Update the service state to Start Pending.
ServiceStatus serviceStatus = new ServiceStatus
{
dwCurrentState = ServiceState.SERVICE_START_PENDING,
dwWaitHint = 100000
};
SetServiceStatus(this.ServiceHandle, ref serviceStatus);
eventLog1.WriteEntry("In OnStart");
startWatch.Start();
stopWatch.Start();
UpdateFromDb();
MqttSslProtocols mqttProtocols = new MqttSslProtocols();
MqttClient client = new MqttClient("MQTT_CLIENT_ADDR", 8883, false, mqttProtocols, null, null);
// register to message received
client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
string clientId = Guid.NewGuid().ToString();
client.Connect(clientId, "james", "USER_PASSWORD");
// subscribe to the topic "/home/temperature" with QoS 2
client.Subscribe(new string[] { "/home/games" }, new byte[] { MqttMsgBase.QOS_LEVEL_EXACTLY_ONCE });
eventLog1.WriteEntry("INIT COMPLETED");
// Update the service state to Running.
serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);
}
/// <summary>
/// Constructor (TCP/IP communication layer on port 8883 with SSL/TLS and default settings)
/// </summary>
/// <param name="serverCert">X509 Server certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol version</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>
public MqttBroker(X509Certificate serverCert, MqttSslProtocols sslProtocol, int connectTimeout,
RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback)
: this(new MqttTcpCommunicationLayer(MqttSettings.MQTT_BROKER_DEFAULT_SSL_PORT, true, serverCert, sslProtocol, connectTimeout, userCertificateValidationCallback, userCertificateSelectionCallback), MqttSettings.Instance)
{
}
public MqttBroker(X509Certificate serverCert, MqttSslProtocols sslProtocol, int port, int connectTimeout)
: this(new MqttTcpCommunicationLayer(port, true, serverCert, sslProtocol, connectTimeout, null, null), MqttSettings.Instance)
{
}
public MqttClient(string brokerHostName, int brokerPort, bool secure, X509Certificate caCert, MqttSslProtocols sslProtocol,
RemoteCertificateValidationCallback userCertificateValidationCallback)
{
}
public MqttClient(string brokerHostName, int brokerPort, bool secure, X509Certificate caCert,
MqttSslProtocols sslProtocol)
{
}
public static SslProtocols ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
{
switch (mqttSslProtocol)
{
case MqttSslProtocols.None:
return SslProtocols.None;
case MqttSslProtocols.SSLv3:
return SslProtocols.SSLv3;
case MqttSslProtocols.TLSv1_0:
return SslProtocols.TLSv1;
case MqttSslProtocols.TLSv1_1:
case MqttSslProtocols.TLSv1_2:
default:
throw new ArgumentException("SSL/TLS protocol version not supported");
}
}
public MQTTMan(string ClientEui, string ServerEui, string brokerHostName, int brokerPort, X509Certificate caCert, MqttSslProtocols protocols)
: base(ServerEui, brokerHostName, brokerPort, caCert, protocols)
{
this.ClientEui = ClientEui;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="socket">Socket opened with the client</param>
public MqttNetworkChannel(StreamSocket socket)
{
this.socket = socket;
this.sslProtocol = MqttSslProtocols.None;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="socket">Socket opened with the client</param>
public MqttNetworkChannel(StreamSocket socket)
{
this.socket = socket;
this.sslProtocol = MqttSslProtocols.None;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="socket">Socket opened with the client</param>
public MqttNetworkChannel(TcpSocketClient socket)
{
this.socket = socket;
this.sslProtocol = MqttSslProtocols.None;
}
/// <summary>
/// Constructor (TCP/IP communication layer on port 8883 with SSL/TLS and default settings)
/// </summary>
/// <param name="serverCert">X509 Server certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol versiokn</param>
public MqttBroker(X509Certificate serverCert, MqttSslProtocols sslProtocol)
: this(new MqttTcpCommunicationLayer(MqttSettings.MQTT_BROKER_DEFAULT_SSL_PORT, true, serverCert, sslProtocol, null, null), MqttSettings.Instance)
{
}
public static SocketProtectionLevel ToSslPlatformEnum(MqttSslProtocols mqttSslProtocol)
{
switch (mqttSslProtocol)
{
case MqttSslProtocols.None:
return SocketProtectionLevel.PlainSocket;
case MqttSslProtocols.SSLv3:
return SocketProtectionLevel.SslAllowNullEncryption;
case MqttSslProtocols.TLSv1_0:
return SocketProtectionLevel.Tls10;
case MqttSslProtocols.TLSv1_1:
return SocketProtectionLevel.Tls11;
case MqttSslProtocols.TLSv1_2:
return SocketProtectionLevel.Tls12;
default:
throw new ArgumentException("SSL/TLS protocol version not supported");
}
}
private void btnConnect_Click(object sender, RoutedEventArgs e)
{
if (cboxQoS.SelectedItem == null)
{
// Missing QoS level
NotifyUser("Select QoS level");
return;
}
if (cboxProtocolVersion.SelectedItem == null)
{
// Missing MQTT version
NotifyUser("Select a protocol version.");
return;
}
if (cboxSslVersion.SelectedItem == null)
{
// Missing SSL version
NotifyUser("Select a SSL version.");
return;
}
var broker = txtBoxMqttBroker.Text.Trim();
if (broker.Length == 0)
{
// Missing broker
NotifyUser("Enter a hostname for the MQTT broker.");
return;
}
int port = -1;
if (!(int.TryParse(txtBoxMqttPort.Text.Trim(), out port)))
{
// Invalid port
NotifyUser("Enter a valid port number");
return;
}
if (txtBoxTopic.Text.Trim().Length == 0)
{
// Invalid topic
NotifyUser("Enter a valid topic");
return;
}
// Parse the input values
var sslprotocol = (MqttSslProtocols)Enum.Parse(typeof(MqttSslProtocols), cboxSslVersion.SelectedItem.ToString());
var protocolversion = (MqttProtocolVersion)Enum.Parse(typeof(MqttProtocolVersion), cboxProtocolVersion.SelectedItem.ToString());
// Connect to Mqtt Broker
try
{
this.broker = txtBoxMqttBroker.Text;
this.clientId = txtBoxDeviceID.Text;
this.port = port;
this.secure = ckboxUseSecure.IsChecked.Value;
this.sslprotocol = sslprotocol;
this.protocolversion = protocolversion;
this.username = txtBoxUsername.Text;
this.password = txtBoxPassword.Text;
this.qos = (byte)cboxQoS.SelectedValue;
this.retain = chkBoxRetain.IsChecked.Value;
this.cleansession = false; // http://www.steves-internet-guide.com/mqtt-clean-sessions-example/
this.keepalive = 60; // 60 seconds http://www.steves-internet-guide.com/mqtt-keep-alive-by-example/
client = new MqttClient(this.broker, this.port, this.secure, this.sslprotocol);
// Set MQTT version
client.ProtocolVersion = this.protocolversion;
// Setup callback for receiving messages
client.MqttMsgPublishReceived += _client_MqttMsgPublishReceived;
// MQTT return codes
// https://www.hivemq.com/blog/mqtt-essentials-part-3-client-broker-connection-establishment/
// https://www.eclipse.org/paho/clients/dotnet/api/html/4158a883-de72-1ec4-2209-632a86aebd74.htm
byte resp = client.Connect(this.clientId, this.username, this.password, this.cleansession, this.keepalive);
NotifyUser("Connect() Response: " + resp.ToString());
}
catch (Exception ex)
{
NotifyUser(ex.Message + ": " + ex.InnerException);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="brokerHostName">Broker Host Name or IP Address</param>
/// <param name="brokerPort">Broker port</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param>
public MqttSecureClient(string brokerHostName, int brokerPort, MqttSslProtocols sslProtocol)
: base(brokerHostName, brokerPort, true)
{
this.InitSecureChannel(sslProtocol);
}
/// <summary>
/// Constructor (TCP/IP communication layer on port 8883 with SSL/TLS and default settings)
/// </summary>
/// <param name="serverCert">X509 Server certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol versiokn</param>
public MqttBroker(X509Certificate serverCert, MqttSslProtocols sslProtocol, int connectTimeout)
: this(new MqttTcpCommunicationLayer(MqttSettings.MQTT_BROKER_DEFAULT_SSL_PORT, true, serverCert, sslProtocol, connectTimeout, null, null), MqttSettings.Instance)
{
}
/// <summary>
/// MqttClient initialization
/// </summary>
/// <param name="caCert">CA certificate for secure connection</param>
/// <param name="clientCert">Client certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol version</param>
private void InitSecureChannel(X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol)
{
// create network channel
this.channel = new MqttSecureNetworkChannel(this.brokerHostName, this.brokerPort, caCert, clientCert, sslProtocol);
}
/**
* \brief constructor
* \param [in] brokerInfo : informations relative to the broker
* \param [in] secure : define if the communication is secure or not
* \param [in] caCert :
* \param [in] clientCert :
* \param [in] ssProtocol :
*/
public SampleMqttClient(MqttBrokerInfo brokerInfo, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol)
: base(brokerInfo.broker_address, brokerInfo.broker_port, secure, caCert, clientCert, sslProtocol)
{
BrokerInfo = brokerInfo;
ID = Guid.NewGuid().ToString();
}
/// <summary>
/// Constructor (TCP/IP communication layer on port 8883 with SSL/TLS and default settings)
/// </summary>
/// <param name="serverCert">X509 Server certificate</param>
/// <param name="sslProtocol">SSL/TLS protocol version</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>
public MqttBroker(X509Certificate serverCert, MqttSslProtocols sslProtocol,
RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback)
: this(new MqttTcpCommunicationLayer(MqttSettings.MQTT_BROKER_DEFAULT_SSL_PORT, true, serverCert, sslProtocol, userCertificateValidationCallback, userCertificateSelectionCallback), MqttSettings.Instance)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="port">TCP listening port</param>
/// <param name="secure">Secure connection (SSL/TLS)</param>
/// <param name="serverCert">X509 server certificate</param>
/// <param name="protocol">SSL/TLS protocol version</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>
public MqttTcpCommunicationLayer(int port, bool secure, X509Certificate serverCert, MqttSslProtocols protocol,
RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback)
{
if (secure && serverCert == null)
{
throw new ArgumentException("Secure connection requested but no server certificate provided");
}
this.Port = port;
this.Secure = secure;
this.ServerCert = serverCert;
this.Protocol = protocol;
this.UserCertificateValidationCallback = userCertificateValidationCallback;
this.UserCertificateSelectionCallback = userCertificateSelectionCallback;
}
/// <summary>
/// MqttClient initialization
/// </summary>
/// <param name="sslProtocol">SSL/TLS protocol version</param>
private void InitSecureChannel(MqttSslProtocols sslProtocol)
{
// create network channel
this.channel = new MqttSecureNetworkChannel(this.brokerHostName, this.brokerPort, sslProtocol);
}
/// <summary>
/// 此通讯代理相关的服务器角色
public MQTTManBase(string ServerEui, string brokerHostName, int brokerPort, X509Certificate caCert, MqttSslProtocols protocols)
{
RemoteCertificateValidationCallback certValidationCallBack = RemoteCertificateValidate;
_client = new MqttClient(brokerHostName, brokerPort, caCert != null, caCert, null, protocols, certValidationCallBack);
//register to message received
_client.MqttMsgPublishReceived += Client_MqttMsgPublishReceived;
_client.ConnectionClosed += Client_ConnectionClosed;
ServerId = ServerEui;
}
public MqttClient(IPAddress brokerIpAddress, int brokerPort, bool secure, X509Certificate caCert, X509Certificate clientCert, MqttSslProtocols sslProtocol)
{
#if !(MF_FRAMEWORK_VERSION_V4_2 || MF_FRAMEWORK_VERSION_V4_3 || COMPACT_FRAMEWORK)
this.Init(brokerIpAddress.ToString(), brokerPort, secure, caCert, clientCert, sslProtocol, null, null);
#else
this.Init(brokerIpAddress.ToString(), brokerPort, secure, caCert, clientCert, sslProtocol);
#endif
}
private void bt_connect_Click(object sender, RoutedEventArgs e)
{
var broker = tb_broker.Text.Trim();
if (broker.Length == 0)
{
//no broker given
NotifyUser("Enter a hostname for the MQTT broker.", NotifyType.ErrorMessage);
}
else
{
int port = -1;
if (!(int.TryParse(tb_port.Text.Trim(), out port)))
{
//invalid port
NotifyUser("Enter a valid port number", NotifyType.ErrorMessage);
}
else
{
if (cb_protocol_version.SelectedItem == null)
{
//no protocol version selected
NotifyUser("Select a protocol", NotifyType.ErrorMessage);
}
else
{
if (cb_ssl_protocol_version.SelectedItem == null)
{
//no ssl protocol selected
NotifyUser("Select a protocol version", NotifyType.ErrorMessage);
}
else
{
uint interval = 15;
if (!uint.TryParse(tb_interval.Text.Trim(), out interval) || interval <= 0)
{
//invalid interval
NotifyUser("Enter a valid interval", NotifyType.ErrorMessage);
}
else
{
if (tb_topic.Text.Trim().Length == 0)
{
//invalid topic
NotifyUser("Enter a valid topic", NotifyType.ErrorMessage);
}
else
{
//parse the input values
var sslprotocol = (MqttSslProtocols)Enum.Parse(typeof(MqttSslProtocols), cb_ssl_protocol_version.SelectedItem.ToString());
var protocolversion = (MqttProtocolVersion)Enum.Parse(typeof(MqttProtocolVersion), cb_protocol_version.SelectedItem.ToString());
this._interval = interval;
//connect
try
{
//store all settings
StoreAllSettings();
this.broker = tb_broker.Text;
this.port = port;
this.secure = cb_secure.IsChecked.Value;
this.sslprotocol = sslprotocol;
this.protocolversion = protocolversion;
this.username = tb_username.Text;
this.password = tb_password.Password;
MqttBroker mqttbroker = new MqttBroker(this.broker, this.port, this.secure, this.sslprotocol, this.protocolversion, this.username, this.password);
mqttbroker.Connect();
//register extended execution.
BeginExtendedExecution(_interval);
}
catch (Exception ex)
{
NotifyUser(ex.Message + ": " + ex.InnerException, NotifyType.ErrorMessage);
}
}
}
}
}
}
}
}
public AdafruitClient(string brokerHostName, int brokerPort, bool secure, MqttSslProtocols sslProtocol,
RemoteCertificateValidationCallback userCertificateValidationCallback,
LocalCertificateSelectionCallback userCertificateSelectionCallback) : base(brokerHostName, brokerPort, secure, sslProtocol, userCertificateValidationCallback, userCertificateSelectionCallback)
{
}
public static async Task Get()
{
MqttClient client = new MqttClient("127.0.0.1", 1883, false, null, MqttSslProtocols.None); // 1883 default
// MqttClient client = new MqttClient("mqtt.phelicks.net");
X509Certificate cert = null; //X509Certificate.CreateFromCertFile(Certificate); Not used atm.
MqttSslProtocols sslProtocol = new MqttSslProtocols();
string clientId = Guid.NewGuid().ToString();
var simJobIndex = 0;
//client.Connect(clientId, "cab", "sjuttongubbar");
client.Connect(clientId);
//client.MqttMsgPublished += client_MqttMsgPublished;
simJobStatus.Clear();
for (;;)
{
using (var httpclient = new HttpClient())
{
httpclient.BaseAddress = new Uri("http://localhost:50780/");
httpclient.DefaultRequestHeaders.Accept.Clear();
httpclient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = await httpclient.GetAsync("api/SimJob"+"?includeSnapshots=true");
if (response.IsSuccessStatusCode)
{
List<SimJobModel> simJobList = await response.Content.ReadAsAsync<List<SimJobModel>>();
foreach (var simjob in simJobList)
{
//var simjobx = simJobStatus.Find(x => x.SimJobId.Contains(simjob.SimJobId));
simJobIndex = findSimJob(simjob); // simjob already exist
if (simJobIndex >= 0)
{
if (simjob.jobStarted == false) // existing simjob stopped - remove thread
{
simJobStatus[simJobIndex].active = false; // mark passive- to be removed
}
else // update with latest fields from GUI
simJobStatus[simJobIndex].tws.UpdateSimulatedCar(simjob.carId, simjob.repeatJob, simjob.speedX);
}
else
{ // new simjob, not stored locally
if (simjob.jobStarted)
{
SimJobStatus sim = new SimJobStatus();
sim.ObjectId = simjob.SimJobId;
sim.active = true;
SimulatedCar tws = new SimulatedCar(client, simjob);
tws.UpdateSimulatedCar(simjob.carId, simjob.repeatJob, simjob.speedX);
Thread t = new Thread(new ThreadStart(tws.ThreadProc));
sim.task = t;
sim.tws = tws;
simJobStatus.Add(sim);
t.Start();
}
}
}
for (int i = simJobStatus.Count - 1; i >= 0; i--) // remove passive simjobs
{
if (simJobStatus[i].active == false)
{
simJobStatus[i].task.Abort();
Console.WriteLine("Simjob terminated.\n");
simJobStatus.RemoveAt(i);
}
}
}
}
System.Threading.Thread.Sleep(100);
}
}
