Merge branch 'fixes'

CMakeLists.txt

@@ -8,7 +8,7 @@ cmake_minimum_required(VERSION 3.0)
 cmake_policy(SET CMP0042 NEW)
 
 project(mosquitto)
-set (VERSION 2.0.13)
+set (VERSION 2.0.14)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/")
 

ChangeLog.txt

@@ -1,3 +1,15 @@
+2.0.14 - 2021-11-17
+===================
+
+Broker:
+- Fix bridge not respecting receive-maximum when reconnecting with MQTT v5.
+
+Client library:
+- Fix mosquitto_topic_matches_sub2() not using the length parameters.
+  Closes #2364.
+- Fix incorrect subscribe_callback in mosquittopp.h. Closes #2367.
+
+
 2.0.13 - 2021-10-27
 ===================
 

config.mk

@@ -127,7 +127,7 @@ WITH_XTREPORT=no
 
 # Also bump lib/mosquitto.h, CMakeLists.txt,
 # installer/mosquitto.nsi, installer/mosquitto64.nsi
-VERSION=2.0.13
+VERSION=2.0.14
 
 # Client library SO version. Bump if incompatible API/ABI changes are made.
 SOVERSION=1
@@ -333,11 +333,6 @@ ifeq ($(WITH_WEBSOCKETS),yes)
 	BROKER_LDADD:=$(BROKER_LDADD) -lwebsockets
 endif
 
-ifeq ($(WITH_WEBSOCKETS),static)
-	BROKER_CPPFLAGS:=$(BROKER_CPPFLAGS) -DWITH_WEBSOCKETS
-	BROKER_LDADD:=$(BROKER_LDADD) -static -lwebsockets
-endif
-
 INSTALL?=install
 prefix?=/usr/local
 incdir?=${prefix}/include

include/mosquitto.h

