mirror of
https://github.com/eclipse-mosquitto/mosquitto.git
synced 2026-08-20 21:41:40 +08:00
Refactor headers for easier discovery.
This commit is contained in:
Roger A. Light
+6
-3629
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -17,12 +17,12 @@ Contributors:
|
||||
*/
|
||||
|
||||
/*
|
||||
* File: mosquitto_control.h
|
||||
* File: mosquitto/control.h
|
||||
*
|
||||
* This header contains functions for use by plugins using the CONTROL event.
|
||||
*/
|
||||
#ifndef MOSQUITTO_CONTROL_H
|
||||
#define MOSQUITTO_CONTROL_H
|
||||
#ifndef MOSQUITTO_BROKER_CONTROL_H
|
||||
#define MOSQUITTO_BROKER_CONTROL_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
@@ -30,9 +30,9 @@ extern "C" {
|
||||
|
||||
#include <cjson/cJSON.h>
|
||||
|
||||
#include <mosquitto_broker.h>
|
||||
#include <mosquitto/broker.h>
|
||||
#include <mosquitto.h>
|
||||
#include <mqtt_protocol.h>
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
|
||||
|
||||
/* =========================================================================
|
||||
@@ -0,0 +1,441 @@
|
||||
/*
|
||||
Copyright (c) 2012-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_BROKER_PLUGIN_H
|
||||
#define MOSQUITTO_BROKER_PLUGIN_H
|
||||
|
||||
/*
|
||||
* File: mosquitto_plugin.h
|
||||
*
|
||||
* This header contains function declarations for use when writing a Mosquitto plugin.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* The generic plugin interface starts at version 5 */
|
||||
#define MOSQ_PLUGIN_VERSION 5
|
||||
|
||||
/* The old auth only interface stopped at version 4 */
|
||||
#define MOSQ_AUTH_PLUGIN_VERSION 4
|
||||
|
||||
#define MOSQ_ACL_NONE 0x00
|
||||
#define MOSQ_ACL_READ 0x01
|
||||
#define MOSQ_ACL_WRITE 0x02
|
||||
#define MOSQ_ACL_SUBSCRIBE 0x04
|
||||
#define MOSQ_ACL_UNSUBSCRIBE 0x08
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <mosquitto.h>
|
||||
#include <mosquitto/broker.h>
|
||||
|
||||
struct mosquitto;
|
||||
|
||||
struct mosquitto_opt {
|
||||
char *key;
|
||||
char *value;
|
||||
};
|
||||
|
||||
struct mosquitto_auth_opt {
|
||||
char *key;
|
||||
char *value;
|
||||
};
|
||||
|
||||
struct mosquitto_acl_msg {
|
||||
const char *topic;
|
||||
const void *payload;
|
||||
long payloadlen;
|
||||
int qos;
|
||||
bool retain;
|
||||
};
|
||||
|
||||
#ifdef WIN32
|
||||
# define mosq_plugin_EXPORT __declspec(dllexport)
|
||||
#else
|
||||
# define mosq_plugin_EXPORT
|
||||
#endif
|
||||
|
||||
/*
|
||||
* To create an authentication plugin you must include this file then implement
|
||||
* the functions listed in the "Plugin Functions" section below. The resulting
|
||||
* code should then be compiled as a shared library. Using gcc this can be
|
||||
* achieved as follows:
|
||||
*
|
||||
* gcc -I<path to mosquitto_plugin.h> -fPIC -shared plugin.c -o plugin.so
|
||||
*
|
||||
* On Mac OS X:
|
||||
*
|
||||
* gcc -I<path to mosquitto_plugin.h> -fPIC -shared plugin.c -undefined dynamic_lookup -o plugin.so
|
||||
*
|
||||
*/
|
||||
|
||||
/* =========================================================================
|
||||
*
|
||||
* Helper Functions
|
||||
*
|
||||
* ========================================================================= */
|
||||
|
||||
/* There are functions that are available for plugin developers to use in
|
||||
* mosquitto_broker.h, including logging and accessor functions.
|
||||
*/
|
||||
|
||||
|
||||
/* =========================================================================
|
||||
*
|
||||
* Section: Plugin Functions v5
|
||||
*
|
||||
* This is the plugin version 5 interface, which covers authentication, access
|
||||
* control, the $CONTROL topic space handling, and message inspection and
|
||||
* modification.
|
||||
*
|
||||
* This interface is available from v2.0 onwards.
|
||||
*
|
||||
* There are just three functions to implement in your plugin. You should
|
||||
* register callbacks to handle different events in your
|
||||
* mosquitto_plugin_init() function. See mosquitto_broker.h for the events and
|
||||
* callback registering functions.
|
||||
*
|
||||
* ========================================================================= */
|
||||
|
||||
/*
|
||||
* Function: mosquitto_plugin_version
|
||||
*
|
||||
* The broker will attempt to call this function immediately after loading the
|
||||
* plugin to check it is a supported plugin version. Your code must simply
|
||||
* return the plugin interface version you support, i.e. 5.
|
||||
*
|
||||
* The supported_versions array tells you which plugin versions the broker supports.
|
||||
*
|
||||
* If the broker does not support the version that you require, return -1 to
|
||||
* indicate failure.
|
||||
*
|
||||
* HELPER: If you only wish to declare support for a single version, you can
|
||||
* use the helper macro:
|
||||
*
|
||||
* MOSQUITTO_PLUGIN_DECLARE_VERSION(5);
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_plugin_version(int supported_version_count, const int *supported_versions);
|
||||
|
||||
#define MOSQUITTO_PLUGIN_DECLARE_VERSION(A) \
|
||||
int mosquitto_plugin_version(int supported_version_count, const int *supported_versions) \
|
||||
{ \
|
||||
int i; \
|
||||
for(i=0; i<supported_version_count; i++){ \
|
||||
if(supported_versions[i] == (A)){ \
|
||||
return (A); \
|
||||
} \
|
||||
} \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
/*
|
||||
* Function: mosquitto_plugin_init
|
||||
*
|
||||
* Called after the plugin has been loaded and <mosquitto_plugin_version>
|
||||
* has been called. This will only ever be called once and can be used to
|
||||
* initialise the plugin.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* identifier - This is a pointer to an opaque structure which you must
|
||||
* save and use when registering/unregistering callbacks.
|
||||
* user_data - The pointer set here will be passed to the other plugin
|
||||
* functions. Use to hold connection information for example.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_plugin_init(mosquitto_plugin_id_t *identifier, void **userdata, struct mosquitto_opt *options, int option_count);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_plugin_cleanup
|
||||
*
|
||||
* Called when the broker is shutting down. This will only ever be called once
|
||||
* per plugin.
|
||||
*
|
||||
* If you do not need to do any of your own cleanup, this function is not
|
||||
* required. The broker will automatically unregister your callbacks.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_plugin_cleanup(void *userdata, struct mosquitto_opt *options, int option_count);
|
||||
|
||||
|
||||
|
||||
/* =========================================================================
|
||||
*
|
||||
* Section: Plugin Functions v4
|
||||
*
|
||||
* This is the plugin version 4 interface, which is exclusively for
|
||||
* authentication and access control, and which is still supported for existing
|
||||
* plugins. If you are developing a new plugin, please use the v5 interface.
|
||||
*
|
||||
* You must implement these functions in your plugin.
|
||||
*
|
||||
* Authentication plugins can implement one or both of authentication and
|
||||
* access control. If your plugin does not wish to handle either of
|
||||
* authentication or access control it should return MOSQ_ERR_PLUGIN_DEFER. In
|
||||
* this case, the next plugin will handle it. If all plugins return
|
||||
* MOSQ_ERR_PLUGIN_DEFER, the request will be denied.
|
||||
*
|
||||
* For each check, the following flow happens:
|
||||
*
|
||||
* * The default password file and/or acl file checks are made. If either one
|
||||
* of these is not defined, then they are considered to be deferred. If either
|
||||
* one accepts the check, no further checks are made. If an error occurs, the
|
||||
* check is denied
|
||||
* * The first plugin does the check, if it returns anything other than
|
||||
* MOSQ_ERR_PLUGIN_DEFER, then the check returns immediately. If the plugin
|
||||
* returns MOSQ_ERR_PLUGIN_DEFER then the next plugin runs its check.
|
||||
* * If the final plugin returns MOSQ_ERR_PLUGIN_DEFER, then access will be
|
||||
* denied.
|
||||
* ========================================================================= */
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_plugin_version
|
||||
*
|
||||
* The broker will call this function immediately after loading the plugin to
|
||||
* check it is a supported plugin version. Your code must simply return
|
||||
* the version of the plugin interface you support, i.e. 4.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_plugin_version(void);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_plugin_init
|
||||
*
|
||||
* Called after the plugin has been loaded and <mosquitto_auth_plugin_version>
|
||||
* has been called. This will only ever be called once and can be used to
|
||||
* initialise the plugin.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer set here will be passed to the other plugin
|
||||
* functions. Use to hold connection information for example.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_plugin_init(void **user_data, struct mosquitto_opt *opts, int opt_count);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_plugin_cleanup
|
||||
*
|
||||
* Called when the broker is shutting down. This will only ever be called once
|
||||
* per plugin.
|
||||
* Note that <mosquitto_auth_security_cleanup> will be called directly before
|
||||
* this function.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_plugin_cleanup(void *user_data, struct mosquitto_opt *opts, int opt_count);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_security_init
|
||||
*
|
||||
* This function is called in two scenarios:
|
||||
*
|
||||
* 1. When the broker starts up.
|
||||
* 2. If the broker is requested to reload its configuration whilst running. In
|
||||
* this case, <mosquitto_auth_security_cleanup> will be called first, then
|
||||
* this function will be called. In this situation, the reload parameter
|
||||
* will be true.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
* reload - If set to false, this is the first time the function has
|
||||
* been called. If true, the broker has received a signal
|
||||
* asking to reload its configuration.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_security_init(void *user_data, struct mosquitto_opt *opts, int opt_count, bool reload);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_security_cleanup
|
||||
*
|
||||
* This function is called in two scenarios:
|
||||
*
|
||||
* 1. When the broker is shutting down.
|
||||
* 2. If the broker is requested to reload its configuration whilst running. In
|
||||
* this case, this function will be called, followed by
|
||||
* <mosquitto_auth_security_init>. In this situation, the reload parameter
|
||||
* will be true.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
* reload - If set to false, this is the first time the function has
|
||||
* been called. If true, the broker has received a signal
|
||||
* asking to reload its configuration.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_security_cleanup(void *user_data, struct mosquitto_opt *opts, int opt_count, bool reload);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_acl_check
|
||||
*
|
||||
* Called by the broker when topic access must be checked. access will be one
|
||||
* of:
|
||||
* MOSQ_ACL_SUBSCRIBE when a client is asking to subscribe to a topic string.
|
||||
* This differs from MOSQ_ACL_READ in that it allows you to
|
||||
* deny access to topic strings rather than by pattern. For
|
||||
* example, you may use MOSQ_ACL_SUBSCRIBE to deny
|
||||
* subscriptions to '#', but allow all topics in
|
||||
* MOSQ_ACL_READ. This allows clients to subscribe to any
|
||||
* topic they want, but not discover what topics are in use
|
||||
* on the server.
|
||||
* MOSQ_ACL_READ when a message is about to be sent to a client (i.e. whether
|
||||
* it can read that topic or not).
|
||||
* MOSQ_ACL_WRITE when a message has been received from a client (i.e. whether
|
||||
* it can write to that topic or not).
|
||||
*
|
||||
* Return:
|
||||
* MOSQ_ERR_SUCCESS if access was granted.
|
||||
* MOSQ_ERR_ACL_DENIED if access was not granted.
|
||||
* MOSQ_ERR_UNKNOWN for an application specific error.
|
||||
* MOSQ_ERR_PLUGIN_DEFER if your plugin does not wish to handle this check.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_acl_check(void *user_data, int access, struct mosquitto *client, const struct mosquitto_acl_msg *msg);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_unpwd_check
|
||||
*
|
||||
* This function is OPTIONAL. Only include this function in your plugin if you
|
||||
* are making basic username/password checks.
|
||||
*
|
||||
* Called by the broker when a username/password must be checked.
|
||||
*
|
||||
* Return:
|
||||
* MOSQ_ERR_SUCCESS if the user is authenticated.
|
||||
* MOSQ_ERR_AUTH if authentication failed.
|
||||
* MOSQ_ERR_UNKNOWN for an application specific error.
|
||||
* MOSQ_ERR_PLUGIN_DEFER if your plugin does not wish to handle this check.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_unpwd_check(void *user_data, struct mosquitto *client, const char *username, const char *password);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_psk_key_get
|
||||
*
|
||||
* This function is OPTIONAL. Only include this function in your plugin if you
|
||||
* are making TLS-PSK checks.
|
||||
*
|
||||
* Called by the broker when a client connects to a listener using TLS/PSK.
|
||||
* This is used to retrieve the pre-shared-key associated with a client
|
||||
* identity.
|
||||
*
|
||||
* Examine hint and identity to determine the required PSK (which must be a
|
||||
* hexadecimal string with no leading "0x") and copy this string into key.
|
||||
*
|
||||
* Parameters:
|
||||
* user_data - the pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* hint - the psk_hint for the listener the client is connecting to.
|
||||
* identity - the identity string provided by the client
|
||||
* key - a string where the hex PSK should be copied
|
||||
* max_key_len - the size of key
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success.
|
||||
* Return >0 on failure.
|
||||
* Return MOSQ_ERR_PLUGIN_DEFER if your plugin does not wish to handle this check.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_psk_key_get(void *user_data, struct mosquitto *client, const char *hint, const char *identity, char *key, int max_key_len);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_start
|
||||
*
|
||||
* This function is OPTIONAL. Only include this function in your plugin if you
|
||||
* are making extended authentication checks.
|
||||
*
|
||||
* Parameters:
|
||||
* user_data - the pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* method - the authentication method
|
||||
* reauth - this is set to false if this is the first authentication attempt
|
||||
* on a connection, set to true if the client is attempting to
|
||||
* reauthenticate.
|
||||
* data_in - pointer to authentication data, or NULL
|
||||
* data_in_len - length of data_in, in bytes
|
||||
* data_out - if your plugin wishes to send authentication data back to the
|
||||
* client, allocate some memory using malloc or friends and set
|
||||
* data_out. The broker will free the memory after use.
|
||||
* data_out_len - Set the length of data_out in bytes.
|
||||
*
|
||||
* Return value:
|
||||
* Return MOSQ_ERR_SUCCESS if authentication was successful.
|
||||
* Return MOSQ_ERR_AUTH_CONTINUE if the authentication is a multi step process and can continue.
|
||||
* Return MOSQ_ERR_AUTH if authentication was valid but did not succeed.
|
||||
* Return any other relevant positive integer MOSQ_ERR_* to produce an error.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_start(void *user_data, struct mosquitto *client, const char *method, bool reauth, const void *data_in, uint16_t data_in_len, void **data_out, uint16_t *data_out_len);
|
||||
|
||||
mosq_plugin_EXPORT int mosquitto_auth_continue(void *user_data, struct mosquitto *client, const char *method, const void *data_in, uint16_t data_in_len, void **data_out, uint16_t *data_out_len);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,125 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_DEFS_H
|
||||
#define MOSQUITTO_DEFS_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/defs.h
|
||||
*
|
||||
* This header contains defines and enums used by the mosquitto broker and
|
||||
* libmosquitto, the Mosquitto client library.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
|
||||
/* Log types */
|
||||
#define MOSQ_LOG_NONE 0
|
||||
#define MOSQ_LOG_INFO (1<<0)
|
||||
#define MOSQ_LOG_NOTICE (1<<1)
|
||||
#define MOSQ_LOG_WARNING (1<<2)
|
||||
#define MOSQ_LOG_ERR (1<<3)
|
||||
#define MOSQ_LOG_DEBUG (1<<4)
|
||||
#define MOSQ_LOG_SUBSCRIBE (1<<5)
|
||||
#define MOSQ_LOG_UNSUBSCRIBE (1<<6)
|
||||
#define MOSQ_LOG_WEBSOCKETS (1<<7)
|
||||
#define MOSQ_LOG_INTERNAL 0x80000000U
|
||||
#define MOSQ_LOG_ALL 0xFFFFFFFFU
|
||||
|
||||
/* Enum: mosq_err_t
|
||||
* Integer values returned from many libmosquitto functions. */
|
||||
enum mosq_err_t {
|
||||
MOSQ_ERR_QUOTA_EXCEEDED = -6,
|
||||
MOSQ_ERR_AUTH_DELAYED = -5,
|
||||
MOSQ_ERR_AUTH_CONTINUE = -4,
|
||||
MOSQ_ERR_NO_SUBSCRIBERS = -3,
|
||||
MOSQ_ERR_SUB_EXISTS = -2,
|
||||
MOSQ_ERR_CONN_PENDING = -1,
|
||||
MOSQ_ERR_SUCCESS = 0,
|
||||
MOSQ_ERR_NOMEM = 1,
|
||||
MOSQ_ERR_PROTOCOL = 2,
|
||||
MOSQ_ERR_INVAL = 3,
|
||||
MOSQ_ERR_NO_CONN = 4,
|
||||
MOSQ_ERR_CONN_REFUSED = 5,
|
||||
MOSQ_ERR_NOT_FOUND = 6,
|
||||
MOSQ_ERR_CONN_LOST = 7,
|
||||
MOSQ_ERR_TLS = 8,
|
||||
MOSQ_ERR_PAYLOAD_SIZE = 9,
|
||||
MOSQ_ERR_NOT_SUPPORTED = 10,
|
||||
MOSQ_ERR_AUTH = 11,
|
||||
MOSQ_ERR_ACL_DENIED = 12,
|
||||
MOSQ_ERR_UNKNOWN = 13,
|
||||
MOSQ_ERR_ERRNO = 14,
|
||||
MOSQ_ERR_EAI = 15,
|
||||
MOSQ_ERR_PROXY = 16,
|
||||
MOSQ_ERR_PLUGIN_DEFER = 17,
|
||||
MOSQ_ERR_MALFORMED_UTF8 = 18,
|
||||
MOSQ_ERR_KEEPALIVE = 19,
|
||||
MOSQ_ERR_LOOKUP = 20,
|
||||
MOSQ_ERR_MALFORMED_PACKET = 21,
|
||||
MOSQ_ERR_DUPLICATE_PROPERTY = 22,
|
||||
MOSQ_ERR_TLS_HANDSHAKE = 23,
|
||||
MOSQ_ERR_QOS_NOT_SUPPORTED = 24,
|
||||
MOSQ_ERR_OVERSIZE_PACKET = 25,
|
||||
MOSQ_ERR_OCSP = 26,
|
||||
MOSQ_ERR_TIMEOUT = 27,
|
||||
/* 28, 29, 30 - was internal only, moved to MQTT v5 section. */
|
||||
MOSQ_ERR_ALREADY_EXISTS = 31,
|
||||
MOSQ_ERR_PLUGIN_IGNORE = 32,
|
||||
MOSQ_ERR_HTTP_BAD_ORIGIN = 33,
|
||||
|
||||
/* MQTT v5 direct equivalents 128-255 */
|
||||
MOSQ_ERR_UNSPECIFIED = 128,
|
||||
MOSQ_ERR_IMPLEMENTATION_SPECIFIC = 131,
|
||||
MOSQ_ERR_CLIENT_IDENTIFIER_NOT_VALID = 133,
|
||||
MOSQ_ERR_BAD_USERNAME_OR_PASSWORD = 134,
|
||||
MOSQ_ERR_SERVER_UNAVAILABLE = 136,
|
||||
MOSQ_ERR_SERVER_BUSY = 137,
|
||||
MOSQ_ERR_BANNED = 138,
|
||||
MOSQ_ERR_BAD_AUTHENTICATION_METHOD = 140,
|
||||
MOSQ_ERR_SESSION_TAKEN_OVER = 142,
|
||||
MOSQ_ERR_RECEIVE_MAXIMUM_EXCEEDED = 147,
|
||||
MOSQ_ERR_TOPIC_ALIAS_INVALID = 148,
|
||||
MOSQ_ERR_ADMINISTRATIVE_ACTION = 152,
|
||||
MOSQ_ERR_RETAIN_NOT_SUPPORTED = 154,
|
||||
MOSQ_ERR_CONNECTION_RATE_EXCEEDED = 159,
|
||||
};
|
||||
|
||||
enum mosq_transport_t {
|
||||
MOSQ_T_TCP = 1,
|
||||
MOSQ_T_WEBSOCKETS = 2,
|
||||
};
|
||||
|
||||
/* MQTT specification restricts client ids to a maximum of 23 characters */
|
||||
#define MOSQ_MQTT_ID_MAX_LENGTH 23
|
||||
|
||||
#define MQTT_PROTOCOL_V31 3
|
||||
#define MQTT_PROTOCOL_V311 4
|
||||
#define MQTT_PROTOCOL_V5 5
|
||||
|
||||
struct mosquitto;
|
||||
typedef struct mqtt5__property mosquitto_property;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,39 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBCOMMON_H
|
||||
#define MOSQUITTO_LIBCOMMON_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libcommon.h
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <mosquitto/libcommon_properties.h>
|
||||
#include <mosquitto/libcommon_string.h>
|
||||
#include <mosquitto/libcommon_topic.h>
|
||||
#include <mosquitto/libcommon_utf8.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,97 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBCOMMON_STRING_H
|
||||
#define MOSQUITTO_LIBCOMMON_STRING_H
|
||||
|
||||
/*
|
||||
* File: mosquitto.h
|
||||
*
|
||||
* This header contains functions and definitions for use with libmosquitto, the Mosquitto client library.
|
||||
*
|
||||
* The definitions are also used in Mosquitto broker plugins, and some functions are available to plugins.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Function: mosquitto_strerror
|
||||
*
|
||||
* Call to obtain a const string description of a mosquitto error number.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq_errno - a mosquitto error number.
|
||||
*
|
||||
* Returns:
|
||||
* A constant string describing the error.
|
||||
*/
|
||||
libmosq_EXPORT const char *mosquitto_strerror(int mosq_errno);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connack_string
|
||||
*
|
||||
* Call to obtain a const string description of an MQTT connection result.
|
||||
*
|
||||
* Parameters:
|
||||
* connack_code - an MQTT connection result.
|
||||
*
|
||||
* Returns:
|
||||
* A constant string describing the result.
|
||||
*/
|
||||
libmosq_EXPORT const char *mosquitto_connack_string(int connack_code);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_reason_string
|
||||
*
|
||||
* Call to obtain a const string description of an MQTT reason code.
|
||||
*
|
||||
* Parameters:
|
||||
* reason_code - an MQTT reason code.
|
||||
*
|
||||
* Returns:
|
||||
* A constant string describing the reason.
|
||||
*/
|
||||
libmosq_EXPORT const char *mosquitto_reason_string(int reason_code);
|
||||
|
||||
/* Function: mosquitto_string_to_command
|
||||
*
|
||||
* Take a string input representing an MQTT command and convert it to the
|
||||
* libmosquitto integer representation.
|
||||
*
|
||||
* Parameters:
|
||||
* str - the string to parse.
|
||||
* cmd - pointer to an int, for the result.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - on an invalid input.
|
||||
*
|
||||
* Example:
|
||||
* (start code)
|
||||
* mosquitto_string_to_command("CONNECT", &cmd);
|
||||
* // cmd == CMD_CONNECT
|
||||
* (end)
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_string_to_command(const char *str, int *cmd);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,348 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBCOMMON_TOPIC_H
|
||||
#define MOSQUITTO_LIBCOMMON_TOPIC_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libcommon_topic.h
|
||||
*
|
||||
* This header contains functions and definitions for checking and manipulating topic strings.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Function: mosquitto_sub_topic_tokenise
|
||||
*
|
||||
* Tokenise a topic or subscription string into an array of strings
|
||||
* representing the topic hierarchy.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* subtopic: "a/deep/topic/hierarchy"
|
||||
*
|
||||
* Would result in:
|
||||
*
|
||||
* topics[0] = "a"
|
||||
* topics[1] = "deep"
|
||||
* topics[2] = "topic"
|
||||
* topics[3] = "hierarchy"
|
||||
*
|
||||
* and:
|
||||
*
|
||||
* subtopic: "/a/deep/topic/hierarchy/"
|
||||
*
|
||||
* Would result in:
|
||||
*
|
||||
* topics[0] = NULL
|
||||
* topics[1] = "a"
|
||||
* topics[2] = "deep"
|
||||
* topics[3] = "topic"
|
||||
* topics[4] = "hierarchy"
|
||||
*
|
||||
* Parameters:
|
||||
* subtopic - the subscription/topic to tokenise
|
||||
* topics - a pointer to store the array of strings
|
||||
* count - an int pointer to store the number of items in the topics array.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* > char **topics;
|
||||
* > int topic_count;
|
||||
* > int i;
|
||||
* >
|
||||
* > mosquitto_sub_topic_tokenise("$SYS/broker/uptime", &topics, &topic_count);
|
||||
* >
|
||||
* > for(i=0; i<token_count; i++){
|
||||
* > printf("%d: %s\n", i, topics[i]);
|
||||
* > }
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_sub_topic_tokens_free>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_sub_topic_tokenise(const char *subtopic, char ***topics, int *count);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_sub_topic_tokens_free
|
||||
*
|
||||
* Free memory that was allocated in <mosquitto_sub_topic_tokenise>.
|
||||
*
|
||||
* Parameters:
|
||||
* topics - pointer to string array.
|
||||
* count - count of items in string array.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_sub_topic_tokenise>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_sub_topic_tokens_free(char ***topics, int count);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_topic_matches_sub
|
||||
*
|
||||
* Check whether a topic matches a subscription.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* foo/bar would match the subscription foo/# or +/bar
|
||||
* non/matching would not match the subscription non/+/+
|
||||
*
|
||||
* Parameters:
|
||||
* sub - subscription string to check topic against.
|
||||
* topic - topic to check.
|
||||
* result - bool pointer to hold result. Will be set to true if the topic
|
||||
* matches the subscription.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_topic_matches_sub(const char *sub, const char *topic, bool *result);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_topic_matches_sub2
|
||||
*
|
||||
* Identical to <mosquitto_topic_matches_sub>. The sublen and topiclen
|
||||
* parameters are *IGNORED*.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_topic_matches_sub2(const char *sub, size_t sublen, const char *topic, size_t topiclen, bool *result);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_topic_matches_sub_with_pattern
|
||||
*
|
||||
* Check whether a topic matches a subscription, with client id/username
|
||||
* pattern substitution.
|
||||
*
|
||||
* Any instances of a subscriptions hierarchy that are exactly %c or %u will be
|
||||
* replaced with the client id or username respectively.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* mosquitto_topic_matches_sub_with_pattern("sensors/%c/temperature", "sensors/kitchen/temperature", "kitchen", NULL, &result)
|
||||
* -> this will match
|
||||
*
|
||||
* mosquitto_topic_matches_sub_with_pattern("sensors/%c/temperature", "sensors/bathroom/temperature", "kitchen", NULL, &result)
|
||||
* -> this will not match
|
||||
*
|
||||
* mosquitto_topic_matches_sub_with_pattern("sensors/%count/temperature", "sensors/kitchen/temperature", "kitchen", NULL, &result)
|
||||
* -> this will not match - the `%count` is not treated as a pattern
|
||||
*
|
||||
* mosquitto_topic_matches_sub_with_pattern("%c/%c/%u/%u", "kitchen/kitchen/bathroom/bathroom", "kitchen", "bathroom", &result)
|
||||
* -> this will match
|
||||
*
|
||||
* Parameters:
|
||||
* sub - subscription string to check topic against.
|
||||
* topic - topic to check.
|
||||
* clientid - client id to substitute in patterns. If NULL, then any %c patterns will not match.
|
||||
* username - username to substitute in patterns. If NULL, then any %u patterns will not match.
|
||||
* result - bool pointer to hold result. Will be set to true if the topic
|
||||
* matches the subscription.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_topic_matches_sub_with_pattern(const char *sub, const char *topic, const char *clientid, const char *username, bool *result);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_sub_matches_acl
|
||||
*
|
||||
* Check whether a subscription matches an ACL topic filter
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* The subscription $SYS/broker/# would match against the ACL $SYS/#
|
||||
* The subscription $SYS/broker/# would not match against the ACL $SYS/broker/uptime
|
||||
*
|
||||
* Parameters:
|
||||
* acl - topic filter string to check sub against.
|
||||
* sub - subscription topic to check.
|
||||
* result - bool pointer to hold result. Will be set to true if the subscription
|
||||
* matches the acl.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_sub_matches_acl(const char *acl, const char *sub, bool *result);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_sub_matches_acl_with_pattern
|
||||
*
|
||||
* Check whether a subscription (a topic filter with wildcards) matches an ACL
|
||||
* (a topic filter with wildcards) , with client id/username pattern
|
||||
* substitution.
|
||||
*
|
||||
* Any instances of an ACL hierarchy that are exactly %c or %u will be
|
||||
* replaced with the client id or username respectively.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* mosquitto_sub_matches_acl_with_pattern("sensors/%c/+", "sensors/kitchen/temperature", "kitchen", NULL, &result)
|
||||
* -> this will match
|
||||
*
|
||||
* mosquitto_sub_matches_acl_with_pattern("sensors/%c/+", "sensors/bathroom/temperature", "kitchen", NULL, &result)
|
||||
* -> this will not match
|
||||
*
|
||||
* mosquitto_sub_matches_acl_with_pattern("sensors/%count/+", "sensors/kitchen/temperature", "kitchen", NULL, &result)
|
||||
* -> this will not match - the `%count` is not treated as a pattern
|
||||
*
|
||||
* mosquitto_sub_matches_acl_with_pattern("%c/%c/%u/+", "kitchen/kitchen/bathroom/bathroom", "kitchen", "bathroom", &result)
|
||||
* -> this will match
|
||||
*
|
||||
* Parameters:
|
||||
* acl - ACL topic filter string to check sub against.
|
||||
* sub - subscription to check.
|
||||
* clientid - client id to substitute in patterns. If NULL, then any %c patterns will not match.
|
||||
* username - username to substitute in patterns. If NULL, then any %u patterns will not match.
|
||||
* result - bool pointer to hold result. Will be set to true if the subscription
|
||||
* matches the ACL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_sub_matches_acl_with_pattern(const char *acl, const char *sub, const char *clientid, const char *username, bool *result);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_pub_topic_check
|
||||
*
|
||||
* Check whether a topic to be used for publishing is valid.
|
||||
*
|
||||
* This searches for + or # in a topic and checks its length.
|
||||
*
|
||||
* This check is already carried out in <mosquitto_publish> and
|
||||
* <mosquitto_will_set>, there is no need to call it directly before them. It
|
||||
* may be useful if you wish to check the validity of a topic in advance of
|
||||
* making a connection for example.
|
||||
*
|
||||
* Parameters:
|
||||
* topic - the topic to check
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - for a valid topic
|
||||
* MOSQ_ERR_INVAL - if the topic contains a + or a #, or if it is too long.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if topic is not valid UTF-8
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_sub_topic_check>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_pub_topic_check(const char *topic);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_pub_topic_check2
|
||||
*
|
||||
* Check whether a topic to be used for publishing is valid.
|
||||
*
|
||||
* This searches for + or # in a topic and checks its length.
|
||||
*
|
||||
* This check is already carried out in <mosquitto_publish> and
|
||||
* <mosquitto_will_set>, there is no need to call it directly before them. It
|
||||
* may be useful if you wish to check the validity of a topic in advance of
|
||||
* making a connection for example.
|
||||
*
|
||||
* Parameters:
|
||||
* topic - the topic to check
|
||||
* topiclen - length of the topic in bytes
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - for a valid topic
|
||||
* MOSQ_ERR_INVAL - if the topic contains a + or a #, or if it is too long.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if topic is not valid UTF-8
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_sub_topic_check>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_pub_topic_check2(const char *topic, size_t topiclen);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_sub_topic_check
|
||||
*
|
||||
* Check whether a topic to be used for subscribing is valid.
|
||||
*
|
||||
* This searches for + or # in a topic and checks that they aren't in invalid
|
||||
* positions, such as with foo/#/bar, foo/+bar or foo/bar#, and checks its
|
||||
* length.
|
||||
*
|
||||
* This check is already carried out in <mosquitto_subscribe> and
|
||||
* <mosquitto_unsubscribe>, there is no need to call it directly before them.
|
||||
* It may be useful if you wish to check the validity of a topic in advance of
|
||||
* making a connection for example.
|
||||
*
|
||||
* Parameters:
|
||||
* topic - the topic to check
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - for a valid topic
|
||||
* MOSQ_ERR_INVAL - if the topic contains a + or a # that is in an
|
||||
* invalid position, or if it is too long.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if topic is not valid UTF-8
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_sub_topic_check>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_sub_topic_check(const char *topic);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_sub_topic_check2
|
||||
*
|
||||
* Check whether a topic to be used for subscribing is valid.
|
||||
*
|
||||
* This searches for + or # in a topic and checks that they aren't in invalid
|
||||
* positions, such as with foo/#/bar, foo/+bar or foo/bar#, and checks its
|
||||
* length.
|
||||
*
|
||||
* This check is already carried out in <mosquitto_subscribe> and
|
||||
* <mosquitto_unsubscribe>, there is no need to call it directly before them.
|
||||
* It may be useful if you wish to check the validity of a topic in advance of
|
||||
* making a connection for example.
|
||||
*
|
||||
* Parameters:
|
||||
* topic - the topic to check
|
||||
* topiclen - the length in bytes of the topic
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - for a valid topic
|
||||
* MOSQ_ERR_INVAL - if the topic contains a + or a # that is in an
|
||||
* invalid position, or if it is too long.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if topic is not valid UTF-8
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_sub_topic_check>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_sub_topic_check2(const char *topic, size_t topiclen);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBCOMMON_UTF8_H
|
||||
#define MOSQUITTO_LIBCOMMON_UTF8_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libcommon_utf8.h
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Function: mosquitto_validate_utf8
|
||||
*
|
||||
* Helper function to validate whether a UTF-8 string is valid, according to
|
||||
* the UTF-8 spec and the MQTT additions.
|
||||
*
|
||||
* Parameters:
|
||||
* str - a string to check
|
||||
* len - the length of the string in bytes
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* MOSQ_ERR_INVAL - if str is NULL or len<0 or len>65536
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if str is not valid UTF-8
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_validate_utf8(const char *str, int len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,248 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto.h
|
||||
*
|
||||
* This header contains functions and definitions for use with libmosquitto, the Mosquitto client library.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef WIN32
|
||||
# ifdef mosquitto_EXPORTS
|
||||
# define libmosq_EXPORT __declspec(dllexport)
|
||||
# else
|
||||
# ifndef LIBMOSQUITTO_STATIC
|
||||
# ifdef libmosquitto_EXPORTS
|
||||
# define libmosq_EXPORT __declspec(dllexport)
|
||||
# else
|
||||
# define libmosq_EXPORT __declspec(dllimport)
|
||||
# endif
|
||||
# else
|
||||
# define libmosq_EXPORT
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
# define libmosq_EXPORT
|
||||
#endif
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1900 && !defined(bool)
|
||||
# ifndef __cplusplus
|
||||
# define bool char
|
||||
# define true 1
|
||||
# define false 0
|
||||
# endif
|
||||
#else
|
||||
# ifndef __cplusplus
|
||||
# include <stdbool.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <mosquitto/defs.h>
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
|
||||
#define LIBMOSQUITTO_MAJOR 2
|
||||
#define LIBMOSQUITTO_MINOR 1
|
||||
#define LIBMOSQUITTO_REVISION 0
|
||||
/* LIBMOSQUITTO_VERSION_NUMBER looks like 1002001 for e.g. version 1.2.1. */
|
||||
#define LIBMOSQUITTO_VERSION_NUMBER (LIBMOSQUITTO_MAJOR*1000000+LIBMOSQUITTO_MINOR*1000+LIBMOSQUITTO_REVISION)
|
||||
|
||||
/* Enum: mosq_opt_t
|
||||
*
|
||||
* Client options.
|
||||
*
|
||||
* See <mosquitto_int_option>, <mosquitto_string_option>, and <mosquitto_void_option>.
|
||||
*/
|
||||
enum mosq_opt_t {
|
||||
MOSQ_OPT_PROTOCOL_VERSION = 1,
|
||||
MOSQ_OPT_SSL_CTX = 2,
|
||||
MOSQ_OPT_SSL_CTX_WITH_DEFAULTS = 3,
|
||||
MOSQ_OPT_RECEIVE_MAXIMUM = 4,
|
||||
MOSQ_OPT_SEND_MAXIMUM = 5,
|
||||
MOSQ_OPT_TLS_KEYFORM = 6,
|
||||
MOSQ_OPT_TLS_ENGINE = 7,
|
||||
MOSQ_OPT_TLS_ENGINE_KPASS_SHA1 = 8,
|
||||
MOSQ_OPT_TLS_OCSP_REQUIRED = 9,
|
||||
MOSQ_OPT_TLS_ALPN = 10,
|
||||
MOSQ_OPT_TCP_NODELAY = 11,
|
||||
MOSQ_OPT_BIND_ADDRESS = 12,
|
||||
MOSQ_OPT_TLS_USE_OS_CERTS = 13,
|
||||
MOSQ_OPT_DISABLE_SOCKETPAIR = 14,
|
||||
MOSQ_OPT_TRANSPORT = 15,
|
||||
MOSQ_OPT_HTTP_PATH = 16,
|
||||
MOSQ_OPT_HTTP_HEADER_SIZE = 17,
|
||||
};
|
||||
|
||||
/* Struct: mosquitto_message
|
||||
*
|
||||
* Contains details of a PUBLISH message.
|
||||
*
|
||||
* int mid - the message/packet ID of the PUBLISH message, assuming this is a
|
||||
* QoS 1 or 2 message. Will be set to 0 for QoS 0 messages.
|
||||
*
|
||||
* char *topic - the topic the message was delivered on.
|
||||
*
|
||||
* void *payload - the message payload. This will be payloadlen bytes long, and
|
||||
* may be NULL if a zero length payload was sent.
|
||||
*
|
||||
* int payloadlen - the length of the payload, in bytes.
|
||||
*
|
||||
* int qos - the quality of service of the message, 0, 1, or 2.
|
||||
*
|
||||
* bool retain - set to true for stale retained messages.
|
||||
*/
|
||||
struct mosquitto_message{
|
||||
int mid;
|
||||
char *topic;
|
||||
void *payload;
|
||||
int payloadlen;
|
||||
int qos;
|
||||
bool retain;
|
||||
};
|
||||
|
||||
struct mosquitto_message_v5{
|
||||
void *payload;
|
||||
char *topic;
|
||||
mosquitto_property *properties;
|
||||
uint32_t payloadlen;
|
||||
uint8_t qos;
|
||||
bool retain;
|
||||
uint8_t padding[2];
|
||||
};
|
||||
|
||||
/*
|
||||
* Topic: Threads
|
||||
* libmosquitto provides thread safe operation, with the exception of
|
||||
* <mosquitto_lib_init> which is not thread safe.
|
||||
*
|
||||
* If the library has been compiled without thread support it is *not*
|
||||
* guaranteed to be thread safe.
|
||||
*
|
||||
* If your application uses threads you must use <mosquitto_threaded_set> to
|
||||
* tell the library this is the case, otherwise it makes some optimisations
|
||||
* for the single threaded case that may result in unexpected behaviour for
|
||||
* the multi threaded case.
|
||||
*/
|
||||
/***************************************************
|
||||
* Important note
|
||||
*
|
||||
* The following functions that deal with network operations will return
|
||||
* MOSQ_ERR_SUCCESS on success, but this does not mean that the operation has
|
||||
* taken place. An attempt will be made to write the network data, but if the
|
||||
* socket is not available for writing at that time then the packet will not be
|
||||
* sent. To ensure the packet is sent, call mosquitto_loop() (which must also
|
||||
* be called to process incoming network data).
|
||||
* This is especially important when disconnecting a client that has a will. If
|
||||
* the broker does not receive the DISCONNECT command, it will assume that the
|
||||
* client has disconnected unexpectedly and send the will.
|
||||
*
|
||||
* mosquitto_connect()
|
||||
* mosquitto_disconnect()
|
||||
* mosquitto_subscribe()
|
||||
* mosquitto_unsubscribe()
|
||||
* mosquitto_publish()
|
||||
***************************************************/
|
||||
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Library version, init, and cleanup
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_lib_version
|
||||
*
|
||||
* Can be used to obtain version information for the mosquitto library.
|
||||
* This allows the application to compare the library version against the
|
||||
* version it was compiled against by using the LIBMOSQUITTO_MAJOR,
|
||||
* LIBMOSQUITTO_MINOR and LIBMOSQUITTO_REVISION defines.
|
||||
*
|
||||
* Parameters:
|
||||
* major - an integer pointer. If not NULL, the major version of the
|
||||
* library will be returned in this variable.
|
||||
* minor - an integer pointer. If not NULL, the minor version of the
|
||||
* library will be returned in this variable.
|
||||
* revision - an integer pointer. If not NULL, the revision of the library will
|
||||
* be returned in this variable.
|
||||
*
|
||||
* Returns:
|
||||
* LIBMOSQUITTO_VERSION_NUMBER - which is a unique number based on the major,
|
||||
* minor and revision values.
|
||||
* See Also:
|
||||
* <mosquitto_lib_cleanup>, <mosquitto_lib_init>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_lib_version(int *major, int *minor, int *revision);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_lib_init
|
||||
*
|
||||
* Must be called before any other mosquitto functions.
|
||||
*
|
||||
* This function is *not* thread safe.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_UNKNOWN - on Windows, if sockets couldn't be initialized.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_lib_cleanup>, <mosquitto_lib_version>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_lib_init(void);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_lib_cleanup
|
||||
*
|
||||
* Call to free resources associated with the library.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - always
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_lib_init>, <mosquitto_lib_version>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_lib_cleanup(void);
|
||||
|
||||
#include <mosquitto/libmosquitto_auth.h>
|
||||
#include <mosquitto/libmosquitto_callbacks.h>
|
||||
#include <mosquitto/libmosquitto_connect.h>
|
||||
#include <mosquitto/libmosquitto_create_delete.h>
|
||||
#include <mosquitto/libmosquitto_helpers.h>
|
||||
#include <mosquitto/libmosquitto_loop.h>
|
||||
#include <mosquitto/libmosquitto_message.h>
|
||||
#include <mosquitto/libmosquitto_options.h>
|
||||
#include <mosquitto/libmosquitto_publish.h>
|
||||
#include <mosquitto/libmosquitto_socks.h>
|
||||
#include <mosquitto/libmosquitto_subscribe.h>
|
||||
#include <mosquitto/libmosquitto_tls.h>
|
||||
#include <mosquitto/libmosquitto_unsubscribe.h>
|
||||
#include <mosquitto/libmosquitto_will.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,63 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_AUTH_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_AUTH_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_auth.h
|
||||
*
|
||||
* This header contains functions for setting client authentication parameters in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Username and password
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_username_pw_set
|
||||
*
|
||||
* Configure username and password for a mosquitto instance. By default, no
|
||||
* username or password will be sent. For v3.1 and v3.1.1 clients, if username
|
||||
* is NULL, the password argument is ignored.
|
||||
*
|
||||
* This is must be called before calling <mosquitto_connect>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* username - the username to send as a string, or NULL to disable
|
||||
* authentication.
|
||||
* password - the password to send as a string. Set to NULL when username is
|
||||
* valid in order to send just a username.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_username_pw_set(struct mosquitto *mosq, const char *username, const char *password);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,440 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_CALLBACKS_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_CALLBACKS_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_callbacks.h
|
||||
*
|
||||
* This header contains functions for handling libmosquitto client callbacks.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <mosquitto/defs.h>
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Callbacks
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_connect_callback_set
|
||||
*
|
||||
* Set the connect callback. This is called when the library receives a CONNACK
|
||||
* message in response to a connection.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_connect - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int rc)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* rc - the return code of the connection response. The values are defined by
|
||||
* the MQTT protocol version in use.
|
||||
* For MQTT v5.0, look at section 3.2.2.2 Connect Reason code: https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html
|
||||
* For MQTT v3.1.1, look at section 3.2.2.3 Connect Return code: http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/mqtt-v3.1.1.html
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_pre_connect_callback_set>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_connect_callback_set(struct mosquitto *mosq, void (*on_connect)(struct mosquitto *, void *, int));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_with_flags_callback_set
|
||||
*
|
||||
* Set the connect callback. This is called when the library receives a CONNACK
|
||||
* message in response to a connection.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_connect - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int rc)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* rc - the return code of the connection response. The values are defined by
|
||||
* the MQTT protocol version in use.
|
||||
* For MQTT v5.0, look at section 3.2.2.2 Connect Reason code: https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html
|
||||
* For MQTT v3.1.1, look at section 3.2.2.3 Connect Return code: http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/mqtt-v3.1.1.html
|
||||
* flags - the connect flags.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_pre_connect_callback_set>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_connect_with_flags_callback_set(struct mosquitto *mosq, void (*on_connect)(struct mosquitto *, void *, int, int));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_v5_callback_set
|
||||
*
|
||||
* Set the connect callback. This is called when the library receives a CONNACK
|
||||
* message in response to a connection.
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_connect - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int rc)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* rc - the return code of the connection response. The values are defined by
|
||||
* the MQTT protocol version in use.
|
||||
* For MQTT v5.0, look at section 3.2.2.2 Connect Reason code: https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html
|
||||
* For MQTT v3.1.1, look at section 3.2.2.3 Connect Return code: http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/mqtt-v3.1.1.html
|
||||
* flags - the connect flags.
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_pre_connect_callback_set>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_connect_v5_callback_set(struct mosquitto *mosq, void (*on_connect)(struct mosquitto *, void *, int, int, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_pre_connect_callback_set
|
||||
*
|
||||
* Set the pre-connect callback. The pre-connect callback is called just before an attempt is made to connect to the broker. This may be useful if you are using <mosquitto_loop_start>, or
|
||||
* <mosquitto_loop_forever>, because when your client disconnects the library
|
||||
* will by default automatically reconnect. Using the pre-connect callback
|
||||
* allows you to set usernames, passwords, and TLS related parameters.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_pre_connect - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_pre_connect_callback_set(struct mosquitto *mosq, void (*on_pre_connect)(struct mosquitto *, void *));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_disconnect_callback_set
|
||||
*
|
||||
* Set the disconnect callback. This is called when the broker has received the
|
||||
* DISCONNECT command and has disconnected the client.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_disconnect - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* rc - integer value indicating the reason for the disconnect. A value of 0
|
||||
* means the client has called <mosquitto_disconnect>. Any other value
|
||||
* indicates that the disconnect is unexpected.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_disconnect_callback_set(struct mosquitto *mosq, void (*on_disconnect)(struct mosquitto *, void *, int));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_disconnect_v5_callback_set
|
||||
*
|
||||
* Set the disconnect callback. This is called when the broker has received the
|
||||
* DISCONNECT command and has disconnected the client.
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_disconnect - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* rc - integer value indicating the reason for the disconnect. A value of 0
|
||||
* means the client has called <mosquitto_disconnect>. Any other value
|
||||
* indicates that the disconnect is unexpected.
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_disconnect_v5_callback_set(struct mosquitto *mosq, void (*on_disconnect)(struct mosquitto *, void *, int, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_publish_callback_set
|
||||
*
|
||||
* Set the publish callback. This is called when a message initiated with
|
||||
* <mosquitto_publish> has been sent to the broker. "Sent" means different
|
||||
* things depending on the QoS of the message:
|
||||
*
|
||||
* QoS 0: The PUBLISH was passed to the local operating system for delivery,
|
||||
* there is no guarantee that it was delivered to the remote broker.
|
||||
* QoS 1: The PUBLISH was sent to the remote broker and the corresponding
|
||||
* PUBACK was received by the library.
|
||||
* QoS 2: The PUBLISH was sent to the remote broker and the corresponding
|
||||
* PUBCOMP was received by the library.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_publish - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the sent message.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_publish_callback_set(struct mosquitto *mosq, void (*on_publish)(struct mosquitto *, void *, int));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_publish_v5_callback_set
|
||||
*
|
||||
* Set the publish callback. This is called when a message initiated with
|
||||
* <mosquitto_publish> has been sent to the broker. This callback will be
|
||||
* called both if the message is sent successfully, or if the broker responded
|
||||
* with an error, which will be reflected in the reason_code parameter.
|
||||
* "Sent" means different things depending on the QoS of the message:
|
||||
*
|
||||
* QoS 0: The PUBLISH was passed to the local operating system for delivery,
|
||||
* there is no guarantee that it was delivered to the remote broker.
|
||||
* QoS 1: The PUBLISH was sent to the remote broker and the corresponding
|
||||
* PUBACK was received by the library.
|
||||
* QoS 2: The PUBLISH was sent to the remote broker and the corresponding
|
||||
* PUBCOMP was received by the library.
|
||||
*
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_publish - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the sent message.
|
||||
* reason_code - the MQTT 5 reason code
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_publish_v5_callback_set(struct mosquitto *mosq, void (*on_publish)(struct mosquitto *, void *, int, int, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_message_callback_set
|
||||
*
|
||||
* Set the message callback. This is called when a message is received from the
|
||||
* broker and the required QoS flow has completed.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_message - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* message - the message data. This variable and associated memory will be
|
||||
* freed by the library after the callback completes. The client
|
||||
* should make copies of any of the data it requires.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_message_copy>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_message_callback_set(struct mosquitto *mosq, void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_message_v5_callback_set
|
||||
*
|
||||
* Set the message callback. This is called when a message is received from the
|
||||
* broker and the required QoS flow has completed.
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_message - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* message - the message data. This variable and associated memory will be
|
||||
* freed by the library after the callback completes. The client
|
||||
* should make copies of any of the data it requires.
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_message_copy>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_message_v5_callback_set(struct mosquitto *mosq, void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe_callback_set
|
||||
*
|
||||
* Set the subscribe callback. This is called when the library receives a
|
||||
* SUBACK message in response to a SUBSCRIBE.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_subscribe - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid, int qos_count, const int *granted_qos)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the subscribe message.
|
||||
* qos_count - the number of granted subscriptions (size of granted_qos).
|
||||
* granted_qos - an array of integers indicating the granted QoS for each of
|
||||
* the subscriptions.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_subscribe_callback_set(struct mosquitto *mosq, void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe_v5_callback_set
|
||||
*
|
||||
* Set the subscribe callback. This is called when the library receives a
|
||||
* SUBACK message in response to a SUBSCRIBE.
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_subscribe - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid, int qos_count, const int *granted_qos)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the subscribe message.
|
||||
* qos_count - the number of granted subscriptions (size of granted_qos).
|
||||
* granted_qos - an array of integers indicating the granted QoS for each of
|
||||
* the subscriptions.
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_subscribe_v5_callback_set(struct mosquitto *mosq, void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_unsubscribe_callback_set
|
||||
*
|
||||
* Set the unsubscribe callback. This is called when the library receives a
|
||||
* UNSUBACK message in response to an UNSUBSCRIBE.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_unsubscribe - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the unsubscribe message.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_unsubscribe_callback_set(struct mosquitto *mosq, void (*on_unsubscribe)(struct mosquitto *, void *, int));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_unsubscribe_v5_callback_set
|
||||
*
|
||||
* Set the unsubscribe callback. This is called when the library receives a
|
||||
* UNSUBACK message in response to an UNSUBSCRIBE.
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_unsubscribe - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid, const mosquitto_property *props)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the unsubscribe message.
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_unsubscribe_v5_callback_set(struct mosquitto *mosq, void (*on_unsubscribe)(struct mosquitto *, void *, int, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_unsubscribe2_v5_callback_set
|
||||
*
|
||||
* Set the unsubscribe callback. This is called when the library receives a
|
||||
* UNSUBACK message in response to an UNSUBSCRIBE.
|
||||
*
|
||||
* It is valid to set this callback for all MQTT protocol versions. If it is
|
||||
* used with MQTT clients that use MQTT v3.1.1 or earlier, then the `props`
|
||||
* argument will always be NULL.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_unsubscribe - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int mid,
|
||||
* int reason_code_count, const int *reason_codes, const mosquitto_property *props)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* mid - the message id of the unsubscribe message.
|
||||
* reason_code_count - the count of reason code responses
|
||||
* reason_codes - an array of integers indicating the reason codes for each of
|
||||
* the unsubscription requests.
|
||||
* mid - the message id of the unsubscribe message.
|
||||
* props - list of MQTT 5 properties, or NULL
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_unsubscribe2_v5_callback_set(struct mosquitto *mosq, void (*on_unsubscribe)(struct mosquitto *, void *, int, int, const int *, const mosquitto_property *props));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_log_callback_set
|
||||
*
|
||||
* Set the logging callback. This should be used if you want event logging
|
||||
* information from the client library.
|
||||
*
|
||||
* mosq - a valid mosquitto instance.
|
||||
* on_log - a callback function in the following form:
|
||||
* void callback(struct mosquitto *mosq, void *obj, int level, const char *str)
|
||||
*
|
||||
* Callback Parameters:
|
||||
* mosq - the mosquitto instance making the callback.
|
||||
* obj - the user data provided in <mosquitto_new>
|
||||
* level - the log message level from the values:
|
||||
* MOSQ_LOG_INFO
|
||||
* MOSQ_LOG_NOTICE
|
||||
* MOSQ_LOG_WARNING
|
||||
* MOSQ_LOG_ERR
|
||||
* MOSQ_LOG_DEBUG
|
||||
* str - the message string.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_log_callback_set(struct mosquitto *mosq, void (*on_log)(struct mosquitto *, void *, int, const char *));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,372 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_CONNECT_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_CONNECT_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_connect.h
|
||||
*
|
||||
* This header contains functions for connect/disconnecting/reconnectng clients in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Connecting, reconnecting, disconnecting
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_connect
|
||||
*
|
||||
* Connect to an MQTT broker.
|
||||
*
|
||||
* It is valid to use this function for clients using all MQTT protocol versions.
|
||||
* If you need to set MQTT v5 CONNECT properties, use <mosquitto_connect_bind_v5>
|
||||
* instead.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the hostname or ip address of the broker to connect to.
|
||||
* port - the network port to connect to. Usually 1883.
|
||||
* keepalive - the number of seconds after which the client should send a PING
|
||||
* message to the broker if no other messages have been exchanged
|
||||
* in that time.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid, which could be any of:
|
||||
* * mosq == NULL
|
||||
* * host == NULL
|
||||
* * port < 0
|
||||
* * keepalive < 5
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect_bind>, <mosquitto_connect_async>, <mosquitto_reconnect>, <mosquitto_disconnect>, <mosquitto_tls_set>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_connect(struct mosquitto *mosq, const char *host, int port, int keepalive);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_bind
|
||||
*
|
||||
* Connect to an MQTT broker. This extends the functionality of
|
||||
* <mosquitto_connect> by adding the bind_address parameter. Use this function
|
||||
* if you need to restrict network communication over a particular interface.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the hostname or ip address of the broker to connect to.
|
||||
* port - the network port to connect to. Usually 1883.
|
||||
* keepalive - the number of seconds after which the client should send a PING
|
||||
* message to the broker if no other messages have been exchanged
|
||||
* in that time.
|
||||
* bind_address - the hostname or ip address of the local network interface to
|
||||
* bind to. If you do not want to bind to a specific interface,
|
||||
* set this to NULL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect>, <mosquitto_connect_async>, <mosquitto_connect_bind_async>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_connect_bind(struct mosquitto *mosq, const char *host, int port, int keepalive, const char *bind_address);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_bind_v5
|
||||
*
|
||||
* Connect to an MQTT broker. This extends the functionality of
|
||||
* <mosquitto_connect> by adding the bind_address parameter and MQTT v5
|
||||
* properties. Use this function if you need to restrict network communication
|
||||
* over a particular interface.
|
||||
*
|
||||
* Use e.g. <mosquitto_property_add_string> and similar to create a list of
|
||||
* properties, then attach them to this publish. Properties need freeing with
|
||||
* <mosquitto_property_free_all>.
|
||||
*
|
||||
* If the mosquitto instance `mosq` is using MQTT v5, the `properties` argument
|
||||
* will be applied to the CONNECT message. For MQTT v3.1.1 and below, the
|
||||
* `properties` argument will be ignored.
|
||||
*
|
||||
* Set your client to use MQTT v5 immediately after it is created:
|
||||
*
|
||||
* mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the hostname or ip address of the broker to connect to.
|
||||
* port - the network port to connect to. Usually 1883.
|
||||
* keepalive - the number of seconds after which the client should send a PING
|
||||
* message to the broker if no other messages have been exchanged
|
||||
* in that time.
|
||||
* bind_address - the hostname or ip address of the local network interface to
|
||||
* bind to. If you do not want to bind to a specific interface,
|
||||
* set this to NULL.
|
||||
* properties - the MQTT 5 properties for the connect (not for the Will).
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid, which could be any of:
|
||||
* * mosq == NULL
|
||||
* * host == NULL
|
||||
* * port < 0
|
||||
* * keepalive < 5
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
* MOSQ_ERR_DUPLICATE_PROPERTY - if a property is duplicated where it is forbidden.
|
||||
* MOSQ_ERR_PROTOCOL - if any property is invalid for use with CONNECT.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect>, <mosquitto_connect_async>, <mosquitto_connect_bind_async>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_connect_bind_v5(struct mosquitto *mosq, const char *host, int port, int keepalive, const char *bind_address, const mosquitto_property *properties);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_async
|
||||
*
|
||||
* Connect to an MQTT broker. This is a non-blocking call. If you use
|
||||
* <mosquitto_connect_async> your client must use the threaded interface
|
||||
* <mosquitto_loop_start>. If you need to use <mosquitto_loop>, you must use
|
||||
* <mosquitto_connect> to connect the client.
|
||||
*
|
||||
* May be called before or after <mosquitto_loop_start>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the hostname or ip address of the broker to connect to.
|
||||
* port - the network port to connect to. Usually 1883.
|
||||
* keepalive - the number of seconds after which the client should send a PING
|
||||
* message to the broker if no other messages have been exchanged
|
||||
* in that time.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect_bind_async>, <mosquitto_connect>, <mosquitto_reconnect>, <mosquitto_disconnect>, <mosquitto_tls_set>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_connect_async(struct mosquitto *mosq, const char *host, int port, int keepalive);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_bind_async
|
||||
*
|
||||
* Connect to an MQTT broker. This is a non-blocking call. If you use
|
||||
* <mosquitto_connect_bind_async> your client must use the threaded interface
|
||||
* <mosquitto_loop_start>. If you need to use <mosquitto_loop>, you must use
|
||||
* <mosquitto_connect> to connect the client.
|
||||
*
|
||||
* This extends the functionality of <mosquitto_connect_async> by adding the
|
||||
* bind_address parameter. Use this function if you need to restrict network
|
||||
* communication over a particular interface.
|
||||
*
|
||||
* May be called before or after <mosquitto_loop_start>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the hostname or ip address of the broker to connect to.
|
||||
* port - the network port to connect to. Usually 1883.
|
||||
* keepalive - the number of seconds after which the client should send a PING
|
||||
* message to the broker if no other messages have been exchanged
|
||||
* in that time.
|
||||
* bind_address - the hostname or ip address of the local network interface to
|
||||
* bind to. If you do not want to bind to a specific interface,
|
||||
* set this to NULL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid, which could be any of:
|
||||
* * mosq == NULL
|
||||
* * host == NULL
|
||||
* * port < 0
|
||||
* * keepalive < 5
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect_async>, <mosquitto_connect>, <mosquitto_connect_bind>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_connect_bind_async(struct mosquitto *mosq, const char *host, int port, int keepalive, const char *bind_address);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_connect_srv
|
||||
*
|
||||
* Connect to an MQTT broker.
|
||||
*
|
||||
* If you set `host` to `example.com`, then this call will attempt to retrieve
|
||||
* the DNS SRV record for `_secure-mqtt._tcp.example.com` or
|
||||
* `_mqtt._tcp.example.com` to discover which actual host to connect to.
|
||||
*
|
||||
* DNS SRV support is not usually compiled in to libmosquitto, use of this call
|
||||
* is not recommended.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the hostname to search for an SRV record.
|
||||
* keepalive - the number of seconds after which the client should send a PING
|
||||
* message to the broker if no other messages have been exchanged
|
||||
* in that time.
|
||||
* bind_address - the hostname or ip address of the local network interface to
|
||||
* bind to. If you do not want to bind to a specific interface,
|
||||
* set this to NULL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid, which could be any of:
|
||||
* * mosq == NULL
|
||||
* * host == NULL
|
||||
* * port < 0
|
||||
* * keepalive < 5
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect_async>, <mosquitto_connect>, <mosquitto_connect_bind>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_connect_srv(struct mosquitto *mosq, const char *host, int keepalive, const char *bind_address);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_reconnect
|
||||
*
|
||||
* Reconnect to a broker.
|
||||
*
|
||||
* This function provides an easy way of reconnecting to a broker after a
|
||||
* connection has been lost. It uses the values that were provided in the
|
||||
* <mosquitto_connect> call. It must not be called before
|
||||
* <mosquitto_connect>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect>, <mosquitto_disconnect>, <mosquitto_reconnect_async>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_reconnect(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_reconnect_async
|
||||
*
|
||||
* Reconnect to a broker. Non blocking version of <mosquitto_reconnect>.
|
||||
*
|
||||
* This function provides an easy way of reconnecting to a broker after a
|
||||
* connection has been lost. It uses the values that were provided in the
|
||||
* <mosquitto_connect> or <mosquitto_connect_async> calls. It must not be
|
||||
* called before <mosquitto_connect>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect>, <mosquitto_disconnect>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_reconnect_async(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_disconnect
|
||||
*
|
||||
* Disconnect from the broker.
|
||||
*
|
||||
* It is valid to use this function for clients using all MQTT protocol versions.
|
||||
* If you need to set MQTT v5 DISCONNECT properties, use
|
||||
* <mosquitto_disconnect_v5> instead.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_disconnect(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_disconnect_v5
|
||||
*
|
||||
* Disconnect from the broker, with attached MQTT properties.
|
||||
*
|
||||
* Use e.g. <mosquitto_property_add_string> and similar to create a list of
|
||||
* properties, then attach them to this publish. Properties need freeing with
|
||||
* <mosquitto_property_free_all>.
|
||||
*
|
||||
* If the mosquitto instance `mosq` is using MQTT v5, the `properties` argument
|
||||
* will be applied to the DISCONNECT message. For MQTT v3.1.1 and below, the
|
||||
* `properties` argument will be ignored.
|
||||
*
|
||||
* Set your client to use MQTT v5 immediately after it is created:
|
||||
*
|
||||
* mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* reason_code - the disconnect reason code.
|
||||
* properties - a valid mosquitto_property list, or NULL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_DUPLICATE_PROPERTY - if a property is duplicated where it is forbidden.
|
||||
* MOSQ_ERR_PROTOCOL - if any property is invalid for use with DISCONNECT.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_disconnect_v5(struct mosquitto *mosq, int reason_code, const mosquitto_property *properties);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,114 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_CREATE_DELETE_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_CREATE_DELETE_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_create_delete.h
|
||||
*
|
||||
* This header contains functions for creating/deleting/reinitialising mosquitto clients.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Client creation, destruction, and reinitialisation
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_new
|
||||
*
|
||||
* Create a new mosquitto client instance.
|
||||
*
|
||||
* Parameters:
|
||||
* id - String to use as the client id. If NULL, a random client id
|
||||
* will be generated. If id is NULL, clean_session must be true.
|
||||
* clean_session - set to true to instruct the broker to clean all messages
|
||||
* and subscriptions on disconnect, false to instruct it to
|
||||
* keep them. See the man page mqtt(7) for more details.
|
||||
* Note that a client will never discard its own outgoing
|
||||
* messages on disconnect. Calling <mosquitto_connect> or
|
||||
* <mosquitto_reconnect> will cause the messages to be resent.
|
||||
* Use <mosquitto_reinitialise> to reset a client to its
|
||||
* original state.
|
||||
* Must be set to true if the id parameter is NULL.
|
||||
* obj - A user pointer that will be passed as an argument to any
|
||||
* callbacks that are specified.
|
||||
*
|
||||
* Returns:
|
||||
* Pointer to a struct mosquitto on success.
|
||||
* NULL on failure. Interrogate errno to determine the cause for the failure:
|
||||
* - ENOMEM on out of memory.
|
||||
* - EINVAL on invalid input parameters.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_reinitialise>, <mosquitto_destroy>, <mosquitto_user_data_set>
|
||||
*/
|
||||
libmosq_EXPORT struct mosquitto *mosquitto_new(const char *id, bool clean_session, void *obj);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_destroy
|
||||
*
|
||||
* Use to free memory associated with a mosquitto client instance.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a struct mosquitto pointer to free.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_new>, <mosquitto_reinitialise>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_destroy(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_reinitialise
|
||||
*
|
||||
* This function allows an existing mosquitto client to be reused. Call on a
|
||||
* mosquitto instance to close any open network connections, free memory
|
||||
* and reinitialise the client with the new parameters. The end result is the
|
||||
* same as the output of <mosquitto_new>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* id - string to use as the client id. If NULL, a random client id
|
||||
* will be generated. If id is NULL, clean_session must be true.
|
||||
* clean_session - set to true to instruct the broker to clean all messages
|
||||
* and subscriptions on disconnect, false to instruct it to
|
||||
* keep them. See the man page mqtt(7) for more details.
|
||||
* Must be set to true if the id parameter is NULL.
|
||||
* obj - A user pointer that will be passed as an argument to any
|
||||
* callbacks that are specified.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the client id is not valid UTF-8.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_new>, <mosquitto_destroy>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_reinitialise(struct mosquitto *mosq, const char *id, bool clean_session, void *obj);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,169 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_HELPERS_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_HELPERS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <mosquitto/defs.h>
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
|
||||
/* =============================================================================
|
||||
*
|
||||
* Section: One line client helper functions
|
||||
*
|
||||
* =============================================================================
|
||||
*/
|
||||
|
||||
struct libmosquitto_will {
|
||||
char *topic;
|
||||
void *payload;
|
||||
int payloadlen;
|
||||
int qos;
|
||||
bool retain;
|
||||
};
|
||||
|
||||
struct libmosquitto_auth {
|
||||
char *username;
|
||||
char *password;
|
||||
};
|
||||
|
||||
struct libmosquitto_tls {
|
||||
char *cafile;
|
||||
char *capath;
|
||||
char *certfile;
|
||||
char *keyfile;
|
||||
char *ciphers;
|
||||
char *tls_version;
|
||||
int (*pw_callback)(char *buf, int size, int rwflag, void *userdata);
|
||||
int cert_reqs;
|
||||
};
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe_simple
|
||||
*
|
||||
* Helper function to make subscribing to a topic and retrieving some messages
|
||||
* very straightforward.
|
||||
*
|
||||
* This connects to a broker, subscribes to a topic, waits for msg_count
|
||||
* messages to be received, then returns after disconnecting cleanly.
|
||||
*
|
||||
* Parameters:
|
||||
* messages - pointer to a "struct mosquitto_message *". The received
|
||||
* messages will be returned here. On error, this will be set to
|
||||
* NULL.
|
||||
* msg_count - the number of messages to retrieve.
|
||||
* want_retained - if set to true, stale retained messages will be treated as
|
||||
* normal messages with regards to msg_count. If set to
|
||||
* false, they will be ignored.
|
||||
* topic - the subscription topic to use (wildcards are allowed).
|
||||
* qos - the qos to use for the subscription.
|
||||
* host - the broker to connect to.
|
||||
* port - the network port the broker is listening on.
|
||||
* clientid - the client id to use, or NULL if a random client id should be
|
||||
* generated.
|
||||
* keepalive - the MQTT keepalive value.
|
||||
* clean_session - the MQTT clean session flag.
|
||||
* username - the username string, or NULL for no username authentication.
|
||||
* password - the password string, or NULL for an empty password.
|
||||
* will - a libmosquitto_will struct containing will information, or NULL for
|
||||
* no will.
|
||||
* tls - a libmosquitto_tls struct containing TLS related parameters, or NULL
|
||||
* for no use of TLS.
|
||||
*
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* Greater than 0 - on error.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_subscribe_simple(
|
||||
struct mosquitto_message **messages,
|
||||
int msg_count,
|
||||
bool want_retained,
|
||||
const char *topic,
|
||||
int qos,
|
||||
const char *host,
|
||||
int port,
|
||||
const char *clientid,
|
||||
int keepalive,
|
||||
bool clean_session,
|
||||
const char *username,
|
||||
const char *password,
|
||||
const struct libmosquitto_will *will,
|
||||
const struct libmosquitto_tls *tls);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe_callback
|
||||
*
|
||||
* Helper function to make subscribing to a topic and processing some messages
|
||||
* very straightforward.
|
||||
*
|
||||
* This connects to a broker, subscribes to a topic, then passes received
|
||||
* messages to a user provided callback. If the callback returns a 1, it then
|
||||
* disconnects cleanly and returns.
|
||||
*
|
||||
* Parameters:
|
||||
* callback - a callback function in the following form:
|
||||
* int callback(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message)
|
||||
* Note that this is the same as the normal on_message callback,
|
||||
* except that it returns an int.
|
||||
* userdata - user provided pointer that will be passed to the callback.
|
||||
* topic - the subscription topic to use (wildcards are allowed).
|
||||
* qos - the qos to use for the subscription.
|
||||
* host - the broker to connect to.
|
||||
* port - the network port the broker is listening on.
|
||||
* clientid - the client id to use, or NULL if a random client id should be
|
||||
* generated.
|
||||
* keepalive - the MQTT keepalive value.
|
||||
* clean_session - the MQTT clean session flag.
|
||||
* username - the username string, or NULL for no username authentication.
|
||||
* password - the password string, or NULL for an empty password.
|
||||
* will - a libmosquitto_will struct containing will information, or NULL for
|
||||
* no will.
|
||||
* tls - a libmosquitto_tls struct containing TLS related parameters, or NULL
|
||||
* for no use of TLS.
|
||||
*
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success
|
||||
* Greater than 0 - on error.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_subscribe_callback(
|
||||
int (*callback)(struct mosquitto *, void *, const struct mosquitto_message *),
|
||||
void *userdata,
|
||||
const char *topic,
|
||||
int qos,
|
||||
const char *host,
|
||||
int port,
|
||||
const char *clientid,
|
||||
int keepalive,
|
||||
bool clean_session,
|
||||
const char *username,
|
||||
const char *password,
|
||||
const struct libmosquitto_will *will,
|
||||
const struct libmosquitto_tls *tls);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,322 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_LOOP_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_LOOP_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_loop.h
|
||||
*
|
||||
* This header contains functions for handling the libmosquitto network loop.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <mosquitto/defs.h>
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Network loop (managed by libmosquitto)
|
||||
*
|
||||
* The internal network loop must be called at a regular interval. The two
|
||||
* recommended approaches are to use either <mosquitto_loop_forever> or
|
||||
* <mosquitto_loop_start>. <mosquitto_loop_forever> is a blocking call and is
|
||||
* suitable for the situation where you only want to handle incoming messages
|
||||
* in callbacks. <mosquitto_loop_start> is a non-blocking call, it creates a
|
||||
* separate thread to run the loop for you. Use this function when you have
|
||||
* other tasks you need to run at the same time as the MQTT client, e.g.
|
||||
* reading data from a sensor.
|
||||
*
|
||||
* ====================================================================== */
|
||||
|
||||
/*
|
||||
* Function: mosquitto_loop_forever
|
||||
*
|
||||
* This function call loop() for you in an infinite blocking loop. It is useful
|
||||
* for the case where you only want to run the MQTT client loop in your
|
||||
* program.
|
||||
*
|
||||
* It handles reconnecting in case server connection is lost. If you call
|
||||
* mosquitto_disconnect() in a callback it will return.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* timeout - Maximum number of milliseconds to wait for network activity
|
||||
* in the select() call before timing out. Set to 0 for instant
|
||||
* return. Set negative to use the default of 1000ms.
|
||||
* max_packets - this parameter is currently unused and should be set to 1 for
|
||||
* future compatibility.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
|
||||
* MOSQ_ERR_PROTOCOL - if there is a protocol error communicating with the
|
||||
* broker.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_loop>, <mosquitto_loop_start>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop_forever(struct mosquitto *mosq, int timeout, int max_packets);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_loop_start
|
||||
*
|
||||
* This is part of the threaded client interface. Call this once to start a new
|
||||
* thread to process network traffic. This provides an alternative to
|
||||
* repeatedly calling <mosquitto_loop> yourself.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOT_SUPPORTED - if thread support is not available.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_connect_async>, <mosquitto_loop>, <mosquitto_loop_forever>, <mosquitto_loop_stop>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop_start(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_loop_stop
|
||||
*
|
||||
* This is part of the threaded client interface. Call this once to stop the
|
||||
* network thread previously created with <mosquitto_loop_start>. This call
|
||||
* will block until the network thread finishes. For the network thread to end,
|
||||
* you must have previously called <mosquitto_disconnect> or have set the force
|
||||
* parameter to true.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* force - set to true to force thread cancellation. If false,
|
||||
* <mosquitto_disconnect> must have already been called.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOT_SUPPORTED - if thread support is not available.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_loop>, <mosquitto_loop_start>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop_stop(struct mosquitto *mosq, bool force);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_loop
|
||||
*
|
||||
* The main network loop for the client. This must be called frequently
|
||||
* to keep communications between the client and broker working. This is
|
||||
* carried out by <mosquitto_loop_forever> and <mosquitto_loop_start>, which
|
||||
* are the recommended ways of handling the network loop. You may also use this
|
||||
* function if you wish. It must not be called inside a callback.
|
||||
*
|
||||
* If incoming data is present it will then be processed. Outgoing commands,
|
||||
* from e.g. <mosquitto_publish>, are normally sent immediately that their
|
||||
* function is called, but this is not always possible. <mosquitto_loop> will
|
||||
* also attempt to send any remaining outgoing messages, which also includes
|
||||
* commands that are part of the flow for messages with QoS>0.
|
||||
*
|
||||
* This calls select() to monitor the client network socket. If you want to
|
||||
* integrate mosquitto client operation with your own select() call, use
|
||||
* <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_write> and
|
||||
* <mosquitto_loop_misc>.
|
||||
*
|
||||
* Threads:
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* timeout - Maximum number of milliseconds to wait for network activity
|
||||
* in the select() call before timing out. Set to 0 for instant
|
||||
* return. Set negative to use the default of 1000ms.
|
||||
* max_packets - this parameter is currently unused and should be set to 1 for
|
||||
* future compatibility.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
|
||||
* MOSQ_ERR_PROTOCOL - if there is a protocol error communicating with the
|
||||
* broker.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
* See Also:
|
||||
* <mosquitto_loop_forever>, <mosquitto_loop_start>, <mosquitto_loop_stop>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop(struct mosquitto *mosq, int timeout, int max_packets);
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Network loop (for use in other event loops)
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_loop_read
|
||||
*
|
||||
* Carry out network read operations.
|
||||
* This should only be used if you are not using mosquitto_loop() and are
|
||||
* monitoring the client network socket for activity yourself.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* max_packets - this parameter is currently unused and should be set to 1 for
|
||||
* future compatibility.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
|
||||
* MOSQ_ERR_PROTOCOL - if there is a protocol error communicating with the
|
||||
* broker.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_socket>, <mosquitto_loop_write>, <mosquitto_loop_misc>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop_read(struct mosquitto *mosq, int max_packets);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_loop_write
|
||||
*
|
||||
* Carry out network write operations.
|
||||
* This should only be used if you are not using mosquitto_loop() and are
|
||||
* monitoring the client network socket for activity yourself.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* max_packets - this parameter is currently unused and should be set to 1 for
|
||||
* future compatibility.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_CONN_LOST - if the connection to the broker was lost.
|
||||
* MOSQ_ERR_PROTOCOL - if there is a protocol error communicating with the
|
||||
* broker.
|
||||
* MOSQ_ERR_ERRNO - if a system call returned an error. The variable errno
|
||||
* contains the error code, even on Windows.
|
||||
* Use strerror_r() where available or FormatMessage() on
|
||||
* Windows.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_misc>, <mosquitto_want_write>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop_write(struct mosquitto *mosq, int max_packets);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_loop_misc
|
||||
*
|
||||
* Carry out miscellaneous operations required as part of the network loop.
|
||||
* This should only be used if you are not using mosquitto_loop() and are
|
||||
* monitoring the client network socket for activity yourself.
|
||||
*
|
||||
* This function deals with handling PINGs and checking whether messages need
|
||||
* to be retried, so should be called fairly frequently, around once per second
|
||||
* is sufficient.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_write>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_loop_misc(struct mosquitto *mosq);
|
||||
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Network loop (helper functions)
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_socket
|
||||
*
|
||||
* Return the socket handle for a mosquitto instance. Useful if you want to
|
||||
* include a mosquitto client in your own select() calls.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* The socket for the mosquitto client or -1 on failure.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_socket(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_want_write
|
||||
*
|
||||
* Returns true if there is data ready to be written on the socket.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_socket>, <mosquitto_loop_read>, <mosquitto_loop_write>
|
||||
*/
|
||||
libmosq_EXPORT bool mosquitto_want_write(struct mosquitto *mosq);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_threaded_set
|
||||
*
|
||||
* Used to tell the library that your application is using threads, but not
|
||||
* using <mosquitto_loop_start>. The library operates slightly differently when
|
||||
* not in threaded mode in order to simplify its operation. If you are managing
|
||||
* your own threads and do not use this function you will experience crashes
|
||||
* due to race conditions.
|
||||
*
|
||||
* When using <mosquitto_loop_start>, this is set automatically.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* threaded - true if your application is using threads, false otherwise.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_threaded_set(struct mosquitto *mosq, bool threaded);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,86 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_MESSAGE_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_MESSAGE_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_message.h
|
||||
*
|
||||
* This header contains functions for handling mosquitto_message structs.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Struct mosquitto_message helper functions
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_message_copy
|
||||
*
|
||||
* Copy the contents of a mosquitto message to another message.
|
||||
* Useful for preserving a message received in the on_message() callback.
|
||||
*
|
||||
* Parameters:
|
||||
* dst - a pointer to a valid mosquitto_message struct to copy to.
|
||||
* src - a pointer to a valid mosquitto_message struct to copy from.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_message_free>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_message_copy(struct mosquitto_message *dst, const struct mosquitto_message *src);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_message_free
|
||||
*
|
||||
* Completely free a mosquitto_message struct.
|
||||
*
|
||||
* Parameters:
|
||||
* message - pointer to a mosquitto_message pointer to free.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_message_copy>, <mosquitto_message_free_contents>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_message_free(struct mosquitto_message **message);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_message_free_contents
|
||||
*
|
||||
* Free a mosquitto_message struct contents, leaving the struct unaffected.
|
||||
*
|
||||
* Parameters:
|
||||
* message - pointer to a mosquitto_message struct to free its contents.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_message_copy>, <mosquitto_message_free>
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_message_free_contents(struct mosquitto_message *message);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,321 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_OPTIONS_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_OPTIONS_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_options.h
|
||||
*
|
||||
* This header contains functions for setting client options in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Client options
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_opts_set
|
||||
*
|
||||
* Used to set options for the client.
|
||||
*
|
||||
* This function is deprecated, the replacement <mosquitto_int_option>,
|
||||
* <mosquitto_string_option> and <mosquitto_void_option> functions should
|
||||
* be used instead.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* option - the option to set.
|
||||
* value - the option specific value.
|
||||
*
|
||||
* Options:
|
||||
* MOSQ_OPT_PROTOCOL_VERSION - Value must be an int, set to either
|
||||
* MQTT_PROTOCOL_V31 or MQTT_PROTOCOL_V311. Must be set
|
||||
* before the client connects.
|
||||
* Defaults to MQTT_PROTOCOL_V31.
|
||||
*
|
||||
* MOSQ_OPT_SSL_CTX - Pass an openssl SSL_CTX to be used when creating
|
||||
* TLS connections rather than libmosquitto creating its own.
|
||||
* This must be called before connecting to have any effect.
|
||||
* If you use this option, the onus is on you to ensure that
|
||||
* you are using secure settings.
|
||||
* Setting to NULL means that libmosquitto will use its own SSL_CTX
|
||||
* if TLS is to be used.
|
||||
* This option is only available for openssl 1.1.0 and higher.
|
||||
*
|
||||
* MOSQ_OPT_SSL_CTX_WITH_DEFAULTS - Value must be an int set to 1 or 0.
|
||||
* If set to 1, then the user specified SSL_CTX passed in using
|
||||
* MOSQ_OPT_SSL_CTX will have the default options applied to it.
|
||||
* This means that you only need to change the values that are
|
||||
* relevant to you. If you use this option then you must configure
|
||||
* the TLS options as normal, i.e. you should use
|
||||
* <mosquitto_tls_set> to configure the cafile/capath as a minimum.
|
||||
* This option is only available for openssl 1.1.0 and higher.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_opts_set(struct mosquitto *mosq, enum mosq_opt_t option, void *value);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_int_option
|
||||
*
|
||||
* Used to set integer options for the client.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* option - the option to set.
|
||||
* value - the option specific value.
|
||||
*
|
||||
* Options:
|
||||
* MOSQ_OPT_TCP_NODELAY - Set to 1 to disable Nagle's algorithm on client
|
||||
* sockets. This has the effect of reducing latency of individual
|
||||
* messages at the potential cost of increasing the number of
|
||||
* packets being sent.
|
||||
* Defaults to 0, which means Nagle remains enabled.
|
||||
*
|
||||
* MOSQ_OPT_PROTOCOL_VERSION - Value must be set to either MQTT_PROTOCOL_V31,
|
||||
* MQTT_PROTOCOL_V311, or MQTT_PROTOCOL_V5. Must be set before the
|
||||
* client connects. Defaults to MQTT_PROTOCOL_V311.
|
||||
*
|
||||
* MOSQ_OPT_RECEIVE_MAXIMUM - Value can be set between 1 and 65535 inclusive,
|
||||
* and represents the maximum number of incoming QoS 1 and QoS 2
|
||||
* messages that this client wants to process at once. Defaults to
|
||||
* 20. This option is not valid for MQTT v3.1 or v3.1.1 clients.
|
||||
* Note that if the MQTT_PROP_RECEIVE_MAXIMUM property is in the
|
||||
* proplist passed to mosquitto_connect_v5(), then that property
|
||||
* will override this option. Using this option is the recommended
|
||||
* method however.
|
||||
*
|
||||
* MOSQ_OPT_SEND_MAXIMUM - Value can be set between 1 and 65535 inclusive,
|
||||
* and represents the maximum number of outgoing QoS 1 and QoS 2
|
||||
* messages that this client will attempt to have "in flight" at
|
||||
* once. Defaults to 20.
|
||||
* This option is not valid for MQTT v3.1 or v3.1.1 clients.
|
||||
* Note that if the broker being connected to sends a
|
||||
* MQTT_PROP_RECEIVE_MAXIMUM property that has a lower value than
|
||||
* this option, then the broker provided value will be used.
|
||||
*
|
||||
* MOSQ_OPT_SSL_CTX_WITH_DEFAULTS - If value is set to a non zero value,
|
||||
* then the user specified SSL_CTX passed in using MOSQ_OPT_SSL_CTX
|
||||
* will have the default options applied to it. This means that
|
||||
* you only need to change the values that are relevant to you.
|
||||
* If you use this option then you must configure the TLS options
|
||||
* as normal, i.e. you should use <mosquitto_tls_set> to
|
||||
* configure the cafile/capath as a minimum.
|
||||
* This option is only available for openssl 1.1.0 and higher.
|
||||
*
|
||||
* MOSQ_OPT_TLS_OCSP_REQUIRED - Set whether OCSP checking on TLS
|
||||
* connections is required. Set to 1 to enable checking,
|
||||
* or 0 (the default) for no checking.
|
||||
*
|
||||
* MOSQ_OPT_TLS_USE_OS_CERTS - Set to 1 to instruct the client to load and
|
||||
* trust OS provided CA certificates for use with TLS connections.
|
||||
* Set to 0 (the default) to only use manually specified CA certs.
|
||||
*
|
||||
* MOSQ_OPT_DISABLE_SOCKETPAIR - By default, each client connected will create
|
||||
* an internal pair of connected sockets to allow the network thread
|
||||
* to be notified and woken up if another thread calls
|
||||
* <mosquitto_publish> or other similar command. If you are
|
||||
* operating with an external loop, this is not necessary and
|
||||
* consumes an extra two sockets per client. Set this option to 1 to
|
||||
* disable the use of the socket pair.
|
||||
*
|
||||
* MOSQ_OPT_TRANSPORT - Have the client connect with either MQTT over TCP as
|
||||
* normal, or MQTT over WebSockets. Set the value to MOSQ_T_TCP or
|
||||
* MOSQ_T_WEBSOCKETS.
|
||||
*
|
||||
* MOSQ_OPT_HTTP_HEADER_SIZE - Size the size of buffer that will be allocated
|
||||
* to store the incoming HTTP header when using Websocket transport.
|
||||
* Defaults to 4096. Setting to below 100 will result in a return
|
||||
* value of MOSQ_ERR_INVAL. This should be set before starting the
|
||||
* connection. If you try to set this when the initial http request
|
||||
* is underway then it will return MOSQ_ERR_INVAL.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_int_option(struct mosquitto *mosq, enum mosq_opt_t option, int value);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_string_option
|
||||
*
|
||||
* Used to set const char* options for the client.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* option - the option to set.
|
||||
* value - the option specific value.
|
||||
*
|
||||
* Options:
|
||||
* MOSQ_OPT_TLS_ENGINE - Configure the client for TLS Engine support.
|
||||
* Pass a TLS Engine ID to be used when creating TLS
|
||||
* connections. Must be set before <mosquitto_connect>.
|
||||
* Must be a valid engine, and note that the string will not be used
|
||||
* until a connection attempt is made so this function will return
|
||||
* success even if an invalid engine string is passed.
|
||||
*
|
||||
* MOSQ_OPT_TLS_KEYFORM - Configure the client to treat the keyfile
|
||||
* differently depending on its type. Must be set
|
||||
* before <mosquitto_connect>.
|
||||
* Set as either "pem" or "engine", to determine from where the
|
||||
* private key for a TLS connection will be obtained. Defaults to
|
||||
* "pem", a normal private key file.
|
||||
*
|
||||
* MOSQ_OPT_TLS_KPASS_SHA1 - Where the TLS Engine requires the use of
|
||||
* a password to be accessed, this option allows a hex encoded
|
||||
* SHA1 hash of the private key password to be passed to the
|
||||
* engine directly. Must be set before <mosquitto_connect>.
|
||||
*
|
||||
* MOSQ_OPT_TLS_ALPN - If the broker being connected to has multiple
|
||||
* services available on a single TLS port, such as both MQTT
|
||||
* and WebSockets, use this option to configure the ALPN
|
||||
* option for the connection.
|
||||
*
|
||||
* MOSQ_OPT_BIND_ADDRESS - Set the hostname or ip address of the local network
|
||||
* interface to bind to when connecting.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, const char *value);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_void_option
|
||||
*
|
||||
* Used to set void* options for the client.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* option - the option to set.
|
||||
* value - the option specific value.
|
||||
*
|
||||
* Options:
|
||||
* MOSQ_OPT_SSL_CTX - Pass an openssl SSL_CTX to be used when creating TLS
|
||||
* connections rather than libmosquitto creating its own. This must
|
||||
* be called before connecting to have any effect. If you use this
|
||||
* option, the onus is on you to ensure that you are using secure
|
||||
* settings.
|
||||
* Setting to NULL means that libmosquitto will use its own SSL_CTX
|
||||
* if TLS is to be used.
|
||||
* This option is only available for openssl 1.1.0 and higher.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_void_option(struct mosquitto *mosq, enum mosq_opt_t option, void *value);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_reconnect_delay_set
|
||||
*
|
||||
* Control the behaviour of the client when it has unexpectedly disconnected in
|
||||
* <mosquitto_loop_forever> or after <mosquitto_loop_start>. The default
|
||||
* behaviour if this function is not used is to repeatedly attempt to reconnect
|
||||
* with a delay of 1 second until the connection succeeds.
|
||||
*
|
||||
* Use reconnect_delay parameter to change the delay between successive
|
||||
* reconnection attempts. You may also enable exponential backoff of the time
|
||||
* between reconnections by setting reconnect_exponential_backoff to true and
|
||||
* set an upper bound on the delay with reconnect_delay_max.
|
||||
*
|
||||
* Example 1:
|
||||
* delay=2, delay_max=10, exponential_backoff=False
|
||||
* Delays would be: 2, 4, 6, 8, 10, 10, ...
|
||||
*
|
||||
* Example 2:
|
||||
* delay=3, delay_max=30, exponential_backoff=True
|
||||
* Delays would be: 3, 6, 12, 24, 30, 30, ...
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* reconnect_delay - the number of seconds to wait between
|
||||
* reconnects.
|
||||
* reconnect_delay_max - the maximum number of seconds to wait
|
||||
* between reconnects.
|
||||
* reconnect_exponential_backoff - use exponential backoff between
|
||||
* reconnect attempts. Set to true to enable
|
||||
* exponential backoff.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_reconnect_delay_set(struct mosquitto *mosq, unsigned int reconnect_delay, unsigned int reconnect_delay_max, bool reconnect_exponential_backoff);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_max_inflight_messages_set
|
||||
*
|
||||
* This function is deprected. Use the <mosquitto_int_option> function with the
|
||||
* MOSQ_OPT_SEND_MAXIMUM option instead.
|
||||
*
|
||||
* Set the number of QoS 1 and 2 messages that can be "in flight" at one time.
|
||||
* An in flight message is part way through its delivery flow. Attempts to send
|
||||
* further messages with <mosquitto_publish> will result in the messages being
|
||||
* queued until the number of in flight messages reduces.
|
||||
*
|
||||
* A higher number here results in greater message throughput, but if set
|
||||
* higher than the maximum in flight messages on the broker may lead to
|
||||
* delays in the messages being acknowledged.
|
||||
*
|
||||
* Set to 0 for no maximum.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* max_inflight_messages - the maximum number of inflight messages. Defaults
|
||||
* to 20.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_max_inflight_messages_set(struct mosquitto *mosq, unsigned int max_inflight_messages);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_message_retry_set
|
||||
*
|
||||
* This function now has no effect.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_message_retry_set(struct mosquitto *mosq, unsigned int message_retry);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_user_data_set
|
||||
*
|
||||
* When <mosquitto_new> is called, the pointer given as the "obj" parameter
|
||||
* will be passed to the callbacks as user data. The <mosquitto_user_data_set>
|
||||
* function allows this obj parameter to be updated at any time. This function
|
||||
* will not modify the memory pointed to by the current user data pointer. If
|
||||
* it is dynamically allocated memory you must free it yourself.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* obj - A user pointer that will be passed as an argument to any callbacks
|
||||
* that are specified.
|
||||
*/
|
||||
libmosq_EXPORT void mosquitto_user_data_set(struct mosquitto *mosq, void *obj);
|
||||
|
||||
/* Function: mosquitto_userdata
|
||||
*
|
||||
* Retrieve the "userdata" variable for a mosquitto client.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* A pointer to the userdata member variable.
|
||||
*/
|
||||
libmosq_EXPORT void *mosquitto_userdata(struct mosquitto *mosq);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_PUBLISH_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_PUBLISH_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_publish.h
|
||||
*
|
||||
* This header contains functions for publishing with libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Function: mosquitto_publish
|
||||
*
|
||||
* Publish a message on a given topic.
|
||||
*
|
||||
* It is valid to use this function for clients using all MQTT protocol versions.
|
||||
* If you need to set MQTT v5 PUBLISH properties, use <mosquitto_publish_v5>
|
||||
* instead.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - pointer to an int. If not NULL, the function will set this
|
||||
* to the message id of this particular message. This can be then
|
||||
* used with the publish callback to determine when the message
|
||||
* has been sent.
|
||||
* Note that although the MQTT protocol doesn't use message ids
|
||||
* for messages with QoS=0, libmosquitto assigns them message ids
|
||||
* so they can be tracked with this parameter.
|
||||
* topic - null terminated string of the topic to publish to.
|
||||
* payloadlen - the size of the payload (bytes). Valid values are between 0 and
|
||||
* 268,435,455.
|
||||
* payload - pointer to the data to send. If payloadlen > 0 this must be a
|
||||
* valid memory location.
|
||||
* qos - integer value 0, 1 or 2 indicating the Quality of Service to be
|
||||
* used for the message.
|
||||
* retain - set to true to make the message retained.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_PROTOCOL - if there is a protocol error communicating with the
|
||||
* broker.
|
||||
* MOSQ_ERR_PAYLOAD_SIZE - if payloadlen is too large.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
* MOSQ_ERR_QOS_NOT_SUPPORTED - if the QoS is greater than that supported by
|
||||
* the broker.
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_max_inflight_messages_set>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_publish(struct mosquitto *mosq, int *mid, const char *topic, int payloadlen, const void *payload, int qos, bool retain);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_publish_v5
|
||||
*
|
||||
* Publish a message on a given topic, with attached MQTT properties.
|
||||
*
|
||||
* Use e.g. <mosquitto_property_add_string> and similar to create a list of
|
||||
* properties, then attach them to this publish. Properties need freeing with
|
||||
* <mosquitto_property_free_all>.
|
||||
*
|
||||
* If the mosquitto instance `mosq` is using MQTT v5, the `properties` argument
|
||||
* will be applied to the PUBLISH message. For MQTT v3.1.1 and below, the
|
||||
* `properties` argument will be ignored.
|
||||
*
|
||||
* Set your client to use MQTT v5 immediately after it is created:
|
||||
*
|
||||
* mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - pointer to an int. If not NULL, the function will set this
|
||||
* to the message id of this particular message. This can be then
|
||||
* used with the publish callback to determine when the message
|
||||
* has been sent.
|
||||
* Note that although the MQTT protocol doesn't use message ids
|
||||
* for messages with QoS=0, libmosquitto assigns them message ids
|
||||
* so they can be tracked with this parameter.
|
||||
* topic - null terminated string of the topic to publish to.
|
||||
* payloadlen - the size of the payload (bytes). Valid values are between 0 and
|
||||
* 268,435,455.
|
||||
* payload - pointer to the data to send. If payloadlen > 0 this must be a
|
||||
* valid memory location.
|
||||
* qos - integer value 0, 1 or 2 indicating the Quality of Service to be
|
||||
* used for the message.
|
||||
* retain - set to true to make the message retained.
|
||||
* properties - a valid mosquitto_property list, or NULL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_PROTOCOL - if there is a protocol error communicating with the
|
||||
* broker.
|
||||
* MOSQ_ERR_PAYLOAD_SIZE - if payloadlen is too large.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
* MOSQ_ERR_DUPLICATE_PROPERTY - if a property is duplicated where it is forbidden.
|
||||
* MOSQ_ERR_PROTOCOL - if any property is invalid for use with PUBLISH.
|
||||
* MOSQ_ERR_QOS_NOT_SUPPORTED - if the QoS is greater than that supported by
|
||||
* the broker.
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_publish_v5(
|
||||
struct mosquitto *mosq,
|
||||
int *mid,
|
||||
const char *topic,
|
||||
int payloadlen,
|
||||
const void *payload,
|
||||
int qos,
|
||||
bool retain,
|
||||
const mosquitto_property *properties);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,59 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_SOCKS_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_SOCKS_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_socks.h
|
||||
*
|
||||
* This header contains functions for controlling SOCKSv5 in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* =============================================================================
|
||||
*
|
||||
* Section: SOCKS5 proxy functions
|
||||
*
|
||||
* =============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
* Function: mosquitto_socks5_set
|
||||
*
|
||||
* Configure the client to use a SOCKS5 proxy when connecting. Must be called
|
||||
* before connecting. "None" and "username/password" authentication is
|
||||
* supported.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* host - the SOCKS5 proxy host to connect to.
|
||||
* port - the SOCKS5 proxy port to use.
|
||||
* username - if not NULL, use this username when authenticating with the proxy.
|
||||
* password - if not NULL and username is not NULL, use this password when
|
||||
* authenticating with the proxy.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_socks5_set(struct mosquitto *mosq, const char *host, int port, const char *username, const char *password);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,142 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_SUBSCRIBE_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_SUBSCRIBE_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_subscribe.h
|
||||
*
|
||||
* This header contains functions for subscribing in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe
|
||||
*
|
||||
* Subscribe to a topic.
|
||||
*
|
||||
* It is valid to use this function for clients using all MQTT protocol versions.
|
||||
* If you need to set MQTT v5 SUBSCRIBE properties, use <mosquitto_subscribe_v5>
|
||||
* instead.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - a pointer to an int. If not NULL, the function will set this to
|
||||
* the message id of this particular message. This can be then used
|
||||
* with the subscribe callback to determine when the message has been
|
||||
* sent.
|
||||
* sub - the subscription pattern - must not be NULL or an empty string.
|
||||
* qos - the requested Quality of Service for this subscription.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_subscribe(struct mosquitto *mosq, int *mid, const char *sub, int qos);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe_v5
|
||||
*
|
||||
* Subscribe to a topic, with attached MQTT properties.
|
||||
*
|
||||
* Use e.g. <mosquitto_property_add_string> and similar to create a list of
|
||||
* properties, then attach them to this publish. Properties need freeing with
|
||||
* <mosquitto_property_free_all>.
|
||||
*
|
||||
* If the mosquitto instance `mosq` is using MQTT v5, the `properties` argument
|
||||
* will be applied to the PUBLISH message. For MQTT v3.1.1 and below, the
|
||||
* `properties` argument will be ignored.
|
||||
*
|
||||
* Set your client to use MQTT v5 immediately after it is created:
|
||||
*
|
||||
* mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - a pointer to an int. If not NULL, the function will set this to
|
||||
* the message id of this particular message. This can be then used
|
||||
* with the subscribe callback to determine when the message has been
|
||||
* sent.
|
||||
* sub - the subscription pattern - must not be NULL or an empty string.
|
||||
* qos - the requested Quality of Service for this subscription.
|
||||
* options - options to apply to this subscription, OR'd together. Set to 0 to
|
||||
* use the default options, otherwise choose from list of <mqtt5_sub_options>
|
||||
* properties - a valid mosquitto_property list, or NULL.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
* MOSQ_ERR_DUPLICATE_PROPERTY - if a property is duplicated where it is forbidden.
|
||||
* MOSQ_ERR_PROTOCOL - if any property is invalid for use with SUBSCRIBE.
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_subscribe_v5(struct mosquitto *mosq, int *mid, const char *sub, int qos, int options, const mosquitto_property *properties);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_subscribe_multiple
|
||||
*
|
||||
* Subscribe to multiple topics.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - a pointer to an int. If not NULL, the function will set this to
|
||||
* the message id of this particular message. This can be then used
|
||||
* with the subscribe callback to determine when the message has been
|
||||
* sent.
|
||||
* sub_count - the count of subscriptions to be made
|
||||
* sub - array of sub_count pointers, each pointing to a subscription string.
|
||||
* The "char *const *const" datatype ensures that neither the array of
|
||||
* pointers nor the strings that they point to are mutable. If you aren't
|
||||
* familiar with this, just think of it as a safer "char **",
|
||||
* equivalent to "const char *" for a simple string pointer.
|
||||
* Each string must not be NULL or an empty string.
|
||||
* qos - the requested Quality of Service for each subscription.
|
||||
* options - options to apply to this subscription, OR'd together. This
|
||||
* argument is not used for MQTT v3 susbcriptions. Set to 0 to use
|
||||
* the default options, otherwise choose from list of <mqtt5_sub_options>
|
||||
* properties - a valid mosquitto_property list, or NULL. Only used with MQTT
|
||||
* v5 clients.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if a topic is not valid UTF-8
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_subscribe_multiple(struct mosquitto *mosq, int *mid, int sub_count, char *const *const sub, int qos, int options, const mosquitto_property *properties);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,198 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_TLS_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_TLS_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_tls.h
|
||||
*
|
||||
* This header contains functions for setting TLS options in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: TLS support
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_tls_set
|
||||
*
|
||||
* Configure the client for certificate based SSL/TLS support. Must be called
|
||||
* before <mosquitto_connect>.
|
||||
*
|
||||
* Cannot be used in conjunction with <mosquitto_tls_psk_set>.
|
||||
*
|
||||
* Define the Certificate Authority certificates to be trusted (ie. the server
|
||||
* certificate must be signed with one of these certificates) using cafile.
|
||||
*
|
||||
* If the server you are connecting to requires clients to provide a
|
||||
* certificate, define certfile and keyfile with your client certificate and
|
||||
* private key. If your private key is encrypted, provide a password callback
|
||||
* function or you will have to enter the password at the command line.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* cafile - path to a file containing the PEM encoded trusted CA
|
||||
* certificate files. Either cafile or capath must not be NULL.
|
||||
* capath - path to a directory containing the PEM encoded trusted CA
|
||||
* certificate files. See mosquitto.conf for more details on
|
||||
* configuring this directory. Either cafile or capath must not
|
||||
* be NULL.
|
||||
* certfile - path to a file containing the PEM encoded certificate file
|
||||
* for this client. If NULL, keyfile must also be NULL and no
|
||||
* client certificate will be used.
|
||||
* keyfile - path to a file containing the PEM encoded private key for
|
||||
* this client. If NULL, certfile must also be NULL and no
|
||||
* client certificate will be used.
|
||||
* pw_callback - if keyfile is encrypted, set pw_callback to allow your client
|
||||
* to pass the correct password for decryption. If set to NULL,
|
||||
* the password must be entered on the command line.
|
||||
* Your callback must write the password into "buf", which is
|
||||
* "size" bytes long. The return value must be the length of the
|
||||
* password. "userdata" will be set to the calling mosquitto
|
||||
* instance. The mosquitto userdata member variable can be
|
||||
* retrieved using <mosquitto_userdata>.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_tls_opts_set>, <mosquitto_tls_psk_set>,
|
||||
* <mosquitto_tls_insecure_set>, <mosquitto_userdata>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_tls_set(struct mosquitto *mosq,
|
||||
const char *cafile, const char *capath,
|
||||
const char *certfile, const char *keyfile,
|
||||
int (*pw_callback)(char *buf, int size, int rwflag, void *userdata));
|
||||
|
||||
/*
|
||||
* Function: mosquitto_tls_insecure_set
|
||||
*
|
||||
* Configure verification of the server hostname in the server certificate. If
|
||||
* value is set to true, it is impossible to guarantee that the host you are
|
||||
* connecting to is not impersonating your server. This can be useful in
|
||||
* initial server testing, but makes it possible for a malicious third party to
|
||||
* impersonate your server through DNS spoofing, for example.
|
||||
* Do not use this function in a real system. Setting value to true makes the
|
||||
* connection encryption pointless.
|
||||
* Must be called before <mosquitto_connect>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* value - if set to false, the default, certificate hostname checking is
|
||||
* performed. If set to true, no hostname checking is performed and
|
||||
* the connection is insecure.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_tls_set>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_tls_insecure_set(struct mosquitto *mosq, bool value);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_tls_opts_set
|
||||
*
|
||||
* Set advanced SSL/TLS options. Must be called before <mosquitto_connect>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* cert_reqs - an integer defining the verification requirements the client
|
||||
* will impose on the server. This can be one of:
|
||||
* * SSL_VERIFY_NONE (0): the server will not be verified in any way.
|
||||
* * SSL_VERIFY_PEER (1): the server certificate will be verified
|
||||
* and the connection aborted if the verification fails.
|
||||
* The default and recommended value is SSL_VERIFY_PEER. Using
|
||||
* SSL_VERIFY_NONE provides no security.
|
||||
* tls_version - the version of the SSL/TLS protocol to use as a string. If NULL,
|
||||
* the default value is used. The default value and the
|
||||
* available values depend on the version of openssl that the
|
||||
* library was compiled against. For openssl >= 1.0.1, the
|
||||
* available options are tlsv1.2, tlsv1.1 and tlsv1, with tlv1.2
|
||||
* as the default. For openssl < 1.0.1, only tlsv1 is available.
|
||||
* ciphers - a string describing the ciphers available for use. See the
|
||||
* "openssl ciphers" tool for more information. If NULL, the
|
||||
* default ciphers will be used.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_tls_set>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_tls_opts_set(struct mosquitto *mosq, int cert_reqs, const char *tls_version, const char *ciphers);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_tls_psk_set
|
||||
*
|
||||
* Configure the client for pre-shared-key based TLS support. Must be called
|
||||
* before <mosquitto_connect>.
|
||||
*
|
||||
* Cannot be used in conjunction with <mosquitto_tls_set>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* psk - the pre-shared-key in hex format with no leading "0x".
|
||||
* identity - the identity of this client. May be used as the username
|
||||
* depending on the server settings.
|
||||
* ciphers - a string describing the PSK ciphers available for use. See the
|
||||
* "openssl ciphers" tool for more information. If NULL, the
|
||||
* default ciphers will be used.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
*
|
||||
* See Also:
|
||||
* <mosquitto_tls_set>
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_tls_psk_set(struct mosquitto *mosq, const char *psk, const char *identity, const char *ciphers);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_ssl_get
|
||||
*
|
||||
* Retrieve a pointer to the SSL structure used for TLS connections in this
|
||||
* client. This can be used in e.g. the connect callback to carry out
|
||||
* additional verification steps.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance
|
||||
*
|
||||
* Returns:
|
||||
* A valid pointer to an openssl SSL structure - if the client is using TLS.
|
||||
* NULL - if the client is not using TLS, or TLS support is not compiled in.
|
||||
*/
|
||||
libmosq_EXPORT void *mosquitto_ssl_get(struct mosquitto *mosq);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_UNSUBSCRIBE_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_UNSUBSCRIBE_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_unsubscribe.h
|
||||
*
|
||||
* This header contains functions for client unsubscribing in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Function: mosquitto_unsubscribe
|
||||
*
|
||||
* Unsubscribe from a topic.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - a pointer to an int. If not NULL, the function will set this to
|
||||
* the message id of this particular message. This can be then used
|
||||
* with the unsubscribe callback to determine when the message has been
|
||||
* sent.
|
||||
* sub - the unsubscription pattern - must not by NULL or an empty string.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_unsubscribe(struct mosquitto *mosq, int *mid, const char *sub);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_unsubscribe_v5
|
||||
*
|
||||
* Unsubscribe from a topic, with attached MQTT properties.
|
||||
*
|
||||
* It is valid to use this function for clients using all MQTT protocol versions.
|
||||
* If you need to set MQTT v5 UNSUBSCRIBE properties, use
|
||||
* <mosquitto_unsubscribe_v5> instead.
|
||||
*
|
||||
* Use e.g. <mosquitto_property_add_string> and similar to create a list of
|
||||
* properties, then attach them to this publish. Properties need freeing with
|
||||
* <mosquitto_property_free_all>.
|
||||
*
|
||||
* If the mosquitto instance `mosq` is using MQTT v5, the `properties` argument
|
||||
* will be applied to the PUBLISH message. For MQTT v3.1.1 and below, the
|
||||
* `properties` argument will be ignored.
|
||||
*
|
||||
* Set your client to use MQTT v5 immediately after it is created:
|
||||
*
|
||||
* mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - a pointer to an int. If not NULL, the function will set this to
|
||||
* the message id of this particular message. This can be then used
|
||||
* with the unsubscribe callback to determine when the message has been
|
||||
* sent.
|
||||
* sub - the unsubscription pattern - must not by NULL or an empty string.
|
||||
* properties - a valid mosquitto_property list, or NULL. Only used with MQTT
|
||||
* v5 clients.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8
|
||||
* MOSQ_ERR_DUPLICATE_PROPERTY - if a property is duplicated where it is forbidden.
|
||||
* MOSQ_ERR_PROTOCOL - if any property is invalid for use with UNSUBSCRIBE.
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_unsubscribe_v5(struct mosquitto *mosq, int *mid, const char *sub, const mosquitto_property *properties);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_unsubscribe_multiple
|
||||
*
|
||||
* Unsubscribe from multiple topics.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* mid - a pointer to an int. If not NULL, the function will set this to
|
||||
* the message id of this particular message. This can be then used
|
||||
* with the subscribe callback to determine when the message has been
|
||||
* sent.
|
||||
* sub_count - the count of unsubscriptions to be made
|
||||
* sub - array of sub_count pointers, each pointing to an unsubscription string.
|
||||
* The "char *const *const" datatype ensures that neither the array of
|
||||
* pointers nor the strings that they point to are mutable. If you aren't
|
||||
* familiar with this, just think of it as a safer "char **",
|
||||
* equivalent to "const char *" for a simple string pointer.
|
||||
* Each sub must not be NULL or an empty string.
|
||||
* properties - a valid mosquitto_property list, or NULL. Only used with MQTT
|
||||
* v5 clients.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_NO_CONN - if the client isn't connected to a broker.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if a topic is not valid UTF-8
|
||||
* MOSQ_ERR_OVERSIZE_PACKET - if the resulting packet would be larger than
|
||||
* supported by the broker.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_unsubscribe_multiple(struct mosquitto *mosq, int *mid, int sub_count, char *const *const sub, const mosquitto_property *properties);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,127 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTO_WILL_H
|
||||
#define MOSQUITTO_LIBMOSQUITTO_WILL_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/libmosquitto_will.h
|
||||
*
|
||||
* This header contains functions for manipulating client Wills in libmosquitto.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* ======================================================================
|
||||
*
|
||||
* Section: Will
|
||||
*
|
||||
* ====================================================================== */
|
||||
/*
|
||||
* Function: mosquitto_will_set
|
||||
*
|
||||
* Configure will information for a mosquitto instance. By default, clients do
|
||||
* not have a will. This must be called before calling <mosquitto_connect>.
|
||||
*
|
||||
* It is valid to use this function for clients using all MQTT protocol versions.
|
||||
* If you need to set MQTT v5 Will properties, use <mosquitto_will_set_v5> instead.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* topic - the topic on which to publish the will.
|
||||
* payloadlen - the size of the payload (bytes). Valid values are between 0 and
|
||||
* 268,435,455.
|
||||
* payload - pointer to the data to send. If payloadlen > 0 this must be a
|
||||
* valid memory location.
|
||||
* qos - integer value 0, 1 or 2 indicating the Quality of Service to be
|
||||
* used for the will.
|
||||
* retain - set to true to make the will a retained message.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_PAYLOAD_SIZE - if payloadlen is too large.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_will_set(struct mosquitto *mosq, const char *topic, int payloadlen, const void *payload, int qos, bool retain);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_will_set_v5
|
||||
*
|
||||
* Configure will information for a mosquitto instance, with attached
|
||||
* properties. By default, clients do not have a will. This must be called
|
||||
* before calling <mosquitto_connect>.
|
||||
*
|
||||
* If the mosquitto instance `mosq` is using MQTT v5, the `properties` argument
|
||||
* will be applied to the Will. For MQTT v3.1.1 and below, the `properties`
|
||||
* argument will be ignored.
|
||||
*
|
||||
* Set your client to use MQTT v5 immediately after it is created:
|
||||
*
|
||||
* mosquitto_int_option(mosq, MOSQ_OPT_PROTOCOL_VERSION, MQTT_PROTOCOL_V5);
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
* topic - the topic on which to publish the will.
|
||||
* payloadlen - the size of the payload (bytes). Valid values are between 0 and
|
||||
* 268,435,455.
|
||||
* payload - pointer to the data to send. If payloadlen > 0 this must be a
|
||||
* valid memory location.
|
||||
* qos - integer value 0, 1 or 2 indicating the Quality of Service to be
|
||||
* used for the will.
|
||||
* retain - set to true to make the will a retained message.
|
||||
* properties - list of MQTT 5 properties. Can be NULL. On success only, the
|
||||
* property list becomes the property of libmosquitto once this
|
||||
* function is called and will be freed by the library. The
|
||||
* property list must be freed by the application on error.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
* MOSQ_ERR_NOMEM - if an out of memory condition occurred.
|
||||
* MOSQ_ERR_PAYLOAD_SIZE - if payloadlen is too large.
|
||||
* MOSQ_ERR_MALFORMED_UTF8 - if the topic is not valid UTF-8.
|
||||
* MOSQ_ERR_NOT_SUPPORTED - if properties is not NULL and the client is not
|
||||
* using MQTT v5
|
||||
* MOSQ_ERR_PROTOCOL - if a property is invalid for use with wills.
|
||||
* MOSQ_ERR_DUPLICATE_PROPERTY - if a property is duplicated where it is forbidden.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_will_set_v5(struct mosquitto *mosq, const char *topic, int payloadlen, const void *payload, int qos, bool retain, mosquitto_property *properties);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_will_clear
|
||||
*
|
||||
* Remove a previously configured will. This must be called before calling
|
||||
* <mosquitto_connect>.
|
||||
*
|
||||
* Parameters:
|
||||
* mosq - a valid mosquitto instance.
|
||||
*
|
||||
* Returns:
|
||||
* MOSQ_ERR_SUCCESS - on success.
|
||||
* MOSQ_ERR_INVAL - if the input parameters were invalid.
|
||||
*/
|
||||
libmosq_EXPORT int mosquitto_will_clear(struct mosquitto *mosq);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,162 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_LIBMOSQUITTOPP_H
|
||||
#define MOSQUITTO_LIBMOSQUITTOPP_H
|
||||
|
||||
#if defined(_WIN32) && !defined(LIBMOSQUITTO_STATIC)
|
||||
# ifdef mosquittopp_EXPORTS
|
||||
# define mosqpp_EXPORT __declspec(dllexport)
|
||||
# else
|
||||
# define mosqpp_EXPORT __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define mosqpp_EXPORT
|
||||
#endif
|
||||
|
||||
#include <cstdlib>
|
||||
#include <mosquitto.h>
|
||||
#include <time.h>
|
||||
|
||||
namespace mosqpp {
|
||||
|
||||
|
||||
mosqpp_EXPORT const char * strerror(int mosq_errno);
|
||||
mosqpp_EXPORT const char * connack_string(int connack_code);
|
||||
mosqpp_EXPORT const char * reason_string(int reason_code);
|
||||
mosqpp_EXPORT int sub_topic_tokenise(const char *subtopic, char ***topics, int *count);
|
||||
mosqpp_EXPORT int sub_topic_tokens_free(char ***topics, int count);
|
||||
mosqpp_EXPORT int lib_version(int *major, int *minor, int *revision);
|
||||
mosqpp_EXPORT int lib_init();
|
||||
mosqpp_EXPORT int lib_cleanup();
|
||||
mosqpp_EXPORT int topic_matches_sub(const char *sub, const char *topic, bool *result);
|
||||
mosqpp_EXPORT int topic_matches_sub_with_pattern(const char *sub, const char *topic, const char *clientid, const char *username, bool *result);
|
||||
mosqpp_EXPORT int sub_matches_acl(const char *acl, const char *sub, bool *result);
|
||||
mosqpp_EXPORT int sub_matches_acl_with_pattern(const char *acl, const char *sub, const char *clientid, const char *username, bool *result);
|
||||
mosqpp_EXPORT int validate_utf8(const char *str, int len);
|
||||
mosqpp_EXPORT int subscribe_simple(
|
||||
struct mosquitto_message **messages,
|
||||
int msg_count,
|
||||
bool retained,
|
||||
const char *topic,
|
||||
int qos=0,
|
||||
const char *host="localhost",
|
||||
int port=1883,
|
||||
const char *clientid=NULL,
|
||||
int keepalive=60,
|
||||
bool clean_session=true,
|
||||
const char *username=NULL,
|
||||
const char *password=NULL,
|
||||
const struct libmosquitto_will *will=NULL,
|
||||
const struct libmosquitto_tls *tls=NULL);
|
||||
|
||||
mosqpp_EXPORT int subscribe_callback(
|
||||
int (*callback)(struct mosquitto *, void *, const struct mosquitto_message *),
|
||||
void *userdata,
|
||||
const char *topic,
|
||||
int qos=0,
|
||||
const char *host="localhost",
|
||||
int port=1883,
|
||||
const char *clientid=NULL,
|
||||
int keepalive=60,
|
||||
bool clean_session=true,
|
||||
const char *username=NULL,
|
||||
const char *password=NULL,
|
||||
const struct libmosquitto_will *will=NULL,
|
||||
const struct libmosquitto_tls *tls=NULL);
|
||||
|
||||
mosqpp_EXPORT int property_check_command(int command, int identifier);
|
||||
mosqpp_EXPORT int property_check_all(int command, const mosquitto_property *properties);
|
||||
|
||||
/*
|
||||
* Class: mosquittopp
|
||||
*
|
||||
* A mosquitto client class. This is a C++ wrapper class for the mosquitto C
|
||||
* library. Please see mosquitto.h for details of the functions.
|
||||
*/
|
||||
class mosqpp_EXPORT mosquittopp {
|
||||
private:
|
||||
struct mosquitto *m_mosq;
|
||||
public:
|
||||
mosquittopp(const char *id=NULL, bool clean_session=true);
|
||||
virtual ~mosquittopp();
|
||||
|
||||
int reinitialise(const char *id, bool clean_session);
|
||||
int socket();
|
||||
int will_set(const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false);
|
||||
int will_set_v5(const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false, mosquitto_property *properties=NULL);
|
||||
int will_clear();
|
||||
int username_pw_set(const char *username, const char *password=NULL);
|
||||
int connect(const char *host, int port=1883, int keepalive=60);
|
||||
int connect(const char *host, int port, int keepalive, const char *bind_address);
|
||||
int connect_v5(const char *host, int port, int keepalive, const char *bind_address, const mosquitto_property *properties);
|
||||
int connect_async(const char *host, int port=1883, int keepalive=60);
|
||||
int connect_async(const char *host, int port, int keepalive, const char *bind_address);
|
||||
int reconnect();
|
||||
int reconnect_async();
|
||||
int disconnect();
|
||||
int disconnect_v5(int reason_code, const mosquitto_property *properties);
|
||||
int publish(int *mid, const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false);
|
||||
int publish_v5(int *mid, const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false, const mosquitto_property *properties=NULL);
|
||||
int subscribe(int *mid, const char *sub, int qos=0);
|
||||
int subscribe_v5(int *mid, const char *sub, int qos=0, int options=0, const mosquitto_property *properties=NULL);
|
||||
int unsubscribe(int *mid, const char *sub);
|
||||
int unsubscribe_v5(int *mid, const char *sub, const mosquitto_property *properties);
|
||||
void reconnect_delay_set(unsigned int reconnect_delay, unsigned int reconnect_delay_max, bool reconnect_exponential_backoff);
|
||||
int max_inflight_messages_set(unsigned int max_inflight_messages);
|
||||
void message_retry_set(unsigned int message_retry);
|
||||
void user_data_set(void *userdata);
|
||||
int tls_set(const char *cafile, const char *capath=NULL, const char *certfile=NULL, const char *keyfile=NULL, int (*pw_callback)(char *buf, int size, int rwflag, void *userdata)=NULL);
|
||||
int tls_opts_set(int cert_reqs, const char *tls_version=NULL, const char *ciphers=NULL);
|
||||
int tls_insecure_set(bool value);
|
||||
int tls_psk_set(const char *psk, const char *identity, const char *ciphers=NULL);
|
||||
int opts_set(enum mosq_opt_t option, void *value);
|
||||
int int_option(enum mosq_opt_t option, int value);
|
||||
int string_option(enum mosq_opt_t option, const char *value);
|
||||
int void_option(enum mosq_opt_t option, void *value);
|
||||
|
||||
int loop(int timeout=-1, int max_packets=1);
|
||||
int loop_misc();
|
||||
int loop_read(int max_packets=1);
|
||||
int loop_write(int max_packets=1);
|
||||
int loop_forever(int timeout=-1, int max_packets=1);
|
||||
int loop_start();
|
||||
int loop_stop(bool force=false);
|
||||
bool want_write();
|
||||
int threaded_set(bool threaded=true);
|
||||
int socks5_set(const char *host, int port=1080, const char *username=NULL, const char *password=NULL);
|
||||
|
||||
// names in the functions commented to prevent unused parameter warning
|
||||
virtual void on_pre_connect() {return;}
|
||||
virtual void on_connect(int /*rc*/) {return;}
|
||||
virtual void on_connect_with_flags(int /*rc*/, int /*flags*/) {return;}
|
||||
virtual void on_connect_v5(int /*rc*/, int /*flags*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_disconnect(int /*rc*/) {return;}
|
||||
virtual void on_disconnect_v5(int /*rc*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_publish(int /*mid*/) {return;}
|
||||
virtual void on_publish_v5(int /*mid*/, int /*reason_code*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_message(const struct mosquitto_message * /*message*/) {return;}
|
||||
virtual void on_message_v5(const struct mosquitto_message * /*message*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_subscribe(int /*mid*/, int /*qos_count*/, const int * /*granted_qos*/) {return;}
|
||||
virtual void on_subscribe_v5(int /*mid*/, int /*qos_count*/, const int * /*granted_qos*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_unsubscribe(int /*mid*/) {return;}
|
||||
virtual void on_unsubscribe_v5(int /*mid*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_log(int /*level*/, const char * /*str*/) {return;}
|
||||
virtual void on_error() {return;}
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,292 @@
|
||||
/*
|
||||
Copyright (c) 2009-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MQTT_PROTOCOL_H
|
||||
#define MQTT_PROTOCOL_H
|
||||
|
||||
/*
|
||||
* File: mosquitto/mqtt_protocol.h
|
||||
*
|
||||
* This header contains definitions of MQTT values as defined in the specifications.
|
||||
*/
|
||||
#define PROTOCOL_NAME_v31 "MQIsdp"
|
||||
#define PROTOCOL_VERSION_v31 3
|
||||
|
||||
#define PROTOCOL_NAME "MQTT"
|
||||
|
||||
#define PROTOCOL_VERSION_v311 4
|
||||
#define PROTOCOL_VERSION_v5 5
|
||||
|
||||
|
||||
/* Message types */
|
||||
#define CMD_CONNECT 0x10U
|
||||
#define CMD_CONNACK 0x20U
|
||||
#define CMD_PUBLISH 0x30U
|
||||
#define CMD_PUBACK 0x40U
|
||||
#define CMD_PUBREC 0x50U
|
||||
#define CMD_PUBREL 0x60U
|
||||
#define CMD_PUBCOMP 0x70U
|
||||
#define CMD_SUBSCRIBE 0x80U
|
||||
#define CMD_SUBACK 0x90U
|
||||
#define CMD_UNSUBSCRIBE 0xA0U
|
||||
#define CMD_UNSUBACK 0xB0U
|
||||
#define CMD_PINGREQ 0xC0U
|
||||
#define CMD_PINGRESP 0xD0U
|
||||
#define CMD_DISCONNECT 0xE0U
|
||||
#define CMD_AUTH 0xF0U
|
||||
|
||||
/* Mosquitto only: for distinguishing CONNECT and WILL properties */
|
||||
#define CMD_WILL 0x100
|
||||
|
||||
/* Enum: mqtt311_connack_codes
|
||||
*
|
||||
* The CONNACK results for MQTT v3.1.1, and v3.1.
|
||||
*
|
||||
* Values:
|
||||
* CONNACK_ACCEPTED - 0
|
||||
* CONNACK_REFUSED_PROTOCOL_VERSION - 1
|
||||
* CONNACK_REFUSED_IDENTIFIER_REJECTED - 2
|
||||
* CONNACK_REFUSED_SERVER_UNAVAILABLE - 3
|
||||
* CONNACK_REFUSED_BAD_USERNAME_PASSWORD - 4
|
||||
* CONNACK_REFUSED_NOT_AUTHORIZED - 5
|
||||
*/
|
||||
enum mqtt311_connack_codes {
|
||||
CONNACK_ACCEPTED = 0,
|
||||
CONNACK_REFUSED_PROTOCOL_VERSION = 1,
|
||||
CONNACK_REFUSED_IDENTIFIER_REJECTED = 2,
|
||||
CONNACK_REFUSED_SERVER_UNAVAILABLE = 3,
|
||||
CONNACK_REFUSED_BAD_USERNAME_PASSWORD = 4,
|
||||
CONNACK_REFUSED_NOT_AUTHORIZED = 5,
|
||||
};
|
||||
|
||||
/* Enum: mqtt5_return_codes
|
||||
* The reason codes returned in various MQTT commands.
|
||||
*
|
||||
* Values:
|
||||
* MQTT_RC_SUCCESS - 0
|
||||
* MQTT_RC_NORMAL_DISCONNECTION - 0
|
||||
* MQTT_RC_GRANTED_QOS0 - 0
|
||||
* MQTT_RC_GRANTED_QOS1 - 1
|
||||
* MQTT_RC_GRANTED_QOS2 - 2
|
||||
* MQTT_RC_DISCONNECT_WITH_WILL_MSG - 4
|
||||
* MQTT_RC_NO_MATCHING_SUBSCRIBERS - 16
|
||||
* MQTT_RC_NO_SUBSCRIPTION_EXISTED - 17
|
||||
* MQTT_RC_CONTINUE_AUTHENTICATION - 24
|
||||
* MQTT_RC_REAUTHENTICATE - 25
|
||||
* MQTT_RC_UNSPECIFIED - 128
|
||||
* MQTT_RC_MALFORMED_PACKET - 129
|
||||
* MQTT_RC_PROTOCOL_ERROR - 130
|
||||
* MQTT_RC_IMPLEMENTATION_SPECIFIC - 131
|
||||
* MQTT_RC_UNSUPPORTED_PROTOCOL_VERSION - 132
|
||||
* MQTT_RC_CLIENTID_NOT_VALID - 133
|
||||
* MQTT_RC_BAD_USERNAME_OR_PASSWORD - 134
|
||||
* MQTT_RC_NOT_AUTHORIZED - 135
|
||||
* MQTT_RC_SERVER_UNAVAILABLE - 136
|
||||
* MQTT_RC_SERVER_BUSY - 137
|
||||
* MQTT_RC_BANNED - 138
|
||||
* MQTT_RC_SERVER_SHUTTING_DOWN - 139
|
||||
* MQTT_RC_BAD_AUTHENTICATION_METHOD - 140
|
||||
* MQTT_RC_KEEP_ALIVE_TIMEOUT - 141
|
||||
* MQTT_RC_SESSION_TAKEN_OVER - 142
|
||||
* MQTT_RC_TOPIC_FILTER_INVALID - 143
|
||||
* MQTT_RC_TOPIC_NAME_INVALID - 144
|
||||
* MQTT_RC_PACKET_ID_IN_USE - 145
|
||||
* MQTT_RC_PACKET_ID_NOT_FOUND - 146
|
||||
* MQTT_RC_RECEIVE_MAXIMUM_EXCEEDED - 147
|
||||
* MQTT_RC_TOPIC_ALIAS_INVALID - 148
|
||||
* MQTT_RC_PACKET_TOO_LARGE - 149
|
||||
* MQTT_RC_MESSAGE_RATE_TOO_HIGH - 150
|
||||
* MQTT_RC_QUOTA_EXCEEDED - 151
|
||||
* MQTT_RC_ADMINISTRATIVE_ACTION - 152
|
||||
* MQTT_RC_PAYLOAD_FORMAT_INVALID - 153
|
||||
* MQTT_RC_RETAIN_NOT_SUPPORTED - 154
|
||||
* MQTT_RC_QOS_NOT_SUPPORTED - 155
|
||||
* MQTT_RC_USE_ANOTHER_SERVER - 156
|
||||
* MQTT_RC_SERVER_MOVED - 157
|
||||
* MQTT_RC_SHARED_SUBS_NOT_SUPPORTED - 158
|
||||
* MQTT_RC_CONNECTION_RATE_EXCEEDED - 159
|
||||
* MQTT_RC_MAXIMUM_CONNECT_TIME - 160
|
||||
* MQTT_RC_SUBSCRIPTION_IDS_NOT_SUPPORTED - 161
|
||||
* MQTT_RC_WILDCARD_SUBS_NOT_SUPPORTED - 162
|
||||
*/
|
||||
enum mqtt5_return_codes {
|
||||
MQTT_RC_SUCCESS = 0, /* CONNACK, PUBACK, PUBREC, PUBREL, PUBCOMP, UNSUBACK, AUTH */
|
||||
MQTT_RC_NORMAL_DISCONNECTION = 0, /* DISCONNECT */
|
||||
MQTT_RC_GRANTED_QOS0 = 0, /* SUBACK */
|
||||
MQTT_RC_GRANTED_QOS1 = 1, /* SUBACK */
|
||||
MQTT_RC_GRANTED_QOS2 = 2, /* SUBACK */
|
||||
MQTT_RC_DISCONNECT_WITH_WILL_MSG = 4, /* DISCONNECT */
|
||||
MQTT_RC_NO_MATCHING_SUBSCRIBERS = 16, /* PUBACK, PUBREC */
|
||||
MQTT_RC_NO_SUBSCRIPTION_EXISTED = 17, /* UNSUBACK */
|
||||
MQTT_RC_CONTINUE_AUTHENTICATION = 24, /* AUTH */
|
||||
MQTT_RC_REAUTHENTICATE = 25, /* AUTH */
|
||||
|
||||
MQTT_RC_UNSPECIFIED = 128, /* CONNACK, PUBACK, PUBREC, SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_MALFORMED_PACKET = 129, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_PROTOCOL_ERROR = 130, /* DISCONNECT */
|
||||
MQTT_RC_IMPLEMENTATION_SPECIFIC = 131, /* CONNACK, PUBACK, PUBREC, SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_UNSUPPORTED_PROTOCOL_VERSION = 132, /* CONNACK */
|
||||
MQTT_RC_CLIENTID_NOT_VALID = 133, /* CONNACK */
|
||||
MQTT_RC_BAD_USERNAME_OR_PASSWORD = 134, /* CONNACK */
|
||||
MQTT_RC_NOT_AUTHORIZED = 135, /* CONNACK, PUBACK, PUBREC, SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_SERVER_UNAVAILABLE = 136, /* CONNACK */
|
||||
MQTT_RC_SERVER_BUSY = 137, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_BANNED = 138, /* CONNACK */
|
||||
MQTT_RC_SERVER_SHUTTING_DOWN = 139, /* DISCONNECT */
|
||||
MQTT_RC_BAD_AUTHENTICATION_METHOD = 140, /* CONNACK */
|
||||
MQTT_RC_KEEP_ALIVE_TIMEOUT = 141, /* DISCONNECT */
|
||||
MQTT_RC_SESSION_TAKEN_OVER = 142, /* DISCONNECT */
|
||||
MQTT_RC_TOPIC_FILTER_INVALID = 143, /* SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_TOPIC_NAME_INVALID = 144, /* CONNACK, PUBACK, PUBREC, DISCONNECT */
|
||||
MQTT_RC_PACKET_ID_IN_USE = 145, /* PUBACK, SUBACK, UNSUBACK */
|
||||
MQTT_RC_PACKET_ID_NOT_FOUND = 146, /* PUBREL, PUBCOMP */
|
||||
MQTT_RC_RECEIVE_MAXIMUM_EXCEEDED = 147, /* DISCONNECT */
|
||||
MQTT_RC_TOPIC_ALIAS_INVALID = 148, /* DISCONNECT */
|
||||
MQTT_RC_PACKET_TOO_LARGE = 149, /* CONNACK, PUBACK, PUBREC, DISCONNECT */
|
||||
MQTT_RC_MESSAGE_RATE_TOO_HIGH = 150, /* DISCONNECT */
|
||||
MQTT_RC_QUOTA_EXCEEDED = 151, /* PUBACK, PUBREC, SUBACK, DISCONNECT */
|
||||
MQTT_RC_ADMINISTRATIVE_ACTION = 152, /* DISCONNECT */
|
||||
MQTT_RC_PAYLOAD_FORMAT_INVALID = 153, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_RETAIN_NOT_SUPPORTED = 154, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_QOS_NOT_SUPPORTED = 155, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_USE_ANOTHER_SERVER = 156, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_SERVER_MOVED = 157, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_SHARED_SUBS_NOT_SUPPORTED = 158, /* SUBACK, DISCONNECT */
|
||||
MQTT_RC_CONNECTION_RATE_EXCEEDED = 159, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_MAXIMUM_CONNECT_TIME = 160, /* DISCONNECT */
|
||||
MQTT_RC_SUBSCRIPTION_IDS_NOT_SUPPORTED = 161, /* SUBACK, DISCONNECT */
|
||||
MQTT_RC_WILDCARD_SUBS_NOT_SUPPORTED = 162, /* SUBACK, DISCONNECT */
|
||||
};
|
||||
|
||||
/* Enum: mqtt5_property
|
||||
* Options for use with MQTTv5 properties.
|
||||
* Options:
|
||||
*
|
||||
* MQTT_PROP_PAYLOAD_FORMAT_INDICATOR - property option.
|
||||
* MQTT_PROP_MESSAGE_EXPIRY_INTERVAL - property option.
|
||||
* MQTT_PROP_CONTENT_TYPE - property option.
|
||||
* MQTT_PROP_RESPONSE_TOPIC - property option.
|
||||
* MQTT_PROP_CORRELATION_DATA - property option.
|
||||
* MQTT_PROP_SUBSCRIPTION_IDENTIFIER - property option.
|
||||
* MQTT_PROP_SESSION_EXPIRY_INTERVAL - property option.
|
||||
* MQTT_PROP_ASSIGNED_CLIENT_IDENTIFIER - property option.
|
||||
* MQTT_PROP_SERVER_KEEP_ALIVE - property option.
|
||||
* MQTT_PROP_AUTHENTICATION_METHOD - property option.
|
||||
* MQTT_PROP_AUTHENTICATION_DATA - property option.
|
||||
* MQTT_PROP_REQUEST_PROBLEM_INFORMATION - property option.
|
||||
* MQTT_PROP_WILL_DELAY_INTERVAL - property option.
|
||||
* MQTT_PROP_REQUEST_RESPONSE_INFORMATION - property option.
|
||||
* MQTT_PROP_RESPONSE_INFORMATION - property option.
|
||||
* MQTT_PROP_SERVER_REFERENCE - property option.
|
||||
* MQTT_PROP_REASON_STRING - property option.
|
||||
* MQTT_PROP_RECEIVE_MAXIMUM - property option.
|
||||
* MQTT_PROP_TOPIC_ALIAS_MAXIMUM - property option.
|
||||
* MQTT_PROP_TOPIC_ALIAS - property option.
|
||||
* MQTT_PROP_MAXIMUM_QOS - property option.
|
||||
* MQTT_PROP_RETAIN_AVAILABLE - property option.
|
||||
* MQTT_PROP_USER_PROPERTY - property option.
|
||||
* MQTT_PROP_MAXIMUM_PACKET_SIZE - property option.
|
||||
* MQTT_PROP_WILDCARD_SUB_AVAILABLE - property option.
|
||||
* MQTT_PROP_SUBSCRIPTION_ID_AVAILABLE - property option.
|
||||
* MQTT_PROP_SHARED_SUB_AVAILABLE - property option.
|
||||
*/
|
||||
enum mqtt5_property {
|
||||
MQTT_PROP_PAYLOAD_FORMAT_INDICATOR = 1, /* Byte : PUBLISH, Will Properties */
|
||||
MQTT_PROP_MESSAGE_EXPIRY_INTERVAL = 2, /* 4 byte int : PUBLISH, Will Properties */
|
||||
MQTT_PROP_CONTENT_TYPE = 3, /* UTF-8 string : PUBLISH, Will Properties */
|
||||
MQTT_PROP_RESPONSE_TOPIC = 8, /* UTF-8 string : PUBLISH, Will Properties */
|
||||
MQTT_PROP_CORRELATION_DATA = 9, /* Binary Data : PUBLISH, Will Properties */
|
||||
MQTT_PROP_SUBSCRIPTION_IDENTIFIER = 11, /* Variable byte int : PUBLISH, SUBSCRIBE */
|
||||
MQTT_PROP_SESSION_EXPIRY_INTERVAL = 17, /* 4 byte int : CONNECT, CONNACK, DISCONNECT */
|
||||
MQTT_PROP_ASSIGNED_CLIENT_IDENTIFIER = 18, /* UTF-8 string : CONNACK */
|
||||
MQTT_PROP_SERVER_KEEP_ALIVE = 19, /* 2 byte int : CONNACK */
|
||||
MQTT_PROP_AUTHENTICATION_METHOD = 21, /* UTF-8 string : CONNECT, CONNACK, AUTH */
|
||||
MQTT_PROP_AUTHENTICATION_DATA = 22, /* Binary Data : CONNECT, CONNACK, AUTH */
|
||||
MQTT_PROP_REQUEST_PROBLEM_INFORMATION = 23, /* Byte : CONNECT */
|
||||
MQTT_PROP_WILL_DELAY_INTERVAL = 24, /* 4 byte int : Will properties */
|
||||
MQTT_PROP_REQUEST_RESPONSE_INFORMATION = 25,/* Byte : CONNECT */
|
||||
MQTT_PROP_RESPONSE_INFORMATION = 26, /* UTF-8 string : CONNACK */
|
||||
MQTT_PROP_SERVER_REFERENCE = 28, /* UTF-8 string : CONNACK, DISCONNECT */
|
||||
MQTT_PROP_REASON_STRING = 31, /* UTF-8 string : CONNACK, PUBACK, PUBREC, PUBREL, PUBCOMP, SUBACK, UNSUBACK, DISCONNECT, AUTH */
|
||||
MQTT_PROP_RECEIVE_MAXIMUM = 33, /* 2 byte int : CONNECT, CONNACK */
|
||||
MQTT_PROP_TOPIC_ALIAS_MAXIMUM = 34, /* 2 byte int : CONNECT, CONNACK */
|
||||
MQTT_PROP_TOPIC_ALIAS = 35, /* 2 byte int : PUBLISH */
|
||||
MQTT_PROP_MAXIMUM_QOS = 36, /* Byte : CONNACK */
|
||||
MQTT_PROP_RETAIN_AVAILABLE = 37, /* Byte : CONNACK */
|
||||
MQTT_PROP_USER_PROPERTY = 38, /* UTF-8 string pair : All */
|
||||
MQTT_PROP_MAXIMUM_PACKET_SIZE = 39, /* 4 byte int : CONNECT, CONNACK */
|
||||
MQTT_PROP_WILDCARD_SUB_AVAILABLE = 40, /* Byte : CONNACK */
|
||||
MQTT_PROP_SUBSCRIPTION_ID_AVAILABLE = 41, /* Byte : CONNACK */
|
||||
MQTT_PROP_SHARED_SUB_AVAILABLE = 42, /* Byte : CONNACK */
|
||||
};
|
||||
|
||||
enum mqtt5_property_type {
|
||||
MQTT_PROP_TYPE_BYTE = 1,
|
||||
MQTT_PROP_TYPE_INT16 = 2,
|
||||
MQTT_PROP_TYPE_INT32 = 3,
|
||||
MQTT_PROP_TYPE_VARINT = 4,
|
||||
MQTT_PROP_TYPE_BINARY = 5,
|
||||
MQTT_PROP_TYPE_STRING = 6,
|
||||
MQTT_PROP_TYPE_STRING_PAIR = 7
|
||||
};
|
||||
|
||||
/* Enum: mqtt5_sub_options
|
||||
* Options for use with MQTTv5 subscriptions.
|
||||
*
|
||||
* MQTT_SUB_OPT_NO_LOCAL - with this option set, if this client publishes to
|
||||
* a topic to which it is subscribed, the broker will not publish the
|
||||
* message back to the client.
|
||||
*
|
||||
* MQTT_SUB_OPT_RETAIN_AS_PUBLISHED - with this option set, messages
|
||||
* published for this subscription will keep the retain flag as was set by
|
||||
* the publishing client. The default behaviour without this option set has
|
||||
* the retain flag indicating whether a message is fresh/stale.
|
||||
*
|
||||
* MQTT_SUB_OPT_SEND_RETAIN_ALWAYS - with this option set, pre-existing
|
||||
* retained messages are sent as soon as the subscription is made, even
|
||||
* if the subscription already exists. This is the default behaviour, so
|
||||
* it is not necessary to set this option.
|
||||
*
|
||||
* MQTT_SUB_OPT_SEND_RETAIN_NEW - with this option set, pre-existing retained
|
||||
* messages for this subscription will be sent when the subscription is made,
|
||||
* but only if the subscription does not already exist.
|
||||
*
|
||||
* MQTT_SUB_OPT_SEND_RETAIN_NEVER - with this option set, pre-existing
|
||||
* retained messages will never be sent for this subscription.
|
||||
*/
|
||||
enum mqtt5_sub_options {
|
||||
MQTT_SUB_OPT_NO_LOCAL = 0x04,
|
||||
MQTT_SUB_OPT_RETAIN_AS_PUBLISHED = 0x08,
|
||||
MQTT_SUB_OPT_SEND_RETAIN_ALWAYS = 0x00,
|
||||
MQTT_SUB_OPT_SEND_RETAIN_NEW = 0x10,
|
||||
MQTT_SUB_OPT_SEND_RETAIN_NEVER = 0x20,
|
||||
};
|
||||
|
||||
#define MQTT_MAX_PAYLOAD 268435455U
|
||||
|
||||
#define MQTT_SUB_OPT_GET_QOS(opt) ((opt) & 0x03)
|
||||
#define MQTT_SUB_OPT_GET_NO_LOCAL(opt) ((opt) & MQTT_SUB_OPT_NO_LOCAL)
|
||||
#define MQTT_SUB_OPT_GET_RETAIN_AS_PUBLISHED(opt) ((opt) & MQTT_SUB_OPT_RETAIN_AS_PUBLISHED)
|
||||
#define MQTT_SUB_OPT_GET_SEND_RETAIN(opt) ((opt) & (MQTT_SUB_OPT_SEND_RETAIN_NEW | MQTT_SUB_OPT_SEND_RETAIN_NEVER))
|
||||
|
||||
#define MQTT_SUB_OPT_SET_QOS(opt, qos) ((opt) = ((opt) & 0xFC) | ((qos) & 0x03))
|
||||
|
||||
#define MQTT_SUB_OPT_SET(opt, val) ((opt) |= val)
|
||||
#define MQTT_SUB_OPT_CLEAR(opt, val) ((opt) = (opt) & !val)
|
||||
|
||||
#endif
|
||||
+2
-1265
File diff suppressed because it is too large
Load Diff
+2
-441
@@ -1,441 +1,2 @@
|
||||
/*
|
||||
Copyright (c) 2012-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTO_PLUGIN_H
|
||||
#define MOSQUITTO_PLUGIN_H
|
||||
|
||||
/*
|
||||
* File: mosquitto_plugin.h
|
||||
*
|
||||
* This header contains function declarations for use when writing a Mosquitto plugin.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* The generic plugin interface starts at version 5 */
|
||||
#define MOSQ_PLUGIN_VERSION 5
|
||||
|
||||
/* The old auth only interface stopped at version 4 */
|
||||
#define MOSQ_AUTH_PLUGIN_VERSION 4
|
||||
|
||||
#define MOSQ_ACL_NONE 0x00
|
||||
#define MOSQ_ACL_READ 0x01
|
||||
#define MOSQ_ACL_WRITE 0x02
|
||||
#define MOSQ_ACL_SUBSCRIBE 0x04
|
||||
#define MOSQ_ACL_UNSUBSCRIBE 0x08
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <mosquitto.h>
|
||||
#include <mosquitto_broker.h>
|
||||
|
||||
struct mosquitto;
|
||||
|
||||
struct mosquitto_opt {
|
||||
char *key;
|
||||
char *value;
|
||||
};
|
||||
|
||||
struct mosquitto_auth_opt {
|
||||
char *key;
|
||||
char *value;
|
||||
};
|
||||
|
||||
struct mosquitto_acl_msg {
|
||||
const char *topic;
|
||||
const void *payload;
|
||||
long payloadlen;
|
||||
int qos;
|
||||
bool retain;
|
||||
};
|
||||
|
||||
#ifdef WIN32
|
||||
# define mosq_plugin_EXPORT __declspec(dllexport)
|
||||
#else
|
||||
# define mosq_plugin_EXPORT
|
||||
#endif
|
||||
|
||||
/*
|
||||
* To create an authentication plugin you must include this file then implement
|
||||
* the functions listed in the "Plugin Functions" section below. The resulting
|
||||
* code should then be compiled as a shared library. Using gcc this can be
|
||||
* achieved as follows:
|
||||
*
|
||||
* gcc -I<path to mosquitto_plugin.h> -fPIC -shared plugin.c -o plugin.so
|
||||
*
|
||||
* On Mac OS X:
|
||||
*
|
||||
* gcc -I<path to mosquitto_plugin.h> -fPIC -shared plugin.c -undefined dynamic_lookup -o plugin.so
|
||||
*
|
||||
*/
|
||||
|
||||
/* =========================================================================
|
||||
*
|
||||
* Helper Functions
|
||||
*
|
||||
* ========================================================================= */
|
||||
|
||||
/* There are functions that are available for plugin developers to use in
|
||||
* mosquitto_broker.h, including logging and accessor functions.
|
||||
*/
|
||||
|
||||
|
||||
/* =========================================================================
|
||||
*
|
||||
* Section: Plugin Functions v5
|
||||
*
|
||||
* This is the plugin version 5 interface, which covers authentication, access
|
||||
* control, the $CONTROL topic space handling, and message inspection and
|
||||
* modification.
|
||||
*
|
||||
* This interface is available from v2.0 onwards.
|
||||
*
|
||||
* There are just three functions to implement in your plugin. You should
|
||||
* register callbacks to handle different events in your
|
||||
* mosquitto_plugin_init() function. See mosquitto_broker.h for the events and
|
||||
* callback registering functions.
|
||||
*
|
||||
* ========================================================================= */
|
||||
|
||||
/*
|
||||
* Function: mosquitto_plugin_version
|
||||
*
|
||||
* The broker will attempt to call this function immediately after loading the
|
||||
* plugin to check it is a supported plugin version. Your code must simply
|
||||
* return the plugin interface version you support, i.e. 5.
|
||||
*
|
||||
* The supported_versions array tells you which plugin versions the broker supports.
|
||||
*
|
||||
* If the broker does not support the version that you require, return -1 to
|
||||
* indicate failure.
|
||||
*
|
||||
* HELPER: If you only wish to declare support for a single version, you can
|
||||
* use the helper macro:
|
||||
*
|
||||
* MOSQUITTO_PLUGIN_DECLARE_VERSION(5);
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_plugin_version(int supported_version_count, const int *supported_versions);
|
||||
|
||||
#define MOSQUITTO_PLUGIN_DECLARE_VERSION(A) \
|
||||
int mosquitto_plugin_version(int supported_version_count, const int *supported_versions) \
|
||||
{ \
|
||||
int i; \
|
||||
for(i=0; i<supported_version_count; i++){ \
|
||||
if(supported_versions[i] == (A)){ \
|
||||
return (A); \
|
||||
} \
|
||||
} \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
/*
|
||||
* Function: mosquitto_plugin_init
|
||||
*
|
||||
* Called after the plugin has been loaded and <mosquitto_plugin_version>
|
||||
* has been called. This will only ever be called once and can be used to
|
||||
* initialise the plugin.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* identifier - This is a pointer to an opaque structure which you must
|
||||
* save and use when registering/unregistering callbacks.
|
||||
* user_data - The pointer set here will be passed to the other plugin
|
||||
* functions. Use to hold connection information for example.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_plugin_init(mosquitto_plugin_id_t *identifier, void **userdata, struct mosquitto_opt *options, int option_count);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_plugin_cleanup
|
||||
*
|
||||
* Called when the broker is shutting down. This will only ever be called once
|
||||
* per plugin.
|
||||
*
|
||||
* If you do not need to do any of your own cleanup, this function is not
|
||||
* required. The broker will automatically unregister your callbacks.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_plugin_cleanup(void *userdata, struct mosquitto_opt *options, int option_count);
|
||||
|
||||
|
||||
|
||||
/* =========================================================================
|
||||
*
|
||||
* Section: Plugin Functions v4
|
||||
*
|
||||
* This is the plugin version 4 interface, which is exclusively for
|
||||
* authentication and access control, and which is still supported for existing
|
||||
* plugins. If you are developing a new plugin, please use the v5 interface.
|
||||
*
|
||||
* You must implement these functions in your plugin.
|
||||
*
|
||||
* Authentication plugins can implement one or both of authentication and
|
||||
* access control. If your plugin does not wish to handle either of
|
||||
* authentication or access control it should return MOSQ_ERR_PLUGIN_DEFER. In
|
||||
* this case, the next plugin will handle it. If all plugins return
|
||||
* MOSQ_ERR_PLUGIN_DEFER, the request will be denied.
|
||||
*
|
||||
* For each check, the following flow happens:
|
||||
*
|
||||
* * The default password file and/or acl file checks are made. If either one
|
||||
* of these is not defined, then they are considered to be deferred. If either
|
||||
* one accepts the check, no further checks are made. If an error occurs, the
|
||||
* check is denied
|
||||
* * The first plugin does the check, if it returns anything other than
|
||||
* MOSQ_ERR_PLUGIN_DEFER, then the check returns immediately. If the plugin
|
||||
* returns MOSQ_ERR_PLUGIN_DEFER then the next plugin runs its check.
|
||||
* * If the final plugin returns MOSQ_ERR_PLUGIN_DEFER, then access will be
|
||||
* denied.
|
||||
* ========================================================================= */
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_plugin_version
|
||||
*
|
||||
* The broker will call this function immediately after loading the plugin to
|
||||
* check it is a supported plugin version. Your code must simply return
|
||||
* the version of the plugin interface you support, i.e. 4.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_plugin_version(void);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_plugin_init
|
||||
*
|
||||
* Called after the plugin has been loaded and <mosquitto_auth_plugin_version>
|
||||
* has been called. This will only ever be called once and can be used to
|
||||
* initialise the plugin.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer set here will be passed to the other plugin
|
||||
* functions. Use to hold connection information for example.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_plugin_init(void **user_data, struct mosquitto_opt *opts, int opt_count);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_plugin_cleanup
|
||||
*
|
||||
* Called when the broker is shutting down. This will only ever be called once
|
||||
* per plugin.
|
||||
* Note that <mosquitto_auth_security_cleanup> will be called directly before
|
||||
* this function.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_plugin_cleanup(void *user_data, struct mosquitto_opt *opts, int opt_count);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_security_init
|
||||
*
|
||||
* This function is called in two scenarios:
|
||||
*
|
||||
* 1. When the broker starts up.
|
||||
* 2. If the broker is requested to reload its configuration whilst running. In
|
||||
* this case, <mosquitto_auth_security_cleanup> will be called first, then
|
||||
* this function will be called. In this situation, the reload parameter
|
||||
* will be true.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
* reload - If set to false, this is the first time the function has
|
||||
* been called. If true, the broker has received a signal
|
||||
* asking to reload its configuration.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_security_init(void *user_data, struct mosquitto_opt *opts, int opt_count, bool reload);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_security_cleanup
|
||||
*
|
||||
* This function is called in two scenarios:
|
||||
*
|
||||
* 1. When the broker is shutting down.
|
||||
* 2. If the broker is requested to reload its configuration whilst running. In
|
||||
* this case, this function will be called, followed by
|
||||
* <mosquitto_auth_security_init>. In this situation, the reload parameter
|
||||
* will be true.
|
||||
*
|
||||
* Parameters:
|
||||
*
|
||||
* user_data - The pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* opts - Pointer to an array of struct mosquitto_opt, which
|
||||
* provides the plugin options defined in the configuration file.
|
||||
* opt_count - The number of elements in the opts array.
|
||||
* reload - If set to false, this is the first time the function has
|
||||
* been called. If true, the broker has received a signal
|
||||
* asking to reload its configuration.
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success
|
||||
* Return >0 on failure.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_security_cleanup(void *user_data, struct mosquitto_opt *opts, int opt_count, bool reload);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_acl_check
|
||||
*
|
||||
* Called by the broker when topic access must be checked. access will be one
|
||||
* of:
|
||||
* MOSQ_ACL_SUBSCRIBE when a client is asking to subscribe to a topic string.
|
||||
* This differs from MOSQ_ACL_READ in that it allows you to
|
||||
* deny access to topic strings rather than by pattern. For
|
||||
* example, you may use MOSQ_ACL_SUBSCRIBE to deny
|
||||
* subscriptions to '#', but allow all topics in
|
||||
* MOSQ_ACL_READ. This allows clients to subscribe to any
|
||||
* topic they want, but not discover what topics are in use
|
||||
* on the server.
|
||||
* MOSQ_ACL_READ when a message is about to be sent to a client (i.e. whether
|
||||
* it can read that topic or not).
|
||||
* MOSQ_ACL_WRITE when a message has been received from a client (i.e. whether
|
||||
* it can write to that topic or not).
|
||||
*
|
||||
* Return:
|
||||
* MOSQ_ERR_SUCCESS if access was granted.
|
||||
* MOSQ_ERR_ACL_DENIED if access was not granted.
|
||||
* MOSQ_ERR_UNKNOWN for an application specific error.
|
||||
* MOSQ_ERR_PLUGIN_DEFER if your plugin does not wish to handle this check.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_acl_check(void *user_data, int access, struct mosquitto *client, const struct mosquitto_acl_msg *msg);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_unpwd_check
|
||||
*
|
||||
* This function is OPTIONAL. Only include this function in your plugin if you
|
||||
* are making basic username/password checks.
|
||||
*
|
||||
* Called by the broker when a username/password must be checked.
|
||||
*
|
||||
* Return:
|
||||
* MOSQ_ERR_SUCCESS if the user is authenticated.
|
||||
* MOSQ_ERR_AUTH if authentication failed.
|
||||
* MOSQ_ERR_UNKNOWN for an application specific error.
|
||||
* MOSQ_ERR_PLUGIN_DEFER if your plugin does not wish to handle this check.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_unpwd_check(void *user_data, struct mosquitto *client, const char *username, const char *password);
|
||||
|
||||
|
||||
/*
|
||||
* Function: mosquitto_psk_key_get
|
||||
*
|
||||
* This function is OPTIONAL. Only include this function in your plugin if you
|
||||
* are making TLS-PSK checks.
|
||||
*
|
||||
* Called by the broker when a client connects to a listener using TLS/PSK.
|
||||
* This is used to retrieve the pre-shared-key associated with a client
|
||||
* identity.
|
||||
*
|
||||
* Examine hint and identity to determine the required PSK (which must be a
|
||||
* hexadecimal string with no leading "0x") and copy this string into key.
|
||||
*
|
||||
* Parameters:
|
||||
* user_data - the pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* hint - the psk_hint for the listener the client is connecting to.
|
||||
* identity - the identity string provided by the client
|
||||
* key - a string where the hex PSK should be copied
|
||||
* max_key_len - the size of key
|
||||
*
|
||||
* Return value:
|
||||
* Return 0 on success.
|
||||
* Return >0 on failure.
|
||||
* Return MOSQ_ERR_PLUGIN_DEFER if your plugin does not wish to handle this check.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_psk_key_get(void *user_data, struct mosquitto *client, const char *hint, const char *identity, char *key, int max_key_len);
|
||||
|
||||
/*
|
||||
* Function: mosquitto_auth_start
|
||||
*
|
||||
* This function is OPTIONAL. Only include this function in your plugin if you
|
||||
* are making extended authentication checks.
|
||||
*
|
||||
* Parameters:
|
||||
* user_data - the pointer provided in <mosquitto_auth_plugin_init>.
|
||||
* method - the authentication method
|
||||
* reauth - this is set to false if this is the first authentication attempt
|
||||
* on a connection, set to true if the client is attempting to
|
||||
* reauthenticate.
|
||||
* data_in - pointer to authentication data, or NULL
|
||||
* data_in_len - length of data_in, in bytes
|
||||
* data_out - if your plugin wishes to send authentication data back to the
|
||||
* client, allocate some memory using malloc or friends and set
|
||||
* data_out. The broker will free the memory after use.
|
||||
* data_out_len - Set the length of data_out in bytes.
|
||||
*
|
||||
* Return value:
|
||||
* Return MOSQ_ERR_SUCCESS if authentication was successful.
|
||||
* Return MOSQ_ERR_AUTH_CONTINUE if the authentication is a multi step process and can continue.
|
||||
* Return MOSQ_ERR_AUTH if authentication was valid but did not succeed.
|
||||
* Return any other relevant positive integer MOSQ_ERR_* to produce an error.
|
||||
*/
|
||||
mosq_plugin_EXPORT int mosquitto_auth_start(void *user_data, struct mosquitto *client, const char *method, bool reauth, const void *data_in, uint16_t data_in_len, void **data_out, uint16_t *data_out_len);
|
||||
|
||||
mosq_plugin_EXPORT int mosquitto_auth_continue(void *user_data, struct mosquitto *client, const char *method, const void *data_in, uint16_t data_in_len, void **data_out, uint16_t *data_out_len);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#include <mosquitto/broker_plugin.h>
|
||||
#warning "Please replace '#include <broker_plugin.h> with #include <mosquitto.h>"
|
||||
|
||||
+2
-162
@@ -1,162 +1,2 @@
|
||||
/*
|
||||
Copyright (c) 2010-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MOSQUITTOPP_H
|
||||
#define MOSQUITTOPP_H
|
||||
|
||||
#if defined(_WIN32) && !defined(LIBMOSQUITTO_STATIC)
|
||||
# ifdef mosquittopp_EXPORTS
|
||||
# define mosqpp_EXPORT __declspec(dllexport)
|
||||
# else
|
||||
# define mosqpp_EXPORT __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define mosqpp_EXPORT
|
||||
#endif
|
||||
|
||||
#include <cstdlib>
|
||||
#include <mosquitto.h>
|
||||
#include <time.h>
|
||||
|
||||
namespace mosqpp {
|
||||
|
||||
|
||||
mosqpp_EXPORT const char * strerror(int mosq_errno);
|
||||
mosqpp_EXPORT const char * connack_string(int connack_code);
|
||||
mosqpp_EXPORT const char * reason_string(int reason_code);
|
||||
mosqpp_EXPORT int sub_topic_tokenise(const char *subtopic, char ***topics, int *count);
|
||||
mosqpp_EXPORT int sub_topic_tokens_free(char ***topics, int count);
|
||||
mosqpp_EXPORT int lib_version(int *major, int *minor, int *revision);
|
||||
mosqpp_EXPORT int lib_init();
|
||||
mosqpp_EXPORT int lib_cleanup();
|
||||
mosqpp_EXPORT int topic_matches_sub(const char *sub, const char *topic, bool *result);
|
||||
mosqpp_EXPORT int topic_matches_sub_with_pattern(const char *sub, const char *topic, const char *clientid, const char *username, bool *result);
|
||||
mosqpp_EXPORT int sub_matches_acl(const char *acl, const char *sub, bool *result);
|
||||
mosqpp_EXPORT int sub_matches_acl_with_pattern(const char *acl, const char *sub, const char *clientid, const char *username, bool *result);
|
||||
mosqpp_EXPORT int validate_utf8(const char *str, int len);
|
||||
mosqpp_EXPORT int subscribe_simple(
|
||||
struct mosquitto_message **messages,
|
||||
int msg_count,
|
||||
bool retained,
|
||||
const char *topic,
|
||||
int qos=0,
|
||||
const char *host="localhost",
|
||||
int port=1883,
|
||||
const char *clientid=NULL,
|
||||
int keepalive=60,
|
||||
bool clean_session=true,
|
||||
const char *username=NULL,
|
||||
const char *password=NULL,
|
||||
const struct libmosquitto_will *will=NULL,
|
||||
const struct libmosquitto_tls *tls=NULL);
|
||||
|
||||
mosqpp_EXPORT int subscribe_callback(
|
||||
int (*callback)(struct mosquitto *, void *, const struct mosquitto_message *),
|
||||
void *userdata,
|
||||
const char *topic,
|
||||
int qos=0,
|
||||
const char *host="localhost",
|
||||
int port=1883,
|
||||
const char *clientid=NULL,
|
||||
int keepalive=60,
|
||||
bool clean_session=true,
|
||||
const char *username=NULL,
|
||||
const char *password=NULL,
|
||||
const struct libmosquitto_will *will=NULL,
|
||||
const struct libmosquitto_tls *tls=NULL);
|
||||
|
||||
mosqpp_EXPORT int property_check_command(int command, int identifier);
|
||||
mosqpp_EXPORT int property_check_all(int command, const mosquitto_property *properties);
|
||||
|
||||
/*
|
||||
* Class: mosquittopp
|
||||
*
|
||||
* A mosquitto client class. This is a C++ wrapper class for the mosquitto C
|
||||
* library. Please see mosquitto.h for details of the functions.
|
||||
*/
|
||||
class mosqpp_EXPORT mosquittopp {
|
||||
private:
|
||||
struct mosquitto *m_mosq;
|
||||
public:
|
||||
mosquittopp(const char *id=NULL, bool clean_session=true);
|
||||
virtual ~mosquittopp();
|
||||
|
||||
int reinitialise(const char *id, bool clean_session);
|
||||
int socket();
|
||||
int will_set(const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false);
|
||||
int will_set_v5(const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false, mosquitto_property *properties=NULL);
|
||||
int will_clear();
|
||||
int username_pw_set(const char *username, const char *password=NULL);
|
||||
int connect(const char *host, int port=1883, int keepalive=60);
|
||||
int connect(const char *host, int port, int keepalive, const char *bind_address);
|
||||
int connect_v5(const char *host, int port, int keepalive, const char *bind_address, const mosquitto_property *properties);
|
||||
int connect_async(const char *host, int port=1883, int keepalive=60);
|
||||
int connect_async(const char *host, int port, int keepalive, const char *bind_address);
|
||||
int reconnect();
|
||||
int reconnect_async();
|
||||
int disconnect();
|
||||
int disconnect_v5(int reason_code, const mosquitto_property *properties);
|
||||
int publish(int *mid, const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false);
|
||||
int publish_v5(int *mid, const char *topic, int payloadlen=0, const void *payload=NULL, int qos=0, bool retain=false, const mosquitto_property *properties=NULL);
|
||||
int subscribe(int *mid, const char *sub, int qos=0);
|
||||
int subscribe_v5(int *mid, const char *sub, int qos=0, int options=0, const mosquitto_property *properties=NULL);
|
||||
int unsubscribe(int *mid, const char *sub);
|
||||
int unsubscribe_v5(int *mid, const char *sub, const mosquitto_property *properties);
|
||||
void reconnect_delay_set(unsigned int reconnect_delay, unsigned int reconnect_delay_max, bool reconnect_exponential_backoff);
|
||||
int max_inflight_messages_set(unsigned int max_inflight_messages);
|
||||
void message_retry_set(unsigned int message_retry);
|
||||
void user_data_set(void *userdata);
|
||||
int tls_set(const char *cafile, const char *capath=NULL, const char *certfile=NULL, const char *keyfile=NULL, int (*pw_callback)(char *buf, int size, int rwflag, void *userdata)=NULL);
|
||||
int tls_opts_set(int cert_reqs, const char *tls_version=NULL, const char *ciphers=NULL);
|
||||
int tls_insecure_set(bool value);
|
||||
int tls_psk_set(const char *psk, const char *identity, const char *ciphers=NULL);
|
||||
int opts_set(enum mosq_opt_t option, void *value);
|
||||
int int_option(enum mosq_opt_t option, int value);
|
||||
int string_option(enum mosq_opt_t option, const char *value);
|
||||
int void_option(enum mosq_opt_t option, void *value);
|
||||
|
||||
int loop(int timeout=-1, int max_packets=1);
|
||||
int loop_misc();
|
||||
int loop_read(int max_packets=1);
|
||||
int loop_write(int max_packets=1);
|
||||
int loop_forever(int timeout=-1, int max_packets=1);
|
||||
int loop_start();
|
||||
int loop_stop(bool force=false);
|
||||
bool want_write();
|
||||
int threaded_set(bool threaded=true);
|
||||
int socks5_set(const char *host, int port=1080, const char *username=NULL, const char *password=NULL);
|
||||
|
||||
// names in the functions commented to prevent unused parameter warning
|
||||
virtual void on_pre_connect() {return;}
|
||||
virtual void on_connect(int /*rc*/) {return;}
|
||||
virtual void on_connect_with_flags(int /*rc*/, int /*flags*/) {return;}
|
||||
virtual void on_connect_v5(int /*rc*/, int /*flags*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_disconnect(int /*rc*/) {return;}
|
||||
virtual void on_disconnect_v5(int /*rc*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_publish(int /*mid*/) {return;}
|
||||
virtual void on_publish_v5(int /*mid*/, int /*reason_code*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_message(const struct mosquitto_message * /*message*/) {return;}
|
||||
virtual void on_message_v5(const struct mosquitto_message * /*message*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_subscribe(int /*mid*/, int /*qos_count*/, const int * /*granted_qos*/) {return;}
|
||||
virtual void on_subscribe_v5(int /*mid*/, int /*qos_count*/, const int * /*granted_qos*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_unsubscribe(int /*mid*/) {return;}
|
||||
virtual void on_unsubscribe_v5(int /*mid*/, const mosquitto_property * /*props*/) {return;}
|
||||
virtual void on_log(int /*level*/, const char * /*str*/) {return;}
|
||||
virtual void on_error() {return;}
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
#include <mosquitto/libmosquittopp.h>
|
||||
#warning "Please replace '#include <mosquittopp.h> with #include <mosquitto/libmosquittopp.h>"
|
||||
|
||||
+2
-292
@@ -1,292 +1,2 @@
|
||||
/*
|
||||
Copyright (c) 2009-2021 Roger Light <roger@atchoo.org>
|
||||
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are made available under the terms of the Eclipse Public License 2.0
|
||||
and Eclipse Distribution License v1.0 which accompany this distribution.
|
||||
|
||||
The Eclipse Public License is available at
|
||||
https://www.eclipse.org/legal/epl-2.0/
|
||||
and the Eclipse Distribution License is available at
|
||||
http://www.eclipse.org/org/documents/edl-v10.php.
|
||||
|
||||
SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
|
||||
|
||||
Contributors:
|
||||
Roger Light - initial implementation and documentation.
|
||||
*/
|
||||
|
||||
#ifndef MQTT_PROTOCOL_H
|
||||
#define MQTT_PROTOCOL_H
|
||||
|
||||
/*
|
||||
* File: mqtt_protocol.h
|
||||
*
|
||||
* This header contains definitions of MQTT values as defined in the specifications.
|
||||
*/
|
||||
#define PROTOCOL_NAME_v31 "MQIsdp"
|
||||
#define PROTOCOL_VERSION_v31 3
|
||||
|
||||
#define PROTOCOL_NAME "MQTT"
|
||||
|
||||
#define PROTOCOL_VERSION_v311 4
|
||||
#define PROTOCOL_VERSION_v5 5
|
||||
|
||||
|
||||
/* Message types */
|
||||
#define CMD_CONNECT 0x10U
|
||||
#define CMD_CONNACK 0x20U
|
||||
#define CMD_PUBLISH 0x30U
|
||||
#define CMD_PUBACK 0x40U
|
||||
#define CMD_PUBREC 0x50U
|
||||
#define CMD_PUBREL 0x60U
|
||||
#define CMD_PUBCOMP 0x70U
|
||||
#define CMD_SUBSCRIBE 0x80U
|
||||
#define CMD_SUBACK 0x90U
|
||||
#define CMD_UNSUBSCRIBE 0xA0U
|
||||
#define CMD_UNSUBACK 0xB0U
|
||||
#define CMD_PINGREQ 0xC0U
|
||||
#define CMD_PINGRESP 0xD0U
|
||||
#define CMD_DISCONNECT 0xE0U
|
||||
#define CMD_AUTH 0xF0U
|
||||
|
||||
/* Mosquitto only: for distinguishing CONNECT and WILL properties */
|
||||
#define CMD_WILL 0x100
|
||||
|
||||
/* Enum: mqtt311_connack_codes
|
||||
*
|
||||
* The CONNACK results for MQTT v3.1.1, and v3.1.
|
||||
*
|
||||
* Values:
|
||||
* CONNACK_ACCEPTED - 0
|
||||
* CONNACK_REFUSED_PROTOCOL_VERSION - 1
|
||||
* CONNACK_REFUSED_IDENTIFIER_REJECTED - 2
|
||||
* CONNACK_REFUSED_SERVER_UNAVAILABLE - 3
|
||||
* CONNACK_REFUSED_BAD_USERNAME_PASSWORD - 4
|
||||
* CONNACK_REFUSED_NOT_AUTHORIZED - 5
|
||||
*/
|
||||
enum mqtt311_connack_codes {
|
||||
CONNACK_ACCEPTED = 0,
|
||||
CONNACK_REFUSED_PROTOCOL_VERSION = 1,
|
||||
CONNACK_REFUSED_IDENTIFIER_REJECTED = 2,
|
||||
CONNACK_REFUSED_SERVER_UNAVAILABLE = 3,
|
||||
CONNACK_REFUSED_BAD_USERNAME_PASSWORD = 4,
|
||||
CONNACK_REFUSED_NOT_AUTHORIZED = 5,
|
||||
};
|
||||
|
||||
/* Enum: mqtt5_return_codes
|
||||
* The reason codes returned in various MQTT commands.
|
||||
*
|
||||
* Values:
|
||||
* MQTT_RC_SUCCESS - 0
|
||||
* MQTT_RC_NORMAL_DISCONNECTION - 0
|
||||
* MQTT_RC_GRANTED_QOS0 - 0
|
||||
* MQTT_RC_GRANTED_QOS1 - 1
|
||||
* MQTT_RC_GRANTED_QOS2 - 2
|
||||
* MQTT_RC_DISCONNECT_WITH_WILL_MSG - 4
|
||||
* MQTT_RC_NO_MATCHING_SUBSCRIBERS - 16
|
||||
* MQTT_RC_NO_SUBSCRIPTION_EXISTED - 17
|
||||
* MQTT_RC_CONTINUE_AUTHENTICATION - 24
|
||||
* MQTT_RC_REAUTHENTICATE - 25
|
||||
* MQTT_RC_UNSPECIFIED - 128
|
||||
* MQTT_RC_MALFORMED_PACKET - 129
|
||||
* MQTT_RC_PROTOCOL_ERROR - 130
|
||||
* MQTT_RC_IMPLEMENTATION_SPECIFIC - 131
|
||||
* MQTT_RC_UNSUPPORTED_PROTOCOL_VERSION - 132
|
||||
* MQTT_RC_CLIENTID_NOT_VALID - 133
|
||||
* MQTT_RC_BAD_USERNAME_OR_PASSWORD - 134
|
||||
* MQTT_RC_NOT_AUTHORIZED - 135
|
||||
* MQTT_RC_SERVER_UNAVAILABLE - 136
|
||||
* MQTT_RC_SERVER_BUSY - 137
|
||||
* MQTT_RC_BANNED - 138
|
||||
* MQTT_RC_SERVER_SHUTTING_DOWN - 139
|
||||
* MQTT_RC_BAD_AUTHENTICATION_METHOD - 140
|
||||
* MQTT_RC_KEEP_ALIVE_TIMEOUT - 141
|
||||
* MQTT_RC_SESSION_TAKEN_OVER - 142
|
||||
* MQTT_RC_TOPIC_FILTER_INVALID - 143
|
||||
* MQTT_RC_TOPIC_NAME_INVALID - 144
|
||||
* MQTT_RC_PACKET_ID_IN_USE - 145
|
||||
* MQTT_RC_PACKET_ID_NOT_FOUND - 146
|
||||
* MQTT_RC_RECEIVE_MAXIMUM_EXCEEDED - 147
|
||||
* MQTT_RC_TOPIC_ALIAS_INVALID - 148
|
||||
* MQTT_RC_PACKET_TOO_LARGE - 149
|
||||
* MQTT_RC_MESSAGE_RATE_TOO_HIGH - 150
|
||||
* MQTT_RC_QUOTA_EXCEEDED - 151
|
||||
* MQTT_RC_ADMINISTRATIVE_ACTION - 152
|
||||
* MQTT_RC_PAYLOAD_FORMAT_INVALID - 153
|
||||
* MQTT_RC_RETAIN_NOT_SUPPORTED - 154
|
||||
* MQTT_RC_QOS_NOT_SUPPORTED - 155
|
||||
* MQTT_RC_USE_ANOTHER_SERVER - 156
|
||||
* MQTT_RC_SERVER_MOVED - 157
|
||||
* MQTT_RC_SHARED_SUBS_NOT_SUPPORTED - 158
|
||||
* MQTT_RC_CONNECTION_RATE_EXCEEDED - 159
|
||||
* MQTT_RC_MAXIMUM_CONNECT_TIME - 160
|
||||
* MQTT_RC_SUBSCRIPTION_IDS_NOT_SUPPORTED - 161
|
||||
* MQTT_RC_WILDCARD_SUBS_NOT_SUPPORTED - 162
|
||||
*/
|
||||
enum mqtt5_return_codes {
|
||||
MQTT_RC_SUCCESS = 0, /* CONNACK, PUBACK, PUBREC, PUBREL, PUBCOMP, UNSUBACK, AUTH */
|
||||
MQTT_RC_NORMAL_DISCONNECTION = 0, /* DISCONNECT */
|
||||
MQTT_RC_GRANTED_QOS0 = 0, /* SUBACK */
|
||||
MQTT_RC_GRANTED_QOS1 = 1, /* SUBACK */
|
||||
MQTT_RC_GRANTED_QOS2 = 2, /* SUBACK */
|
||||
MQTT_RC_DISCONNECT_WITH_WILL_MSG = 4, /* DISCONNECT */
|
||||
MQTT_RC_NO_MATCHING_SUBSCRIBERS = 16, /* PUBACK, PUBREC */
|
||||
MQTT_RC_NO_SUBSCRIPTION_EXISTED = 17, /* UNSUBACK */
|
||||
MQTT_RC_CONTINUE_AUTHENTICATION = 24, /* AUTH */
|
||||
MQTT_RC_REAUTHENTICATE = 25, /* AUTH */
|
||||
|
||||
MQTT_RC_UNSPECIFIED = 128, /* CONNACK, PUBACK, PUBREC, SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_MALFORMED_PACKET = 129, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_PROTOCOL_ERROR = 130, /* DISCONNECT */
|
||||
MQTT_RC_IMPLEMENTATION_SPECIFIC = 131, /* CONNACK, PUBACK, PUBREC, SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_UNSUPPORTED_PROTOCOL_VERSION = 132, /* CONNACK */
|
||||
MQTT_RC_CLIENTID_NOT_VALID = 133, /* CONNACK */
|
||||
MQTT_RC_BAD_USERNAME_OR_PASSWORD = 134, /* CONNACK */
|
||||
MQTT_RC_NOT_AUTHORIZED = 135, /* CONNACK, PUBACK, PUBREC, SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_SERVER_UNAVAILABLE = 136, /* CONNACK */
|
||||
MQTT_RC_SERVER_BUSY = 137, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_BANNED = 138, /* CONNACK */
|
||||
MQTT_RC_SERVER_SHUTTING_DOWN = 139, /* DISCONNECT */
|
||||
MQTT_RC_BAD_AUTHENTICATION_METHOD = 140, /* CONNACK */
|
||||
MQTT_RC_KEEP_ALIVE_TIMEOUT = 141, /* DISCONNECT */
|
||||
MQTT_RC_SESSION_TAKEN_OVER = 142, /* DISCONNECT */
|
||||
MQTT_RC_TOPIC_FILTER_INVALID = 143, /* SUBACK, UNSUBACK, DISCONNECT */
|
||||
MQTT_RC_TOPIC_NAME_INVALID = 144, /* CONNACK, PUBACK, PUBREC, DISCONNECT */
|
||||
MQTT_RC_PACKET_ID_IN_USE = 145, /* PUBACK, SUBACK, UNSUBACK */
|
||||
MQTT_RC_PACKET_ID_NOT_FOUND = 146, /* PUBREL, PUBCOMP */
|
||||
MQTT_RC_RECEIVE_MAXIMUM_EXCEEDED = 147, /* DISCONNECT */
|
||||
MQTT_RC_TOPIC_ALIAS_INVALID = 148, /* DISCONNECT */
|
||||
MQTT_RC_PACKET_TOO_LARGE = 149, /* CONNACK, PUBACK, PUBREC, DISCONNECT */
|
||||
MQTT_RC_MESSAGE_RATE_TOO_HIGH = 150, /* DISCONNECT */
|
||||
MQTT_RC_QUOTA_EXCEEDED = 151, /* PUBACK, PUBREC, SUBACK, DISCONNECT */
|
||||
MQTT_RC_ADMINISTRATIVE_ACTION = 152, /* DISCONNECT */
|
||||
MQTT_RC_PAYLOAD_FORMAT_INVALID = 153, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_RETAIN_NOT_SUPPORTED = 154, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_QOS_NOT_SUPPORTED = 155, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_USE_ANOTHER_SERVER = 156, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_SERVER_MOVED = 157, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_SHARED_SUBS_NOT_SUPPORTED = 158, /* SUBACK, DISCONNECT */
|
||||
MQTT_RC_CONNECTION_RATE_EXCEEDED = 159, /* CONNACK, DISCONNECT */
|
||||
MQTT_RC_MAXIMUM_CONNECT_TIME = 160, /* DISCONNECT */
|
||||
MQTT_RC_SUBSCRIPTION_IDS_NOT_SUPPORTED = 161, /* SUBACK, DISCONNECT */
|
||||
MQTT_RC_WILDCARD_SUBS_NOT_SUPPORTED = 162, /* SUBACK, DISCONNECT */
|
||||
};
|
||||
|
||||
/* Enum: mqtt5_property
|
||||
* Options for use with MQTTv5 properties.
|
||||
* Options:
|
||||
*
|
||||
* MQTT_PROP_PAYLOAD_FORMAT_INDICATOR - property option.
|
||||
* MQTT_PROP_MESSAGE_EXPIRY_INTERVAL - property option.
|
||||
* MQTT_PROP_CONTENT_TYPE - property option.
|
||||
* MQTT_PROP_RESPONSE_TOPIC - property option.
|
||||
* MQTT_PROP_CORRELATION_DATA - property option.
|
||||
* MQTT_PROP_SUBSCRIPTION_IDENTIFIER - property option.
|
||||
* MQTT_PROP_SESSION_EXPIRY_INTERVAL - property option.
|
||||
* MQTT_PROP_ASSIGNED_CLIENT_IDENTIFIER - property option.
|
||||
* MQTT_PROP_SERVER_KEEP_ALIVE - property option.
|
||||
* MQTT_PROP_AUTHENTICATION_METHOD - property option.
|
||||
* MQTT_PROP_AUTHENTICATION_DATA - property option.
|
||||
* MQTT_PROP_REQUEST_PROBLEM_INFORMATION - property option.
|
||||
* MQTT_PROP_WILL_DELAY_INTERVAL - property option.
|
||||
* MQTT_PROP_REQUEST_RESPONSE_INFORMATION - property option.
|
||||
* MQTT_PROP_RESPONSE_INFORMATION - property option.
|
||||
* MQTT_PROP_SERVER_REFERENCE - property option.
|
||||
* MQTT_PROP_REASON_STRING - property option.
|
||||
* MQTT_PROP_RECEIVE_MAXIMUM - property option.
|
||||
* MQTT_PROP_TOPIC_ALIAS_MAXIMUM - property option.
|
||||
* MQTT_PROP_TOPIC_ALIAS - property option.
|
||||
* MQTT_PROP_MAXIMUM_QOS - property option.
|
||||
* MQTT_PROP_RETAIN_AVAILABLE - property option.
|
||||
* MQTT_PROP_USER_PROPERTY - property option.
|
||||
* MQTT_PROP_MAXIMUM_PACKET_SIZE - property option.
|
||||
* MQTT_PROP_WILDCARD_SUB_AVAILABLE - property option.
|
||||
* MQTT_PROP_SUBSCRIPTION_ID_AVAILABLE - property option.
|
||||
* MQTT_PROP_SHARED_SUB_AVAILABLE - property option.
|
||||
*/
|
||||
enum mqtt5_property {
|
||||
MQTT_PROP_PAYLOAD_FORMAT_INDICATOR = 1, /* Byte : PUBLISH, Will Properties */
|
||||
MQTT_PROP_MESSAGE_EXPIRY_INTERVAL = 2, /* 4 byte int : PUBLISH, Will Properties */
|
||||
MQTT_PROP_CONTENT_TYPE = 3, /* UTF-8 string : PUBLISH, Will Properties */
|
||||
MQTT_PROP_RESPONSE_TOPIC = 8, /* UTF-8 string : PUBLISH, Will Properties */
|
||||
MQTT_PROP_CORRELATION_DATA = 9, /* Binary Data : PUBLISH, Will Properties */
|
||||
MQTT_PROP_SUBSCRIPTION_IDENTIFIER = 11, /* Variable byte int : PUBLISH, SUBSCRIBE */
|
||||
MQTT_PROP_SESSION_EXPIRY_INTERVAL = 17, /* 4 byte int : CONNECT, CONNACK, DISCONNECT */
|
||||
MQTT_PROP_ASSIGNED_CLIENT_IDENTIFIER = 18, /* UTF-8 string : CONNACK */
|
||||
MQTT_PROP_SERVER_KEEP_ALIVE = 19, /* 2 byte int : CONNACK */
|
||||
MQTT_PROP_AUTHENTICATION_METHOD = 21, /* UTF-8 string : CONNECT, CONNACK, AUTH */
|
||||
MQTT_PROP_AUTHENTICATION_DATA = 22, /* Binary Data : CONNECT, CONNACK, AUTH */
|
||||
MQTT_PROP_REQUEST_PROBLEM_INFORMATION = 23, /* Byte : CONNECT */
|
||||
MQTT_PROP_WILL_DELAY_INTERVAL = 24, /* 4 byte int : Will properties */
|
||||
MQTT_PROP_REQUEST_RESPONSE_INFORMATION = 25,/* Byte : CONNECT */
|
||||
MQTT_PROP_RESPONSE_INFORMATION = 26, /* UTF-8 string : CONNACK */
|
||||
MQTT_PROP_SERVER_REFERENCE = 28, /* UTF-8 string : CONNACK, DISCONNECT */
|
||||
MQTT_PROP_REASON_STRING = 31, /* UTF-8 string : CONNACK, PUBACK, PUBREC, PUBREL, PUBCOMP, SUBACK, UNSUBACK, DISCONNECT, AUTH */
|
||||
MQTT_PROP_RECEIVE_MAXIMUM = 33, /* 2 byte int : CONNECT, CONNACK */
|
||||
MQTT_PROP_TOPIC_ALIAS_MAXIMUM = 34, /* 2 byte int : CONNECT, CONNACK */
|
||||
MQTT_PROP_TOPIC_ALIAS = 35, /* 2 byte int : PUBLISH */
|
||||
MQTT_PROP_MAXIMUM_QOS = 36, /* Byte : CONNACK */
|
||||
MQTT_PROP_RETAIN_AVAILABLE = 37, /* Byte : CONNACK */
|
||||
MQTT_PROP_USER_PROPERTY = 38, /* UTF-8 string pair : All */
|
||||
MQTT_PROP_MAXIMUM_PACKET_SIZE = 39, /* 4 byte int : CONNECT, CONNACK */
|
||||
MQTT_PROP_WILDCARD_SUB_AVAILABLE = 40, /* Byte : CONNACK */
|
||||
MQTT_PROP_SUBSCRIPTION_ID_AVAILABLE = 41, /* Byte : CONNACK */
|
||||
MQTT_PROP_SHARED_SUB_AVAILABLE = 42, /* Byte : CONNACK */
|
||||
};
|
||||
|
||||
enum mqtt5_property_type {
|
||||
MQTT_PROP_TYPE_BYTE = 1,
|
||||
MQTT_PROP_TYPE_INT16 = 2,
|
||||
MQTT_PROP_TYPE_INT32 = 3,
|
||||
MQTT_PROP_TYPE_VARINT = 4,
|
||||
MQTT_PROP_TYPE_BINARY = 5,
|
||||
MQTT_PROP_TYPE_STRING = 6,
|
||||
MQTT_PROP_TYPE_STRING_PAIR = 7
|
||||
};
|
||||
|
||||
/* Enum: mqtt5_sub_options
|
||||
* Options for use with MQTTv5 subscriptions.
|
||||
*
|
||||
* MQTT_SUB_OPT_NO_LOCAL - with this option set, if this client publishes to
|
||||
* a topic to which it is subscribed, the broker will not publish the
|
||||
* message back to the client.
|
||||
*
|
||||
* MQTT_SUB_OPT_RETAIN_AS_PUBLISHED - with this option set, messages
|
||||
* published for this subscription will keep the retain flag as was set by
|
||||
* the publishing client. The default behaviour without this option set has
|
||||
* the retain flag indicating whether a message is fresh/stale.
|
||||
*
|
||||
* MQTT_SUB_OPT_SEND_RETAIN_ALWAYS - with this option set, pre-existing
|
||||
* retained messages are sent as soon as the subscription is made, even
|
||||
* if the subscription already exists. This is the default behaviour, so
|
||||
* it is not necessary to set this option.
|
||||
*
|
||||
* MQTT_SUB_OPT_SEND_RETAIN_NEW - with this option set, pre-existing retained
|
||||
* messages for this subscription will be sent when the subscription is made,
|
||||
* but only if the subscription does not already exist.
|
||||
*
|
||||
* MQTT_SUB_OPT_SEND_RETAIN_NEVER - with this option set, pre-existing
|
||||
* retained messages will never be sent for this subscription.
|
||||
*/
|
||||
enum mqtt5_sub_options {
|
||||
MQTT_SUB_OPT_NO_LOCAL = 0x04,
|
||||
MQTT_SUB_OPT_RETAIN_AS_PUBLISHED = 0x08,
|
||||
MQTT_SUB_OPT_SEND_RETAIN_ALWAYS = 0x00,
|
||||
MQTT_SUB_OPT_SEND_RETAIN_NEW = 0x10,
|
||||
MQTT_SUB_OPT_SEND_RETAIN_NEVER = 0x20,
|
||||
};
|
||||
|
||||
#define MQTT_MAX_PAYLOAD 268435455U
|
||||
|
||||
#define MQTT_SUB_OPT_GET_QOS(opt) ((opt) & 0x03)
|
||||
#define MQTT_SUB_OPT_GET_NO_LOCAL(opt) ((opt) & MQTT_SUB_OPT_NO_LOCAL)
|
||||
#define MQTT_SUB_OPT_GET_RETAIN_AS_PUBLISHED(opt) ((opt) & MQTT_SUB_OPT_RETAIN_AS_PUBLISHED)
|
||||
#define MQTT_SUB_OPT_GET_SEND_RETAIN(opt) ((opt) & (MQTT_SUB_OPT_SEND_RETAIN_NEW | MQTT_SUB_OPT_SEND_RETAIN_NEVER))
|
||||
|
||||
#define MQTT_SUB_OPT_SET_QOS(opt, qos) ((opt) = ((opt) & 0xFC) | ((qos) & 0x03))
|
||||
|
||||
#define MQTT_SUB_OPT_SET(opt, val) ((opt) |= val)
|
||||
#define MQTT_SUB_OPT_CLEAR(opt, val) ((opt) = (opt) & !val)
|
||||
|
||||
#endif
|
||||
#include <mosquitto/mqtt_protocol.h>
|
||||
#warning "Please replace '#include <mqtt_protocol.h> with #include <mosquitto.h>"
|
||||
|
||||
Reference in New Issue
Block a user