@@ -66,7 +66,7 @@ extern "C" {
 
 #define LIBMOSQUITTO_MAJOR 2
 #define LIBMOSQUITTO_MINOR 0
-#define LIBMOSQUITTO_REVISION 13
+#define LIBMOSQUITTO_REVISION 14
 /* 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)
 

installer/mosquitto.nsi

@@ -9,7 +9,7 @@
 !define env_hklm 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
 
 Name "Eclipse Mosquitto"
-!define VERSION 2.0.13
+!define VERSION 2.0.14
 OutFile "mosquitto-${VERSION}-install-windows-x86.exe"
 
 InstallDir "$PROGRAMFILES\mosquitto"

installer/mosquitto64.nsi

@@ -9,7 +9,7 @@
 !define env_hklm 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
 
 Name "Eclipse Mosquitto"
-!define VERSION 2.0.13
+!define VERSION 2.0.14
 OutFile "mosquitto-${VERSION}-install-windows-x64.exe"
 
 !include "x64.nsh"

lib/CMakeLists.txt

@@ -96,7 +96,10 @@ set_target_properties(libmosquitto PROPERTIES
 	SOVERSION 1
 )
 
-install(TARGETS libmosquitto RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+install(TARGETS libmosquitto
+	RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+	ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+	LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
 
 if (WITH_STATIC_LIBRARIES)
 	add_library(libmosquitto_static STATIC ${C_SRC})

lib/cpp/CMakeLists.txt

@@ -14,7 +14,10 @@ set_target_properties(mosquittopp PROPERTIES
 	VERSION ${VERSION}
 	SOVERSION 1
 )
-install(TARGETS mosquittopp RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+install(TARGETS mosquittopp
+	RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+	ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+	LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
 
 if (WITH_STATIC_LIBRARIES)
 	add_library(mosquittopp_static STATIC

lib/cpp/mosquittopp.h

@@ -64,7 +64,6 @@ mosqpp_EXPORT int subscribe_callback(
 		void *userdata,
 		const char *topic,
 		int qos=0,
-		bool retained=true,
 		const char *host="localhost",
 		int port=1883,
 		const char *client_id=NULL,

lib/handle_auth.c

@@ -36,7 +36,7 @@ int handle__auth(struct mosquitto *mosq)
 	mosquitto_property *properties = NULL;
 
 	if(!mosq) return MOSQ_ERR_INVAL;
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received AUTH", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received AUTH", SAFE_PRINT(mosq->id));
 
 	if(mosq->protocol != mosq_p_mqtt5){
 		return MOSQ_ERR_PROTOCOL;

lib/handle_connack.c

@@ -32,7 +32,7 @@ Contributors:
 
 static void connack_callback(struct mosquitto *mosq, uint8_t reason_code, uint8_t connect_flags, const mosquitto_property *properties)
 {
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received CONNACK (%d)", mosq->id, reason_code);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received CONNACK (%d)", SAFE_PRINT(mosq->id), reason_code);
 	if(reason_code == MQTT_RC_SUCCESS){
 		mosq->reconnects = 0;
 	}

lib/handle_ping.c

@@ -49,7 +49,7 @@ int handle__pingreq(struct mosquitto *mosq)
 	}
 
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PINGREQ from %s", mosq->id);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PINGREQ from %s", SAFE_PRINT(mosq->id));
 #else
 	return MOSQ_ERR_PROTOCOL;
 #endif
@@ -69,9 +69,9 @@ int handle__pingresp(struct mosquitto *mosq)
 	if(mosq->bridge == NULL){
 		return MOSQ_ERR_PROTOCOL;
 	}
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PINGRESP from %s", mosq->id);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PINGRESP from %s", SAFE_PRINT(mosq->id));
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PINGRESP", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PINGRESP", SAFE_PRINT(mosq->id));
 #endif
 	return MOSQ_ERR_SUCCESS;
 }

lib/handle_pubackcomp.c

@@ -119,20 +119,20 @@ int handle__pubackcomp(struct mosquitto *mosq, const char *type)
 	}
 
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received %s from %s (Mid: %d, RC:%d)", type, mosq->id, mid, reason_code);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received %s from %s (Mid: %d, RC:%d)", type, SAFE_PRINT(mosq->id), mid, reason_code);
 
 	/* Immediately free, we don't do anything with Reason String or User Property at the moment */
 	mosquitto_property_free_all(&properties);
 
 	rc = db__message_delete_outgoing(mosq, mid, mosq_ms_wait_for_pubcomp, qos);
 	if(rc == MOSQ_ERR_NOT_FOUND){
-		log__printf(mosq, MOSQ_LOG_WARNING, "Warning: Received %s from %s for an unknown packet identifier %d.", type, mosq->id, mid);
+		log__printf(mosq, MOSQ_LOG_WARNING, "Warning: Received %s from %s for an unknown packet identifier %d.", type, SAFE_PRINT(mosq->id), mid);
 		return MOSQ_ERR_SUCCESS;
 	}else{
 		return rc;
 	}
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received %s (Mid: %d, RC:%d)", mosq->id, type, mid, reason_code);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received %s (Mid: %d, RC:%d)", SAFE_PRINT(mosq->id), type, mid, reason_code);
 
 	rc = message__delete(mosq, mid, mosq_md_out, qos);
 	if(rc == MOSQ_ERR_SUCCESS){

lib/handle_publish.c

@@ -115,7 +115,7 @@ int handle__publish(struct mosquitto *mosq)
 	}
 	log__printf(mosq, MOSQ_LOG_DEBUG,
 			"Client %s received PUBLISH (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))",
-			mosq->id, message->dup, message->msg.qos, message->msg.retain,
+			SAFE_PRINT(mosq->id), message->dup, message->msg.qos, message->msg.retain,
 			message->msg.mid, message->msg.topic,
 			(long)message->msg.payloadlen);
 

lib/handle_pubrec.c

@@ -90,7 +90,7 @@ int handle__pubrec(struct mosquitto *mosq)
 	}
 
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PUBREC from %s (Mid: %d)", mosq->id, mid);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PUBREC from %s (Mid: %d)", SAFE_PRINT(mosq->id), mid);
 
 	if(reason_code < 0x80){
 		rc = db__message_update_outgoing(mosq, mid, mosq_ms_wait_for_pubcomp, 2);
@@ -99,7 +99,7 @@ int handle__pubrec(struct mosquitto *mosq)
 	}
 #else
 
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PUBREC (Mid: %d)", mosq->id, mid);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PUBREC (Mid: %d)", SAFE_PRINT(mosq->id), mid);
 
 	if(reason_code < 0x80 || mosq->protocol != mosq_p_mqtt5){
 		rc = message__out_update(mosq, mid, mosq_ms_wait_for_pubcomp, 2);
@@ -122,7 +122,7 @@ int handle__pubrec(struct mosquitto *mosq)
 	}
 #endif
 	if(rc == MOSQ_ERR_NOT_FOUND){
-		log__printf(mosq, MOSQ_LOG_WARNING, "Warning: Received PUBREC from %s for an unknown packet identifier %d.", mosq->id, mid);
+		log__printf(mosq, MOSQ_LOG_WARNING, "Warning: Received PUBREC from %s for an unknown packet identifier %d.", SAFE_PRINT(mosq->id), mid);
 	}else if(rc != MOSQ_ERR_SUCCESS){
 		return rc;
 	}

lib/handle_pubrel.c

@@ -88,7 +88,7 @@ int handle__pubrel(struct mosquitto *mosq)
 	}
 
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PUBREL from %s (Mid: %d)", mosq->id, mid);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received PUBREL from %s (Mid: %d)", SAFE_PRINT(mosq->id), mid);
 
 	/* Immediately free, we don't do anything with Reason String or User Property at the moment */
 	mosquitto_property_free_all(&properties);
@@ -104,7 +104,7 @@ int handle__pubrel(struct mosquitto *mosq)
 	rc = send__pubcomp(mosq, mid, NULL);
 	if(rc) return rc;
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PUBREL (Mid: %d)", mosq->id, mid);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PUBREL (Mid: %d)", SAFE_PRINT(mosq->id), mid);
 
 	rc = send__pubcomp(mosq, mid, NULL);
 	if(rc){

lib/handle_suback.c

@@ -59,9 +59,9 @@ int handle__suback(struct mosquitto *mosq)
 		/* Client is not a bridge, so shouldn't be sending SUBACK */
 		return MOSQ_ERR_PROTOCOL;
 	}
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received SUBACK from %s", mosq->id);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received SUBACK from %s", SAFE_PRINT(mosq->id));
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received SUBACK", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received SUBACK", SAFE_PRINT(mosq->id));
 #endif
 	rc = packet__read_uint16(&mosq->in_packet, &mid);
 	if(rc) return rc;

lib/handle_unsuback.c

@@ -59,9 +59,9 @@ int handle__unsuback(struct mosquitto *mosq)
 		/* Client is not a bridge, so shouldn't be sending SUBACK */
 		return MOSQ_ERR_PROTOCOL;
 	}
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Received UNSUBACK from %s", mosq->id);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Received UNSUBACK from %s", SAFE_PRINT(mosq->id));
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received UNSUBACK", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s received UNSUBACK", SAFE_PRINT(mosq->id));
 #endif
 	rc = packet__read_uint16(&mosq->in_packet, &mid);
 	if(rc) return rc;

lib/mosquitto_internal.h

@@ -72,6 +72,8 @@ typedef SOCKET mosq_sock_t;
 typedef int mosq_sock_t;
 #endif
 
+#define SAFE_PRINT(A) (A)?(A):"null"
+
 enum mosquitto_msg_direction {
 	mosq_md_in = 0,
 	mosq_md_out = 1

lib/send_connect.c

@@ -204,10 +204,10 @@ int send__connect(struct mosquitto *mosq, uint16_t keepalive, bool clean_session
 	mosq->keepalive = keepalive;
 #ifdef WITH_BROKER
 # ifdef WITH_BRIDGE
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending CONNECT", clientid);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending CONNECT", SAFE_PRINT(clientid));
 # endif
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending CONNECT", clientid);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending CONNECT", SAFE_PRINT(clientid));
 #endif
 	return packet__queue(mosq, packet);
 }

lib/send_disconnect.c

@@ -43,15 +43,15 @@ int send__disconnect(struct mosquitto *mosq, uint8_t reason_code, const mosquitt
 #ifdef WITH_BROKER
 #  ifdef WITH_BRIDGE
 	if(mosq->bridge){
-		log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending DISCONNECT", mosq->id);
+		log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending DISCONNECT", SAFE_PRINT(mosq->id));
 	}else
 #  else
 	{
-		log__printf(mosq, MOSQ_LOG_DEBUG, "Sending DISCONNECT to %s (rc%d)", mosq->id, reason_code);
+		log__printf(mosq, MOSQ_LOG_DEBUG, "Sending DISCONNECT to %s (rc%d)", SAFE_PRINT(mosq->id), reason_code);
 	}
 #  endif
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending DISCONNECT", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending DISCONNECT", SAFE_PRINT(mosq->id));
 #endif
 	assert(mosq);
 	packet = mosquitto__calloc(1, sizeof(struct mosquitto__packet));

lib/send_mosq.c

@@ -46,9 +46,9 @@ int send__pingreq(struct mosquitto *mosq)
 	int rc;
 	assert(mosq);
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PINGREQ to %s", mosq->id);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PINGREQ to %s", SAFE_PRINT(mosq->id));
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PINGREQ", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PINGREQ", SAFE_PRINT(mosq->id));
 #endif
 	rc = send__simple_command(mosq, CMD_PINGREQ);
 	if(rc == MOSQ_ERR_SUCCESS){
@@ -60,9 +60,9 @@ int send__pingreq(struct mosquitto *mosq)
 int send__pingresp(struct mosquitto *mosq)
 {
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PINGRESP to %s", mosq->id);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PINGRESP to %s", SAFE_PRINT(mosq->id));
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PINGRESP", mosq->id);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PINGRESP", SAFE_PRINT(mosq->id));
 #endif
 	return send__simple_command(mosq, CMD_PINGRESP);
 }
@@ -70,9 +70,9 @@ int send__pingresp(struct mosquitto *mosq)
 int send__puback(struct mosquitto *mosq, uint16_t mid, uint8_t reason_code, const mosquitto_property *properties)
 {
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBACK to %s (m%d, rc%d)", mosq->id, mid, reason_code);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBACK to %s (m%d, rc%d)", SAFE_PRINT(mosq->id), mid, reason_code);
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBACK (m%d, rc%d)", mosq->id, mid, reason_code);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBACK (m%d, rc%d)", SAFE_PRINT(mosq->id), mid, reason_code);
 #endif
 	util__increment_receive_quota(mosq);
 	/* We don't use Reason String or User Property yet. */
@@ -82,9 +82,9 @@ int send__puback(struct mosquitto *mosq, uint16_t mid, uint8_t reason_code, cons
 int send__pubcomp(struct mosquitto *mosq, uint16_t mid, const mosquitto_property *properties)
 {
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBCOMP to %s (m%d)", mosq->id, mid);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBCOMP to %s (m%d)", SAFE_PRINT(mosq->id), mid);
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBCOMP (m%d)", mosq->id, mid);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBCOMP (m%d)", SAFE_PRINT(mosq->id), mid);
 #endif
 	util__increment_receive_quota(mosq);
 	/* We don't use Reason String or User Property yet. */
@@ -95,9 +95,9 @@ int send__pubcomp(struct mosquitto *mosq, uint16_t mid, const mosquitto_property
 int send__pubrec(struct mosquitto *mosq, uint16_t mid, uint8_t reason_code, const mosquitto_property *properties)
 {
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBREC to %s (m%d, rc%d)", mosq->id, mid, reason_code);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBREC to %s (m%d, rc%d)", SAFE_PRINT(mosq->id), mid, reason_code);
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBREC (m%d, rc%d)", mosq->id, mid, reason_code);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBREC (m%d, rc%d)", SAFE_PRINT(mosq->id), mid, reason_code);
 #endif
 	if(reason_code >= 0x80 && mosq->protocol == mosq_p_mqtt5){
 		util__increment_receive_quota(mosq);
@@ -109,9 +109,9 @@ int send__pubrec(struct mosquitto *mosq, uint16_t mid, uint8_t reason_code, cons
 int send__pubrel(struct mosquitto *mosq, uint16_t mid, const mosquitto_property *properties)
 {
 #ifdef WITH_BROKER
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBREL to %s (m%d)", mosq->id, mid);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBREL to %s (m%d)", SAFE_PRINT(mosq->id), mid);
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBREL (m%d)", mosq->id, mid);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBREL (m%d)", SAFE_PRINT(mosq->id), mid);
 #endif
 	/* We don't use Reason String or User Property yet. */
 	return send__command_with_mid(mosq, CMD_PUBREL|2, mid, false, 0, properties);

lib/send_publish.c

@@ -114,7 +114,7 @@ int send__publish(struct mosquitto *mosq, uint16_t mid, const char *topic, uint3
 						mosquitto__free(mapped_topic);
 						mapped_topic = topic_temp;
 					}
-					log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBLISH to %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", mosq->id, dup, qos, retain, mid, mapped_topic, (long)payloadlen);
+					log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBLISH to %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", SAFE_PRINT(mosq->id), dup, qos, retain, mid, mapped_topic, (long)payloadlen);
 					G_PUB_BYTES_SENT_INC(payloadlen);
 					rc =  send__real_publish(mosq, mid, mapped_topic, payloadlen, payload, qos, retain, dup, cmsg_props, store_props, expiry_interval);
 					mosquitto__free(mapped_topic);
@@ -124,10 +124,10 @@ int send__publish(struct mosquitto *mosq, uint16_t mid, const char *topic, uint3
 		}
 	}
 #endif
-	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBLISH to %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", mosq->id, dup, qos, retain, mid, topic, (long)payloadlen);
+	log__printf(NULL, MOSQ_LOG_DEBUG, "Sending PUBLISH to %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", SAFE_PRINT(mosq->id), dup, qos, retain, mid, topic, (long)payloadlen);
 	G_PUB_BYTES_SENT_INC(payloadlen);
 #else
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBLISH (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", mosq->id, dup, qos, retain, mid, topic, (long)payloadlen);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending PUBLISH (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", SAFE_PRINT(mosq->id), dup, qos, retain, mid, topic, (long)payloadlen);
 #endif
 
 	return send__real_publish(mosq, mid, topic, payloadlen, payload, qos, retain, dup, cmsg_props, store_props, expiry_interval);
@@ -175,7 +175,7 @@ int send__real_publish(struct mosquitto *mosq, uint16_t mid, const char *topic,
 	}
 	if(packet__check_oversize(mosq, packetlen)){
 #ifdef WITH_BROKER
-		log__printf(NULL, MOSQ_LOG_NOTICE, "Dropping too large outgoing PUBLISH for %s (%d bytes)", mosq->id, packetlen);
+		log__printf(NULL, MOSQ_LOG_NOTICE, "Dropping too large outgoing PUBLISH for %s (%d bytes)", SAFE_PRINT(mosq->id), packetlen);
 #else
 		log__printf(NULL, MOSQ_LOG_NOTICE, "Dropping too large outgoing PUBLISH (%d bytes)", packetlen);
 #endif

lib/send_subscribe.c

@@ -89,11 +89,11 @@ int send__subscribe(struct mosquitto *mosq, int *mid, int topic_count, char *con
 
 #ifdef WITH_BROKER
 # ifdef WITH_BRIDGE
-	log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending SUBSCRIBE (Mid: %d, Topic: %s, QoS: %d, Options: 0x%02x)", mosq->id, local_mid, topic[0], topic_qos&0x03, topic_qos&0xFC);
+	log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending SUBSCRIBE (Mid: %d, Topic: %s, QoS: %d, Options: 0x%02x)", SAFE_PRINT(mosq->id), local_mid, topic[0], topic_qos&0x03, topic_qos&0xFC);
 # endif
 #else
 	for(i=0; i<topic_count; i++){
-		log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending SUBSCRIBE (Mid: %d, Topic: %s, QoS: %d, Options: 0x%02x)", mosq->id, local_mid, topic[i], topic_qos&0x03, topic_qos&0xFC);
+		log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending SUBSCRIBE (Mid: %d, Topic: %s, QoS: %d, Options: 0x%02x)", SAFE_PRINT(mosq->id), local_mid, topic[i], topic_qos&0x03, topic_qos&0xFC);
 	}
 #endif
 

lib/send_unsubscribe.c

@@ -89,12 +89,12 @@ int send__unsubscribe(struct mosquitto *mosq, int *mid, int topic_count, char *c
 #ifdef WITH_BROKER
 # ifdef WITH_BRIDGE
 	for(i=0; i<topic_count; i++){
-		log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending UNSUBSCRIBE (Mid: %d, Topic: %s)", mosq->id, local_mid, topic[i]);
+		log__printf(mosq, MOSQ_LOG_DEBUG, "Bridge %s sending UNSUBSCRIBE (Mid: %d, Topic: %s)", SAFE_PRINT(mosq->id), local_mid, topic[i]);
 	}
 # endif
 #else
 	for(i=0; i<topic_count; i++){
-		log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending UNSUBSCRIBE (Mid: %d, Topic: %s)", mosq->id, local_mid, topic[i]);
+		log__printf(mosq, MOSQ_LOG_DEBUG, "Client %s sending UNSUBSCRIBE (Mid: %d, Topic: %s)", SAFE_PRINT(mosq->id), local_mid, topic[i]);
 	}
 #endif
 	return packet__queue(mosq, packet);

lib/util_topic.c

@@ -189,19 +189,11 @@ int mosquitto_sub_topic_check2(const char *str, size_t len)
 	return MOSQ_ERR_SUCCESS;
 }
 
-int mosquitto_topic_matches_sub(const char *sub, const char *topic, bool *result)
-{
-	return mosquitto_topic_matches_sub2(sub, 0, topic, 0, result);
-}
-
 /* Does a topic match a subscription? */
-int mosquitto_topic_matches_sub2(const char *sub, size_t sublen, const char *topic, size_t topiclen, bool *result)
+int mosquitto_topic_matches_sub(const char *sub, const char *topic, bool *result)
 {
 	size_t spos;
 
-	UNUSED(sublen);
-	UNUSED(topiclen);
-
 	if(!result) return MOSQ_ERR_INVAL;
 	*result = false;
 
@@ -325,3 +317,130 @@ int mosquitto_topic_matches_sub2(const char *sub, size_t sublen, const char *top
 
 	return MOSQ_ERR_SUCCESS;
 }
+
+/* Does a topic match a subscription? */
+int mosquitto_topic_matches_sub2(const char *sub, size_t sublen, const char *topic, size_t topiclen, bool *result)
+{
+	size_t spos, tpos;
+
+	if(!result) return MOSQ_ERR_INVAL;
+	*result = false;
+
+	if(!sub || !topic || !sublen || !topiclen){
+		return MOSQ_ERR_INVAL;
+	}
+
+	if((sub[0] == '$' && topic[0] != '$')
+			|| (topic[0] == '$' && sub[0] != '$')){
+
+		return MOSQ_ERR_SUCCESS;
+	}
+
+	spos = 0;
+	tpos = 0;
+
+	while(spos < sublen){
+		if(tpos < topiclen && (topic[tpos] == '+' || topic[tpos] == '#')){
+			return MOSQ_ERR_INVAL;
+		}
+		if(tpos == topiclen || sub[spos] != topic[tpos]){
+			if(sub[spos] == '+'){
+				/* Check for bad "+foo" or "a/+foo" subscription */
+				if(spos > 0 && sub[spos-1] != '/'){
+					return MOSQ_ERR_INVAL;
+				}
+				/* Check for bad "foo+" or "foo+/a" subscription */
+				if(spos+1 < sublen && sub[spos+1] != '/'){
+					return MOSQ_ERR_INVAL;
+				}
+				spos++;
+				while(tpos < topiclen && topic[tpos] != '/'){
+					if(topic[tpos] == '+' || topic[tpos] == '#'){
+						return MOSQ_ERR_INVAL;
+					}
+					tpos++;
+				}
+				if(tpos == topiclen && spos == sublen){
+					*result = true;
+					return MOSQ_ERR_SUCCESS;
+				}
+			}else if(sub[spos] == '#'){
+				/* Check for bad "foo#" subscription */
+				if(spos > 0 && sub[spos-1] != '/'){
+					return MOSQ_ERR_INVAL;
+				}
+				/* Check for # not the final character of the sub, e.g. "#foo" */
+				if(spos+1 < sublen){
+					return MOSQ_ERR_INVAL;
+				}else{
+					while(tpos < topiclen){
+						if(topic[tpos] == '+' || topic[tpos] == '#'){
+							return MOSQ_ERR_INVAL;
+						}
+						tpos++;
+					}
+					*result = true;
+					return MOSQ_ERR_SUCCESS;
+				}
+			}else{
+				/* Check for e.g. foo/bar matching foo/+/# */
+				if(tpos == topiclen
+						&& spos > 0
+						&& sub[spos-1] == '+'
+						&& sub[spos] == '/'
+						&& spos+1 < sublen
+						&& sub[spos+1] == '#')
+				{
+					*result = true;
+					return MOSQ_ERR_SUCCESS;
+				}
+
+				/* There is no match at this point, but is the sub invalid? */
+				while(spos < sublen){
+					if(sub[spos] == '#' && spos+1 < sublen){
+						return MOSQ_ERR_INVAL;
+					}
+					spos++;
+				}
+
+				/* Valid input, but no match */
+				return MOSQ_ERR_SUCCESS;
+			}
+		}else{
+			/* sub[spos] == topic[tpos] */
+			if(tpos+1 == topiclen){
+				/* Check for e.g. foo matching foo/# */
+				if(spos+3 == sublen
+						&& sub[spos+1] == '/'
+						&& sub[spos+2] == '#'){
+					*result = true;
+					return MOSQ_ERR_SUCCESS;
+				}
+			}
+			spos++;
+			tpos++;
+			if(spos == sublen && tpos == topiclen){
+				*result = true;
+				return MOSQ_ERR_SUCCESS;
+			}else if(tpos == topiclen && sub[spos] == '+' && spos+1 == sublen){
+				if(spos > 0 && sub[spos-1] != '/'){
+					return MOSQ_ERR_INVAL;
+				}
+				spos++;
+				*result = true;
+				return MOSQ_ERR_SUCCESS;
+			}
+		}
+	}
+	if(tpos < topiclen || spos < sublen){
+		*result = false;
+	}
+	while(tpos < topiclen){
+		if(topic[tpos] == '+' || topic[tpos] == '#'){
+			return MOSQ_ERR_INVAL;
+		}
+		tpos++;
+	}
+
+	return MOSQ_ERR_SUCCESS;
+}

plugins/dynamic-security/CMakeLists.txt

@@ -35,7 +35,12 @@ if (CJSON_FOUND AND WITH_TLS)
 	target_link_libraries(mosquitto_dynamic_security ${CJSON_LIBRARIES} ${OPENSSL_LIBRARIES})
 	if(WIN32)
 		target_link_libraries(mosquitto_dynamic_security mosquitto)
-	endif(WIN32)
+		install(TARGETS mosquitto_dynamic_security
+			DESTINATION "${CMAKE_INSTALL_BINDIR}")
+	else()
+		install(TARGETS mosquitto_dynamic_security
+			RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+			LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+	endif()
 
-	install(TARGETS mosquitto_dynamic_security RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
 endif()

set-version.sh

@@ -2,7 +2,7 @@
 
 MAJOR=2
 MINOR=0
-REVISION=13
+REVISION=14
 
 sed -i "s/^VERSION=.*/VERSION=${MAJOR}.${MINOR}.${REVISION}/" config.mk
 

snap/snapcraft.yaml

@@ -1,5 +1,5 @@
 name: mosquitto
-version: 2.0.13
+version: 2.0.14
 summary: Eclipse Mosquitto MQTT broker
 description: This is a message broker that supports version 5.0, 3.1.1, and 3.1 of the MQTT
     protocol.

src/handle_connack.c

@@ -37,6 +37,7 @@ int handle__connack(struct mosquitto *context)
 	uint32_t maximum_packet_size;
 	uint8_t retain_available;
 	uint16_t server_keepalive;
+	uint16_t inflight_maximum;
 	uint8_t max_qos = 255;
 
 	if(context == NULL){
@@ -83,9 +84,12 @@ int handle__connack(struct mosquitto *context)
 		}
 
 		/* receive-maximum */
-		mosquitto_property_read_int16(properties, MQTT_PROP_RECEIVE_MAXIMUM,
-				&context->msgs_out.inflight_maximum, false);
-		context->msgs_out.inflight_quota = context->msgs_out.inflight_maximum;
+		inflight_maximum = context->msgs_out.inflight_maximum;
+		mosquitto_property_read_int16(properties, MQTT_PROP_RECEIVE_MAXIMUM, &inflight_maximum, false);
+		if(context->msgs_out.inflight_maximum != inflight_maximum){
+			context->msgs_out.inflight_maximum = inflight_maximum;
+			db__message_reconnect_reset(context);
+		}
 
 		/* retain-available */
 		if(mosquitto_property_read_byte(properties, MQTT_PROP_RETAIN_AVAILABLE,

test/unit/persist_read_stubs.c

@@ -197,3 +197,11 @@ void db__msg_add_to_queued_stats(struct mosquitto_msg_data *msg_data, struct mos
 	UNUSED(msg_data);
 	UNUSED(msg);
 }
+
+void context__add_to_by_id(struct mosquitto *context)
+{
+	if(context->in_by_id == false){
+		context->in_by_id = true;
+		HASH_ADD_KEYPTR(hh_id, db.contexts_by_id, context->id, strlen(context->id), context);
+	}
+}

test/unit/persist_write_stubs.c

@@ -113,3 +113,11 @@ int send__pubrel(struct mosquitto *mosq, uint16_t mid, const mosquitto_property
 
 	return MOSQ_ERR_SUCCESS;
 }
+
+void context__add_to_by_id(struct mosquitto *context)
+{
+	if(context->in_by_id == false){
+		context->in_by_id = true;
+		HASH_ADD_KEYPTR(hh_id, db.contexts_by_id, context->id, strlen(context->id), context);
+	}
+}

test/unit/util_topic_test.c

@@ -11,6 +11,16 @@ static void match_helper(const char *sub, const char *topic)
 	rc = mosquitto_topic_matches_sub(sub, topic, &match);
 	CU_ASSERT_EQUAL(rc, MOSQ_ERR_SUCCESS);
 	CU_ASSERT_EQUAL(match, true);
+	if(match == false){
+		printf("1: %s:%s\n", sub, topic);
+	}
+
+	rc = mosquitto_topic_matches_sub2(sub, strlen(sub), topic, strlen(topic), &match);
+	CU_ASSERT_EQUAL(rc, MOSQ_ERR_SUCCESS);
+	CU_ASSERT_EQUAL(match, true);
+	if(match == false){
+		printf("2: %s:%s\n", sub, topic);
+	}
 }
 
 static void no_match_helper(int rc_expected, const char *sub, const char *topic)
@@ -24,6 +34,13 @@ static void no_match_helper(int rc_expected, const char *sub, const char *topic)
 		printf("%d:%d %s:%s\n", rc, rc_expected, sub, topic);
 	}
 	CU_ASSERT_EQUAL(match, false);
+
+	rc = mosquitto_topic_matches_sub2(sub, strlen(sub), topic, strlen(topic), &match);
+	CU_ASSERT_EQUAL(rc, rc_expected);
+	if(rc != rc_expected){
+		printf("%d:%d %s:%s\n", rc, rc_expected, sub, topic);
+	}
+	CU_ASSERT_EQUAL(match, false);
 }
 
 /* ========================================================================

www/pages/download.md

@@ -11,7 +11,7 @@
 
 # Source
 
-* [mosquitto-2.0.13.tar.gz](https://mosquitto.org/files/source/mosquitto-2.0.13.tar.gz) ([GPG signature](https://mosquitto.org/files/source/mosquitto-2.0.13.tar.gz.asc))
+* [mosquitto-2.0.14.tar.gz](https://mosquitto.org/files/source/mosquitto-2.0.14.tar.gz) ([GPG signature](https://mosquitto.org/files/source/mosquitto-2.0.14.tar.gz.asc))
 * [Git source code repository](https://github.com/eclipse/mosquitto) (github.com)
 
 Older downloads are available at [https://mosquitto.org/files/](../files/)
@@ -24,8 +24,8 @@ distributions.
 
 ## Windows
 
-* [mosquitto-2.0.13-install-windows-x64.exe](https://mosquitto.org/files/binary/win64/mosquitto-2.0.13-install-windows-x64.exe) (64-bit build, Windows Vista and up, built with Visual Studio Community 2019)
-* [mosquitto-2.0.13-install-windows-x32.exe](https://mosquitto.org/files/binary/win32/mosquitto-2.0.13-install-windows-x86.exe) (32-bit build, Windows Vista and up, built with Visual Studio Community 2019)
+* [mosquitto-2.0.14-install-windows-x64.exe](https://mosquitto.org/files/binary/win64/mosquitto-2.0.14-install-windows-x64.exe) (64-bit build, Windows Vista and up, built with Visual Studio Community 2019)
+* [mosquitto-2.0.14-install-windows-x32.exe](https://mosquitto.org/files/binary/win32/mosquitto-2.0.14-install-windows-x86.exe) (32-bit build, Windows Vista and up, built with Visual Studio Community 2019)
 
 Older installers can be found at [https://mosquitto.org/files/binary/](https://mosquitto.org/files/binary/).
 

www/posts/2021/11/version-2-0-14-released.md

@@ -0,0 +1,23 @@
+<!--
+.. title: Version 2.0.14 released.
+.. slug: version-2-0-14-released
+.. date: 2021-11-17 00:25:38 UTC
+.. tags: Releases
+.. category:
+.. link:
+.. description:
+.. type: text
+-->
+
+Versions 2.0.14 of Mosquitto has been released. This is a bugfix release.
+
+# Broker
+- Fix bridge not respecting receive-maximum when reconnecting with MQTT v5.
+
+# Client library
+- Fix `mosquitto_topic_matches_sub2()` not using the length parameters.
+  Closes [#2364].
+- Fix incorrect `subscribe_callback` in mosquittopp.h. Closes [#2367].
+
+[#2364]: https://github.com/eclipse/mosquitto/issues/2364
+[#2367]: https://github.com/eclipse/mosquitto/issues/2367