diff --git a/apps/db_dump/CMakeLists.txt b/apps/db_dump/CMakeLists.txt index bb8cc5c0..8d6e3143 100644 --- a/apps/db_dump/CMakeLists.txt +++ b/apps/db_dump/CMakeLists.txt @@ -3,11 +3,9 @@ add_executable(mosquitto_db_dump print.c stubs.c - ../../lib/memory_mosq.c ../../lib/packet_datatypes.c ../../lib/property_mosq.c - ../../src/memory_public.c ../../src/persist_read.c ../../src/persist_read_v234.c ../../src/persist_read_v5.c diff --git a/apps/db_dump/Makefile b/apps/db_dump/Makefile index 54e72087..80451472 100644 --- a/apps/db_dump/Makefile +++ b/apps/db_dump/Makefile @@ -21,8 +21,6 @@ OBJS = \ stubs.o BROKER_OBJS = \ - ${R}/src/memory_mosq.o \ - ${R}/src/memory_public.o \ ${R}/src/packet_datatypes.o \ ${R}/src/persist_read.o \ ${R}/src/persist_read_v234.o \ diff --git a/apps/db_dump/db_dump.c b/apps/db_dump/db_dump.c index a76431b3..3ee903cd 100644 --- a/apps/db_dump/db_dump.c +++ b/apps/db_dump/db_dump.c @@ -28,11 +28,10 @@ Contributors: #include "db_dump.h" #include -#include #include -#define mosquitto__malloc(A) malloc((A)) -#define mosquitto__free(A) free((A)) +#define mosquitto_malloc(A) malloc((A)) +#define mosquitto_free(A) free((A)) #define _mosquitto_malloc(A) malloc((A)) #define _mosquitto_free(A) free((A)) #include @@ -252,13 +251,13 @@ static int dump__base_msg_chunk_process(FILE *db_fptr, uint32_t length) message_expiry_interval = 0; } - stored = mosquitto__calloc(1, sizeof(struct mosquitto__base_msg)); + stored = mosquitto_calloc(1, sizeof(struct mosquitto__base_msg)); if(stored == NULL){ fprintf(stderr, "Error: Out of memory.\n"); - mosquitto__free(chunk.source.id); - mosquitto__free(chunk.source.username); - mosquitto__free(chunk.topic); - mosquitto__free(chunk.payload); + mosquitto_free(chunk.source.id); + mosquitto_free(chunk.source.username); + mosquitto_free(chunk.topic); + mosquitto_free(chunk.payload); return MOSQ_ERR_NOMEM; } stored->data.store_id = chunk.F.store_id; @@ -273,8 +272,8 @@ static int dump__base_msg_chunk_process(FILE *db_fptr, uint32_t length) rc = db__message_store(&chunk.source, stored, &message_expiry_interval, mosq_mo_client); - mosquitto__free(chunk.source.id); - mosquitto__free(chunk.source.username); + mosquitto_free(chunk.source.id); + mosquitto_free(chunk.source.username); chunk.source.id = NULL; chunk.source.username = NULL; diff --git a/apps/db_dump/print.c b/apps/db_dump/print.c index 5aed249f..ea33bac4 100644 --- a/apps/db_dump/print.c +++ b/apps/db_dump/print.c @@ -21,7 +21,6 @@ Contributors: #include "db_dump.h" #include -#include #include #include #include diff --git a/apps/mosquitto_ctrl/CMakeLists.txt b/apps/mosquitto_ctrl/CMakeLists.txt index 4ad39178..c83fd1e5 100644 --- a/apps/mosquitto_ctrl/CMakeLists.txt +++ b/apps/mosquitto_ctrl/CMakeLists.txt @@ -9,9 +9,7 @@ if(WITH_TLS AND CJSON_FOUND) dynsec_group.c dynsec_role.c ../mosquitto_passwd/get_password.c ../mosquitto_passwd/get_password.h - ../../lib/memory_mosq.c ../../lib/memory_mosq.h ../../common/misc_mosq.c ../../common/misc_mosq.h - ../../src/memory_public.c options.c ../../common/json_help.c ../../common/json_help.h ../../common/password_mosq.c ../../common/password_mosq.h diff --git a/apps/mosquitto_ctrl/Makefile b/apps/mosquitto_ctrl/Makefile index b282479c..3192bdcf 100644 --- a/apps/mosquitto_ctrl/Makefile +++ b/apps/mosquitto_ctrl/Makefile @@ -36,8 +36,6 @@ OBJS_EXTERNAL= \ base64_mosq.o \ get_password.o \ json_help.o \ - memory_mosq.o \ - memory_public.o \ password_mosq.o EXAMPLE_OBJS= example.o @@ -71,12 +69,6 @@ get_password.o : ${R}/apps/mosquitto_passwd/get_password.c ${R}/apps/mosquitto_p json_help.o : ${R}/common/json_help.c ${R}/common/json_help.h ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ -memory_mosq.o : ${R}/lib/memory_mosq.c - ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ - -memory_public.o : ${R}/src/memory_public.c - ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ - password_mosq.o : ${R}/common/password_mosq.c ${R}/common/password_mosq.h ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ diff --git a/apps/mosquitto_passwd/CMakeLists.txt b/apps/mosquitto_passwd/CMakeLists.txt index b9235137..85a2d215 100644 --- a/apps/mosquitto_passwd/CMakeLists.txt +++ b/apps/mosquitto_passwd/CMakeLists.txt @@ -3,8 +3,6 @@ if(WITH_TLS) mosquitto_passwd.c get_password.c get_password.h ../../common/base64_mosq.c ../../common/base64_mosq.h - ../../lib/memory_mosq.c ../../lib/memory_mosq.h - ../../src/memory_public.c ../../common/misc_mosq.c ../../common/misc_mosq.h ../../common/password_mosq.c ../../common/password_mosq.h ) @@ -27,6 +25,7 @@ if(WITH_TLS) target_link_libraries(mosquitto_passwd PRIVATE common-options + libmosquitto_common OpenSSL::SSL ) diff --git a/apps/mosquitto_passwd/Makefile b/apps/mosquitto_passwd/Makefile index f2daec1c..f9c78f70 100644 --- a/apps/mosquitto_passwd/Makefile +++ b/apps/mosquitto_passwd/Makefile @@ -14,8 +14,6 @@ OBJS= \ OBJS_EXTERNAL= \ base64_mosq.o \ - memory_mosq.o \ - memory_public.o \ misc_mosq.o \ password_mosq.o @@ -42,12 +40,6 @@ ${OBJS} : %.o: %.c base64_mosq.o : ${R}/common/base64_mosq.c ${R}/common/base64_mosq.h ${CROSS_COMPILE}${CC} ${LOCAL_CPPFLAGS} $(LOCAL_CFLAGS) -c $< -o $@ -memory_mosq.o : ${R}/lib/memory_mosq.c - ${CROSS_COMPILE}${CC} ${LOCAL_CPPFLAGS} $(LOCAL_CFLAGS) -c $< -o $@ - -memory_public.o : ${R}/src/memory_public.c - ${CROSS_COMPILE}${CC} ${LOCAL_CPPFLAGS} $(LOCAL_CFLAGS) -c $< -o $@ - misc_mosq.o : ${R}/common/misc_mosq.c ${R}/common/misc_mosq.h ${CROSS_COMPILE}${CC} ${LOCAL_CPPFLAGS} $(LOCAL_CFLAGS) -c $< -o $@ diff --git a/apps/mosquitto_passwd/mosquitto_passwd.c b/apps/mosquitto_passwd/mosquitto_passwd.c index 9c4e532e..533acad7 100644 --- a/apps/mosquitto_passwd/mosquitto_passwd.c +++ b/apps/mosquitto_passwd/mosquitto_passwd.c @@ -27,9 +27,9 @@ Contributors: #include #include +#include "mosquitto.h" #include "get_password.h" #include "base64_mosq.h" -#include "memory_mosq.h" #include "password_mosq.h" #ifdef WIN32 @@ -152,7 +152,7 @@ static int output_new_password(FILE *fptr, const char *username, const char *pas } fprintf(fptr, "%s:%s\n", username, pw.encoded_password); - mosquitto__free(pw.encoded_password); + mosquitto_FREE(pw.encoded_password); return rc; } diff --git a/common/base64_mosq.c b/common/base64_mosq.c index d0fb37d9..0154251b 100644 --- a/common/base64_mosq.c +++ b/common/base64_mosq.c @@ -32,7 +32,6 @@ Contributors: #include "mosquitto.h" #include "base64_mosq.h" -#include "memory_mosq.h" #ifdef WITH_TLS int base64__encode(const unsigned char *in, size_t in_len, char **encoded) @@ -93,7 +92,8 @@ int base64__decode(const char *in, unsigned char **decoded, unsigned int *decode *decoded_len = (unsigned int)len; rc = 0; }else{ - SAFE_FREE(*decoded); + free(*decoded); + *decoded = NULL; } } } diff --git a/common/password_mosq.c b/common/password_mosq.c index 2092b933..f8af57f7 100644 --- a/common/password_mosq.c +++ b/common/password_mosq.c @@ -27,7 +27,6 @@ Contributors: #include "mosquitto.h" #include "base64_mosq.h" -#include "memory_mosq.h" #include "password_mosq.h" #ifdef WIN32 diff --git a/include/mosquitto/broker.h b/include/mosquitto/broker.h index ec751da2..672db3ef 100644 --- a/include/mosquitto/broker.h +++ b/include/mosquitto/broker.h @@ -536,45 +536,6 @@ mosq_EXPORT int mosquitto_callback_unregister( const void *event_data); -/* ========================================================================= - * - * Section: Memory allocation. - * - * Use these functions when allocating or freeing memory to have your memory - * included in the memory tracking on the broker. - * - * ========================================================================= */ - -/* - * Function: mosquitto_calloc - */ -mosq_EXPORT void *mosquitto_calloc(size_t nmemb, size_t size); - -/* - * Function: mosquitto_free - */ -mosq_EXPORT void mosquitto_free(void *mem); - -/* - * Function: mosquitto_malloc - */ -mosq_EXPORT void *mosquitto_malloc(size_t size); - -/* - * Function: mosquitto_realloc - */ -mosq_EXPORT void *mosquitto_realloc(void *ptr, size_t size); - -/* - * Function: mosquitto_strdup - */ -mosq_EXPORT char *mosquitto_strdup(const char *s); - -/* - * Function: mosquitto_strndup - */ -mosq_EXPORT char *mosquitto_strndup(const char *s, size_t n); - /* ========================================================================= * * Section: Utility Functions diff --git a/include/mosquitto/libcommon.h b/include/mosquitto/libcommon.h index 5f8d7701..13905fbc 100644 --- a/include/mosquitto/libcommon.h +++ b/include/mosquitto/libcommon.h @@ -26,8 +26,10 @@ Contributors: extern "C" { #endif +#include #include #include +#include #include #include diff --git a/include/mosquitto/libcommon_memory.h b/include/mosquitto/libcommon_memory.h new file mode 100644 index 00000000..990adae6 --- /dev/null +++ b/include/mosquitto/libcommon_memory.h @@ -0,0 +1,84 @@ +/* +Copyright (c) 2010-2021 Roger Light + +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_MEMORY_H +#define MOSQUITTO_LIBCOMMON_MEMORY_H + +/* + * File: mosquitto/libcommon_memory.h + * + * This header contains functions and definitions for allocating and freeing + * memory in broker plugins + */ +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(WIN32) && defined(mosquitto_EXPORTS) +# define mosq_EXPORT __declspec(dllexport) +#else +# define mosq_EXPORT +#endif + +/* ========================================================================= + * + * Section: Memory allocation. + * + * Use these functions when allocating or freeing memory to have your memory + * included in the memory tracking on the broker. + * + * ========================================================================= */ + +/* + * Function: mosquitto_calloc + */ +mosq_EXPORT void *mosquitto_calloc(size_t nmemb, size_t size); + +/* + * Function: mosquitto_free + */ +mosq_EXPORT void mosquitto_free(void *mem); + +/* + * Function: mosquitto_malloc + */ +mosq_EXPORT void *mosquitto_malloc(size_t size); + +/* + * Function: mosquitto_realloc + */ +mosq_EXPORT void *mosquitto_realloc(void *ptr, size_t size); + +/* + * Function: mosquitto_strdup + */ +mosq_EXPORT char *mosquitto_strdup(const char *s); + +/* + * Function: mosquitto_strndup + */ +mosq_EXPORT char *mosquitto_strndup(const char *s, size_t n); + +void mosquitto_memory_set_limit(size_t lim); + +#define mosquitto_FREE(A) do { mosquitto_free(A); (A) = NULL;} while(0) + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index f116428f..2216a166 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -24,7 +24,6 @@ set(C_SRC http_client.c http_client.h logging_mosq.c logging_mosq.h loop.c - memory_mosq.c memory_mosq.h messages_mosq.c messages_mosq.h ../common/misc_mosq.c ../common/misc_mosq.h mosquitto.c ../include/mosquitto.h diff --git a/lib/Makefile b/lib/Makefile index 66c05ca2..36fc6bd0 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -60,7 +60,6 @@ OBJS= \ http_client.o \ logging_mosq.o \ loop.o \ - memory_mosq.o \ messages_mosq.o \ net_mosq_ocsp.o \ net_mosq.o \ diff --git a/lib/actions_publish.c b/lib/actions_publish.c index 1bae132f..08c5f1c2 100644 --- a/lib/actions_publish.c +++ b/lib/actions_publish.c @@ -21,7 +21,6 @@ Contributors: #include #include -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto_internal.h" #include "mosquitto/mqtt_protocol.h" @@ -120,7 +119,7 @@ int mosquitto_publish_v5(struct mosquitto *mosq, int *mid, const char *topic, in rc = mosquitto_property_copy_all(&properties_copy, outgoing_properties); if(rc) return rc; } - message = mosquitto__calloc(1, sizeof(struct mosquitto_message_all)); + message = mosquitto_calloc(1, sizeof(struct mosquitto_message_all)); if(!message){ mosquitto_property_free_all(&properties_copy); return MOSQ_ERR_NOMEM; @@ -129,7 +128,7 @@ int mosquitto_publish_v5(struct mosquitto *mosq, int *mid, const char *topic, in message->next = NULL; message->msg.mid = local_mid; if(topic){ - message->msg.topic = mosquitto__strdup(topic); + message->msg.topic = mosquitto_strdup(topic); if(!message->msg.topic){ message__cleanup(&message); mosquitto_property_free_all(&properties_copy); @@ -138,7 +137,7 @@ int mosquitto_publish_v5(struct mosquitto *mosq, int *mid, const char *topic, in } if(payloadlen){ message->msg.payloadlen = payloadlen; - message->msg.payload = mosquitto__malloc((unsigned int)payloadlen*sizeof(uint8_t)); + message->msg.payload = mosquitto_malloc((unsigned int)payloadlen*sizeof(uint8_t)); if(!message->msg.payload){ message__cleanup(&message); mosquitto_property_free_all(&properties_copy); diff --git a/lib/alias_mosq.c b/lib/alias_mosq.c index 066e52f6..2e598480 100644 --- a/lib/alias_mosq.c +++ b/lib/alias_mosq.c @@ -22,7 +22,6 @@ Contributors: #include "mosquitto.h" #include "alias_mosq.h" -#include "memory_mosq.h" static void alias__free_r2l(struct mosquitto *mosq); static void alias__free_l2r(struct mosquitto *mosq); @@ -33,7 +32,7 @@ int alias__add_l2r(struct mosquitto *mosq, const char *topic, uint16_t *alias) struct mosquitto__alias *aliases_new; if(mosq->alias_count_l2r < mosq->alias_max_l2r){ - aliases_new = mosquitto__realloc(mosq->aliases_l2r, sizeof(struct mosquitto__alias)*(size_t)(mosq->alias_count_l2r+1)); + aliases_new = mosquitto_realloc(mosq->aliases_l2r, sizeof(struct mosquitto__alias)*(size_t)(mosq->alias_count_l2r+1)); if(!aliases_new) return MOSQ_ERR_NOMEM; mosq->aliases_l2r = aliases_new; @@ -41,7 +40,7 @@ int alias__add_l2r(struct mosquitto *mosq, const char *topic, uint16_t *alias) *alias = mosq->alias_count_l2r; mosq->aliases_l2r[mosq->alias_count_l2r-1].alias = *alias; - mosq->aliases_l2r[mosq->alias_count_l2r-1].topic = mosquitto__strdup(topic); + mosq->aliases_l2r[mosq->alias_count_l2r-1].topic = mosquitto_strdup(topic); if(!mosq->aliases_l2r[mosq->alias_count_l2r-1].topic){ *alias = 0; return MOSQ_ERR_NOMEM; @@ -61,8 +60,8 @@ int alias__add_r2l(struct mosquitto *mosq, const char *topic, uint16_t alias) for(i=0; ialias_count_r2l; i++){ if(mosq->aliases_r2l[i].alias == alias){ - mosquitto__FREE(mosq->aliases_r2l[i].topic); - mosq->aliases_r2l[i].topic = mosquitto__strdup(topic); + mosquitto_FREE(mosq->aliases_r2l[i].topic); + mosq->aliases_r2l[i].topic = mosquitto_strdup(topic); if(mosq->aliases_r2l[i].topic){ return MOSQ_ERR_SUCCESS; }else{ @@ -72,14 +71,14 @@ int alias__add_r2l(struct mosquitto *mosq, const char *topic, uint16_t alias) } /* New alias */ - aliases_new = mosquitto__realloc(mosq->aliases_r2l, sizeof(struct mosquitto__alias)*(size_t)(mosq->alias_count_r2l+1)); + aliases_new = mosquitto_realloc(mosq->aliases_r2l, sizeof(struct mosquitto__alias)*(size_t)(mosq->alias_count_r2l+1)); if(!aliases_new) return MOSQ_ERR_NOMEM; mosq->aliases_r2l = aliases_new; mosq->alias_count_r2l++; mosq->aliases_r2l[mosq->alias_count_r2l-1].alias = alias; - mosq->aliases_r2l[mosq->alias_count_r2l-1].topic = mosquitto__strdup(topic); + mosq->aliases_r2l[mosq->alias_count_r2l-1].topic = mosquitto_strdup(topic); if(!mosq->aliases_r2l[mosq->alias_count_r2l-1].topic){ return MOSQ_ERR_NOMEM; } @@ -104,7 +103,7 @@ int alias__find_by_alias(struct mosquitto *mosq, int direction, uint16_t alias, for(i=0; ialias_count_r2l; i++){ - mosquitto__FREE(mosq->aliases_r2l[i].topic); + mosquitto_FREE(mosq->aliases_r2l[i].topic); } - mosquitto__FREE(mosq->aliases_r2l); + mosquitto_FREE(mosq->aliases_r2l); mosq->alias_count_r2l = 0; } @@ -157,9 +156,9 @@ static void alias__free_l2r(struct mosquitto *mosq) int i; for(i=0; ialias_count_l2r; i++){ - mosquitto__FREE(mosq->aliases_l2r[i].topic); + mosquitto_FREE(mosq->aliases_l2r[i].topic); } - mosquitto__FREE(mosq->aliases_l2r); + mosquitto_FREE(mosq->aliases_l2r); mosq->alias_count_l2r = 0; } diff --git a/lib/connect.c b/lib/connect.c index 77166dca..cc509e86 100644 --- a/lib/connect.c +++ b/lib/connect.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto_internal.h" #include "logging_mosq.h" #include "messages_mosq.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "net_mosq.h" #include "send_mosq.h" @@ -50,7 +49,7 @@ static int mosquitto__connect_init(struct mosquitto *mosq, const char *host, int /* Only MQTT v3.1 requires a client id to be sent */ if(mosq->id == NULL && (mosq->protocol == mosq_p_mqtt31)){ - mosq->id = (char *)mosquitto__calloc(24, sizeof(char)); + mosq->id = (char *)mosquitto_calloc(24, sizeof(char)); if(!mosq->id){ return MOSQ_ERR_NOMEM; } @@ -68,8 +67,8 @@ static int mosquitto__connect_init(struct mosquitto *mosq, const char *host, int } } - mosquitto__FREE(mosq->host); - mosq->host = mosquitto__strdup(host); + mosquitto_FREE(mosq->host); + mosq->host = mosquitto_strdup(host); if(!mosq->host) return MOSQ_ERR_NOMEM; mosq->port = (uint16_t)port; diff --git a/lib/handle_connack.c b/lib/handle_connack.c index 58847f47..1a3841f8 100644 --- a/lib/handle_connack.c +++ b/lib/handle_connack.c @@ -22,7 +22,6 @@ Contributors: #include "callbacks.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" diff --git a/lib/handle_disconnect.c b/lib/handle_disconnect.c index fc09b36c..56e2a00a 100644 --- a/lib/handle_disconnect.c +++ b/lib/handle_disconnect.c @@ -23,7 +23,6 @@ Contributors: #include "logging_mosq.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "net_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" diff --git a/lib/handle_ping.c b/lib/handle_ping.c index 27b7892d..97c4f23c 100644 --- a/lib/handle_ping.c +++ b/lib/handle_ping.c @@ -28,7 +28,6 @@ Contributors: #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" diff --git a/lib/handle_pubackcomp.c b/lib/handle_pubackcomp.c index 315a3b5d..54e7f75d 100644 --- a/lib/handle_pubackcomp.c +++ b/lib/handle_pubackcomp.c @@ -29,7 +29,6 @@ Contributors: #include "callbacks.h" #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" diff --git a/lib/handle_publish.c b/lib/handle_publish.c index 28fcef2e..27097cd7 100644 --- a/lib/handle_publish.c +++ b/lib/handle_publish.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_internal.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "messages_mosq.h" #include "packet_mosq.h" @@ -52,7 +51,7 @@ int handle__publish(struct mosquitto *mosq) return MOSQ_ERR_PROTOCOL; } - message = mosquitto__calloc(1, sizeof(struct mosquitto_message_all)); + message = mosquitto_calloc(1, sizeof(struct mosquitto_message_all)); if(!message) return MOSQ_ERR_NOMEM; header = mosq->in_packet.command; @@ -110,7 +109,7 @@ int handle__publish(struct mosquitto *mosq) } }else{ /* Retrieve an existing topic alias */ - mosquitto__FREE(message->msg.topic); + mosquitto_FREE(message->msg.topic); if(alias__find_by_alias(mosq, ALIAS_DIR_R2L, topic_alias, &message->msg.topic)){ message__cleanup(&message); mosquitto_property_free_all(&properties); @@ -128,7 +127,7 @@ int handle__publish(struct mosquitto *mosq) message->msg.payloadlen = (int)(mosq->in_packet.remaining_length - mosq->in_packet.pos); if(message->msg.payloadlen){ - message->msg.payload = mosquitto__calloc((size_t)message->msg.payloadlen+1, sizeof(uint8_t)); + message->msg.payload = mosquitto_calloc((size_t)message->msg.payloadlen+1, sizeof(uint8_t)); if(!message->msg.payload){ message__cleanup(&message); mosquitto_property_free_all(&properties); diff --git a/lib/handle_pubrec.c b/lib/handle_pubrec.c index 9c8b496a..605ae2f2 100644 --- a/lib/handle_pubrec.c +++ b/lib/handle_pubrec.c @@ -29,7 +29,6 @@ Contributors: #include "callbacks.h" #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" diff --git a/lib/handle_pubrel.c b/lib/handle_pubrel.c index 0eb61a1c..c2e99278 100644 --- a/lib/handle_pubrel.c +++ b/lib/handle_pubrel.c @@ -29,7 +29,6 @@ Contributors: #include "callbacks.h" #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" diff --git a/lib/handle_suback.c b/lib/handle_suback.c index f61247cf..a16bdccc 100644 --- a/lib/handle_suback.c +++ b/lib/handle_suback.c @@ -28,7 +28,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_internal.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -74,7 +73,7 @@ int handle__suback(struct mosquitto *mosq) } qos_count = (int)(mosq->in_packet.remaining_length - mosq->in_packet.pos); - granted_qos = mosquitto__malloc((size_t)qos_count*sizeof(int)); + granted_qos = mosquitto_malloc((size_t)qos_count*sizeof(int)); if(!granted_qos){ mosquitto_property_free_all(&properties); return MOSQ_ERR_NOMEM; @@ -82,7 +81,7 @@ int handle__suback(struct mosquitto *mosq) while(mosq->in_packet.pos < mosq->in_packet.remaining_length){ rc = packet__read_byte(&mosq->in_packet, &qos); if(rc){ - mosquitto__FREE(granted_qos); + mosquitto_FREE(granted_qos); mosquitto_property_free_all(&properties); return rc; } @@ -96,7 +95,7 @@ int handle__suback(struct mosquitto *mosq) callback__on_subscribe(mosq, mid, qos_count, granted_qos, properties); mosquitto_property_free_all(&properties); #endif - mosquitto__FREE(granted_qos); + mosquitto_FREE(granted_qos); return MOSQ_ERR_SUCCESS; } diff --git a/lib/handle_unsuback.c b/lib/handle_unsuback.c index 7f0b0482..2c7ed763 100644 --- a/lib/handle_unsuback.c +++ b/lib/handle_unsuback.c @@ -29,7 +29,6 @@ Contributors: #include "callbacks.h" #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" @@ -76,7 +75,7 @@ int handle__unsuback(struct mosquitto *mosq) uint8_t byte; reason_code_count = (int)(mosq->in_packet.remaining_length - mosq->in_packet.pos); - reason_codes = mosquitto__malloc((size_t)reason_code_count*sizeof(int)); + reason_codes = mosquitto_malloc((size_t)reason_code_count*sizeof(int)); if(!reason_codes){ mosquitto_property_free_all(&properties); return MOSQ_ERR_NOMEM; @@ -84,7 +83,7 @@ int handle__unsuback(struct mosquitto *mosq) for(int i=0; iin_packet, &byte); if(rc){ - mosquitto__FREE(reason_codes); + mosquitto_FREE(reason_codes); mosquitto_property_free_all(&properties); return rc; } @@ -96,7 +95,7 @@ int handle__unsuback(struct mosquitto *mosq) callback__on_unsubscribe(mosq, mid, reason_code_count, reason_codes, properties); #endif mosquitto_property_free_all(&properties); - mosquitto__FREE(reason_codes); + mosquitto_FREE(reason_codes); return MOSQ_ERR_SUCCESS; } diff --git a/lib/helpers.c b/lib/helpers.c index 0584a8a1..a90e5de5 100644 --- a/lib/helpers.c +++ b/lib/helpers.c @@ -23,7 +23,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_internal.h" -#include "memory_mosq.h" struct userdata__callback { const char *topic; diff --git a/lib/http_client.c b/lib/http_client.c index bcd6cc3c..424e7b85 100644 --- a/lib/http_client.c +++ b/lib/http_client.c @@ -27,7 +27,6 @@ Contributors: #include "mosquitto_internal.h" #include "base64_mosq.h" #include "http_client.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" #include "packet_mosq.h" @@ -52,7 +51,7 @@ int http_c__context_init(struct mosquitto *context) const char *path; context->transport = mosq_t_http; - context->http_request = mosquitto__calloc(1, (size_t)context->wsd.http_header_size + 1); + context->http_request = mosquitto_calloc(1, (size_t)context->wsd.http_header_size + 1); if(context->http_request == NULL){ return MOSQ_ERR_NOMEM; } @@ -64,7 +63,7 @@ int http_c__context_init(struct mosquitto *context) return MOSQ_ERR_UNKNOWN; } - packet = mosquitto__calloc(1, sizeof(struct mosquitto__packet) + 1024 + WS_PACKET_OFFSET); + packet = mosquitto_calloc(1, sizeof(struct mosquitto__packet) + 1024 + WS_PACKET_OFFSET); if(!packet) return MOSQ_ERR_NOMEM; path = context->wsd.http_path?context->wsd.http_path:"/mqtt"; @@ -89,7 +88,7 @@ int http_c__context_init(struct mosquitto *context) int http_c__context_cleanup(struct mosquitto *context) { SAFE_FREE(context->wsd.accept_key); - mosquitto__FREE(context->http_request); + mosquitto_FREE(context->http_request); return MOSQ_ERR_SUCCESS; } @@ -164,7 +163,7 @@ int http_c__read(struct mosquitto *mosq) } if(http_status != 101){ - mosquitto__FREE(mosq->http_request); + mosquitto_FREE(mosq->http_request); /* FIXME Not supported - send 501 response */ return MOSQ_ERR_UNKNOWN; } diff --git a/lib/logging_mosq.c b/lib/logging_mosq.c index 73bbdc26..14d2b17c 100644 --- a/lib/logging_mosq.c +++ b/lib/logging_mosq.c @@ -26,7 +26,6 @@ Contributors: #include "logging_mosq.h" #include "mosquitto_internal.h" #include "mosquitto.h" -#include "memory_mosq.h" int log__printf(struct mosquitto *mosq, unsigned int priority, const char *fmt, ...) { @@ -40,7 +39,7 @@ int log__printf(struct mosquitto *mosq, unsigned int priority, const char *fmt, pthread_mutex_lock(&mosq->log_callback_mutex); if(mosq->on_log){ len = strlen(fmt) + 500; - s = mosquitto__malloc(len*sizeof(char)); + s = mosquitto_malloc(len*sizeof(char)); if(!s){ pthread_mutex_unlock(&mosq->log_callback_mutex); return MOSQ_ERR_NOMEM; @@ -53,7 +52,7 @@ int log__printf(struct mosquitto *mosq, unsigned int priority, const char *fmt, mosq->on_log(mosq, mosq->userdata, (int)priority, s); - mosquitto__FREE(s); + mosquitto_FREE(s); } pthread_mutex_unlock(&mosq->log_callback_mutex); diff --git a/lib/messages_mosq.c b/lib/messages_mosq.c index 82b5f416..980226d9 100644 --- a/lib/messages_mosq.c +++ b/lib/messages_mosq.c @@ -25,7 +25,6 @@ Contributors: #include "mosquitto_internal.h" #include "mosquitto.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "send_mosq.h" #include "util_mosq.h" @@ -38,10 +37,10 @@ void message__cleanup(struct mosquitto_message_all **message) msg = *message; - mosquitto__FREE(msg->msg.topic); - mosquitto__FREE(msg->msg.payload); + mosquitto_FREE(msg->msg.topic); + mosquitto_FREE(msg->msg.payload); mosquitto_property_free_all(&msg->properties); - mosquitto__FREE(msg); + mosquitto_FREE(msg); } void message__cleanup_all(struct mosquitto *mosq) @@ -65,14 +64,14 @@ int mosquitto_message_copy(struct mosquitto_message *dst, const struct mosquitto if(!dst || !src) return MOSQ_ERR_INVAL; dst->mid = src->mid; - dst->topic = mosquitto__strdup(src->topic); + dst->topic = mosquitto_strdup(src->topic); if(!dst->topic) return MOSQ_ERR_NOMEM; dst->qos = src->qos; dst->retain = src->retain; if(src->payloadlen){ - dst->payload = mosquitto__calloc((unsigned int)src->payloadlen+1, sizeof(uint8_t)); + dst->payload = mosquitto_calloc((unsigned int)src->payloadlen+1, sizeof(uint8_t)); if(!dst->payload){ - mosquitto__FREE(dst->topic); + mosquitto_FREE(dst->topic); return MOSQ_ERR_NOMEM; } memcpy(dst->payload, src->payload, (unsigned int)src->payloadlen); @@ -105,17 +104,17 @@ void mosquitto_message_free(struct mosquitto_message **message) msg = *message; - mosquitto__FREE(msg->topic); - mosquitto__FREE(msg->payload); - mosquitto__FREE(msg); + mosquitto_FREE(msg->topic); + mosquitto_FREE(msg->payload); + mosquitto_FREE(msg); } void mosquitto_message_free_contents(struct mosquitto_message *message) { if(!message) return; - mosquitto__FREE(message->topic); - mosquitto__FREE(message->payload); + mosquitto_FREE(message->topic); + mosquitto_FREE(message->payload); } int message__queue(struct mosquitto *mosq, struct mosquitto_message_all *message, enum mosquitto_msg_direction dir) diff --git a/lib/mosquitto.c b/lib/mosquitto.c index 22bd6325..34e524a4 100644 --- a/lib/mosquitto.c +++ b/lib/mosquitto.c @@ -33,7 +33,6 @@ Contributors: #include "logging_mosq.h" #include "mosquitto.h" #include "mosquitto_internal.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" @@ -112,7 +111,7 @@ struct mosquitto *mosquitto_new(const char *id, bool clean_start, void *userdata return NULL; } - mosq = (struct mosquitto *)mosquitto__calloc(1, sizeof(struct mosquitto)); + mosq = (struct mosquitto *)mosquitto_calloc(1, sizeof(struct mosquitto)); if(mosq){ mosq->sock = INVALID_SOCKET; #ifdef WITH_THREADING @@ -177,7 +176,7 @@ int mosquitto_reinitialise(struct mosquitto *mosq, const char *id, bool clean_st if(mosquitto_validate_utf8(id, (int)strlen(id))){ return MOSQ_ERR_MALFORMED_UTF8; } - mosq->id = mosquitto__strdup(id); + mosq->id = mosquitto_strdup(id); if(!mosq->id){ return MOSQ_ERR_NOMEM; } @@ -284,24 +283,24 @@ void mosquitto__destroy(struct mosquitto *mosq) if(mosq->ssl_ctx){ SSL_CTX_free(mosq->ssl_ctx); } - mosquitto__FREE(mosq->tls_cafile); - mosquitto__FREE(mosq->tls_capath); - mosquitto__FREE(mosq->tls_certfile); - mosquitto__FREE(mosq->tls_keyfile); + mosquitto_FREE(mosq->tls_cafile); + mosquitto_FREE(mosq->tls_capath); + mosquitto_FREE(mosq->tls_certfile); + mosquitto_FREE(mosq->tls_keyfile); if(mosq->tls_pw_callback) mosq->tls_pw_callback = NULL; - mosquitto__FREE(mosq->tls_version); - mosquitto__FREE(mosq->tls_ciphers); - mosquitto__FREE(mosq->tls_psk); - mosquitto__FREE(mosq->tls_psk_identity); - mosquitto__FREE(mosq->tls_alpn); + mosquitto_FREE(mosq->tls_version); + mosquitto_FREE(mosq->tls_ciphers); + mosquitto_FREE(mosq->tls_psk); + mosquitto_FREE(mosq->tls_psk_identity); + mosquitto_FREE(mosq->tls_alpn); #endif - mosquitto__FREE(mosq->address); - mosquitto__FREE(mosq->id); - mosquitto__FREE(mosq->username); - mosquitto__FREE(mosq->password); - mosquitto__FREE(mosq->host); - mosquitto__FREE(mosq->bind_address); + mosquitto_FREE(mosq->address); + mosquitto_FREE(mosq->id); + mosquitto_FREE(mosq->username); + mosquitto_FREE(mosq->password); + mosquitto_FREE(mosq->host); + mosquitto_FREE(mosq->bind_address); mosquitto_property_free_all(&mosq->connect_properties); @@ -323,7 +322,7 @@ void mosquitto_destroy(struct mosquitto *mosq) if(!mosq) return; mosquitto__destroy(mosq); - mosquitto__FREE(mosq); + mosquitto_FREE(mosq); } int mosquitto_socket(struct mosquitto *mosq) @@ -362,7 +361,7 @@ int mosquitto_sub_topic_tokenise(const char *subtopic, char ***topics, int *coun } } - (*topics) = mosquitto__calloc(hier_count, sizeof(char *)); + (*topics) = mosquitto_calloc(hier_count, sizeof(char *)); if(!(*topics)) return MOSQ_ERR_NOMEM; start = 0; @@ -373,12 +372,12 @@ int mosquitto_sub_topic_tokenise(const char *subtopic, char ***topics, int *coun stop = i; if(start != stop){ tlen = stop-start + 1; - (*topics)[hier] = mosquitto__calloc(tlen, sizeof(char)); + (*topics)[hier] = mosquitto_calloc(tlen, sizeof(char)); if(!(*topics)[hier]){ for(j=0; jadns); ar_request = (struct addrinfo *)mosq->adns->ar_request; - mosquitto__FREE(ar_request); - mosquitto__FREE(mosq->adns); + mosquitto_FREE(ar_request); + mosquitto_FREE(mosq->adns); } - mosq->adns = mosquitto__calloc(1, sizeof(struct gaicb)); + mosq->adns = mosquitto_calloc(1, sizeof(struct gaicb)); if(!mosq->adns){ return MOSQ_ERR_NOMEM; } - hints = mosquitto__calloc(1, sizeof(struct addrinfo)); + hints = mosquitto_calloc(1, sizeof(struct addrinfo)); if(!hints){ - mosquitto__FREE(mosq->adns); + mosquitto_FREE(mosq->adns); return MOSQ_ERR_NOMEM; } @@ -328,8 +327,8 @@ int net__try_connect_step1(struct mosquitto *mosq, const char *host) errno = s; if(mosq->adns){ ar_request = (struct addrinfo *)mosq->adns->ar_request; - mosquitto__FREE(ar_request); - mosquitto__FREE(mosq->adns); + mosquitto_FREE(ar_request); + mosquitto_FREE(mosq->adns); } return MOSQ_ERR_EAI; } @@ -388,8 +387,8 @@ int net__try_connect_step2(struct mosquitto *mosq, uint16_t port, mosq_sock_t *s mosq->adns->ar_result = NULL; ar_request = (struct addrinfo *)mosq->adns->ar_request; - mosquitto__FREE(ar_request); - mosquitto__FREE(mosq->adns); + mosquitto_FREE(ar_request); + mosquitto_FREE(mosq->adns); if(!rp){ return MOSQ_ERR_ERRNO; diff --git a/lib/net_ws.c b/lib/net_ws.c index fae80c98..9c038d87 100644 --- a/lib/net_ws.c +++ b/lib/net_ws.c @@ -29,7 +29,6 @@ Contributors: #include "base64_mosq.h" #include "mosquitto_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" #include "packet_mosq.h" @@ -265,7 +264,7 @@ ssize_t net__read_ws(struct mosquitto *mosq, void *buf, size_t count) /* Always allocate payload for testing case, otherwise just for pings */ #endif { - mosq->wsd.out_packet = mosquitto__calloc(1, sizeof(struct mosquitto__packet) + WS_PACKET_OFFSET + mosq->wsd.payloadlen + 1); + mosq->wsd.out_packet = mosquitto_calloc(1, sizeof(struct mosquitto__packet) + WS_PACKET_OFFSET + mosq->wsd.payloadlen + 1); if(mosq->wsd.out_packet == NULL){ errno = ENOMEM; return -1; @@ -299,13 +298,13 @@ ssize_t net__read_ws(struct mosquitto *mosq, void *buf, size_t count) if(mosq->wsd.pos == (ssize_t)mosq->wsd.payloadlen){ if(mosq->wsd.opcode == WS_CLOSE){ - mosquitto__FREE(mosq->wsd.out_packet); + mosquitto_FREE(mosq->wsd.out_packet); /* Testing or PING - so we haven't read any data for the application yet. */ len = -1; errno = EAGAIN; }else if(mosq->wsd.opcode == WS_PONG){ - mosquitto__FREE(mosq->wsd.out_packet); + mosquitto_FREE(mosq->wsd.out_packet); /* Testing or PING - so we haven't read any data for the application yet. */ len = -1; errno = EAGAIN; diff --git a/lib/options.c b/lib/options.c index 659e8f59..9bfac5a4 100644 --- a/lib/options.c +++ b/lib/options.c @@ -33,7 +33,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_internal.h" -#include "memory_mosq.h" #include "misc_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "util_mosq.h" @@ -80,8 +79,8 @@ int mosquitto_username_pw_set(struct mosquitto *mosq, const char *username, cons } } - mosquitto__FREE(mosq->username); - mosquitto__FREE(mosq->password); + mosquitto_FREE(mosq->username); + mosquitto_FREE(mosq->password); if(username){ slen = strlen(username); @@ -91,14 +90,14 @@ int mosquitto_username_pw_set(struct mosquitto *mosq, const char *username, cons if(mosquitto_validate_utf8(username, (int)slen)){ return MOSQ_ERR_MALFORMED_UTF8; } - mosq->username = mosquitto__strdup(username); + mosq->username = mosquitto_strdup(username); if(!mosq->username) return MOSQ_ERR_NOMEM; } if(password){ - mosq->password = mosquitto__strdup(password); + mosq->password = mosquitto_strdup(password); if(!mosq->password){ - mosquitto__FREE(mosq->username); + mosquitto_FREE(mosq->username); return MOSQ_ERR_NOMEM; } } @@ -127,7 +126,7 @@ int mosquitto_tls_set(struct mosquitto *mosq, const char *cafile, const char *ca if(!mosq || (!cafile && !capath) || (certfile && !keyfile) || (!certfile && keyfile)) return MOSQ_ERR_INVAL; - mosquitto__FREE(mosq->tls_cafile); + mosquitto_FREE(mosq->tls_cafile); if(cafile){ fptr = mosquitto__fopen(cafile, "rt", false); if(fptr){ @@ -135,56 +134,56 @@ int mosquitto_tls_set(struct mosquitto *mosq, const char *cafile, const char *ca }else{ return MOSQ_ERR_INVAL; } - mosq->tls_cafile = mosquitto__strdup(cafile); + mosq->tls_cafile = mosquitto_strdup(cafile); if(!mosq->tls_cafile){ return MOSQ_ERR_NOMEM; } } - mosquitto__FREE(mosq->tls_capath); + mosquitto_FREE(mosq->tls_capath); if(capath){ - mosq->tls_capath = mosquitto__strdup(capath); + mosq->tls_capath = mosquitto_strdup(capath); if(!mosq->tls_capath){ return MOSQ_ERR_NOMEM; } } - mosquitto__FREE(mosq->tls_certfile); + mosquitto_FREE(mosq->tls_certfile); if(certfile){ fptr = mosquitto__fopen(certfile, "rt", false); if(fptr){ fclose(fptr); }else{ - mosquitto__FREE(mosq->tls_cafile); - mosquitto__FREE(mosq->tls_capath); + mosquitto_FREE(mosq->tls_cafile); + mosquitto_FREE(mosq->tls_capath); return MOSQ_ERR_INVAL; } - mosq->tls_certfile = mosquitto__strdup(certfile); + mosq->tls_certfile = mosquitto_strdup(certfile); if(!mosq->tls_certfile){ return MOSQ_ERR_NOMEM; } } - mosquitto__FREE(mosq->tls_keyfile); + mosquitto_FREE(mosq->tls_keyfile); if(keyfile){ if(mosq->tls_keyform == mosq_k_pem){ fptr = mosquitto__fopen(keyfile, "rt", false); if(fptr){ fclose(fptr); }else{ - mosquitto__FREE(mosq->tls_cafile); + mosquitto_FREE(mosq->tls_cafile); mosq->tls_cafile = NULL; - mosquitto__FREE(mosq->tls_capath); + mosquitto_FREE(mosq->tls_capath); mosq->tls_capath = NULL; - mosquitto__FREE(mosq->tls_certfile); + mosquitto_FREE(mosq->tls_certfile); mosq->tls_certfile = NULL; return MOSQ_ERR_INVAL; } } - mosq->tls_keyfile = mosquitto__strdup(keyfile); + mosq->tls_keyfile = mosquitto_strdup(keyfile); if(!mosq->tls_keyfile){ return MOSQ_ERR_NOMEM; } @@ -219,35 +218,35 @@ int mosquitto_tls_opts_set(struct mosquitto *mosq, int cert_reqs, const char *tl || !strcasecmp(tls_version, "tlsv1.2") || !strcasecmp(tls_version, "tlsv1.1")){ - mosquitto__FREE(mosq->tls_version); - mosq->tls_version = mosquitto__strdup(tls_version); + mosquitto_FREE(mosq->tls_version); + mosq->tls_version = mosquitto_strdup(tls_version); if(!mosq->tls_version) return MOSQ_ERR_NOMEM; }else{ return MOSQ_ERR_INVAL; } }else{ - mosquitto__FREE(mosq->tls_version); - mosq->tls_version = mosquitto__strdup("tlsv1.2"); + mosquitto_FREE(mosq->tls_version); + mosq->tls_version = mosquitto_strdup("tlsv1.2"); if(!mosq->tls_version) return MOSQ_ERR_NOMEM; } if(ciphers){ - mosquitto__FREE(mosq->tls_ciphers); - mosq->tls_ciphers = mosquitto__strdup(ciphers); + mosquitto_FREE(mosq->tls_ciphers); + mosq->tls_ciphers = mosquitto_strdup(ciphers); if(!mosq->tls_ciphers) return MOSQ_ERR_NOMEM; }else{ - mosquitto__FREE(mosq->tls_ciphers); + mosquitto_FREE(mosq->tls_ciphers); mosq->tls_ciphers = NULL; } - mosquitto__FREE(mosq->tls_ciphers); - mosquitto__FREE(mosq->tls_13_ciphers); + mosquitto_FREE(mosq->tls_ciphers); + mosquitto_FREE(mosq->tls_13_ciphers); if(ciphers){ if(!strcasecmp(mosq->tls_version, "tlsv1.3")){ - mosq->tls_13_ciphers = mosquitto__strdup(ciphers); + mosq->tls_13_ciphers = mosquitto_strdup(ciphers); if(!mosq->tls_13_ciphers) return MOSQ_ERR_NOMEM; }else{ - mosq->tls_ciphers = mosquitto__strdup(ciphers); + mosq->tls_ciphers = mosquitto_strdup(ciphers); if(!mosq->tls_ciphers) return MOSQ_ERR_NOMEM; } } @@ -291,7 +290,7 @@ int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, cons switch(option){ case MOSQ_OPT_TLS_ENGINE: #if defined(WITH_TLS) && !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 - mosquitto__FREE(mosq->tls_engine); + mosquitto_FREE(mosq->tls_engine); if(value){ /* The "Dynamic" OpenSSL engine is not initialized by default but is required by ENGINE_by_id() to find dynamically loadable engines */ @@ -301,7 +300,7 @@ int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, cons return MOSQ_ERR_INVAL; } ENGINE_free(eng); /* release the structural reference from ENGINE_by_id() */ - mosq->tls_engine = mosquitto__strdup(value); + mosq->tls_engine = mosquitto_strdup(value); if(!mosq->tls_engine){ return MOSQ_ERR_NOMEM; } @@ -331,7 +330,7 @@ int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, cons case MOSQ_OPT_TLS_ENGINE_KPASS_SHA1: #if defined(WITH_TLS) && !defined(OPENSSL_NO_ENGINE) && OPENSSL_API_LEVEL < 30000 - mosquitto__FREE(mosq->tls_engine_kpass_sha1); + mosquitto_FREE(mosq->tls_engine_kpass_sha1); if(mosquitto__hex2bin_sha1(value, (unsigned char**)&str) != MOSQ_ERR_SUCCESS){ return MOSQ_ERR_INVAL; } @@ -344,8 +343,8 @@ int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, cons case MOSQ_OPT_TLS_ALPN: #ifdef WITH_TLS - mosquitto__FREE(mosq->tls_alpn); - mosq->tls_alpn = mosquitto__strdup(value); + mosquitto_FREE(mosq->tls_alpn); + mosq->tls_alpn = mosquitto_strdup(value); if(!mosq->tls_alpn){ return MOSQ_ERR_NOMEM; } @@ -356,9 +355,9 @@ int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, cons break; case MOSQ_OPT_BIND_ADDRESS: - mosquitto__FREE(mosq->bind_address); + mosquitto_FREE(mosq->bind_address); if(value){ - mosq->bind_address = mosquitto__strdup(value); + mosq->bind_address = mosquitto_strdup(value); if(mosq->bind_address){ return MOSQ_ERR_SUCCESS; }else{ @@ -370,9 +369,9 @@ int mosquitto_string_option(struct mosquitto *mosq, enum mosq_opt_t option, cons case MOSQ_OPT_HTTP_PATH: #if defined(WITH_WEBSOCKETS) && WITH_WEBSOCKETS == WS_IS_BUILTIN - mosquitto__FREE(mosq->wsd.http_path); + mosquitto_FREE(mosq->wsd.http_path); if(value){ - mosq->wsd.http_path = mosquitto__strdup(value); + mosq->wsd.http_path = mosquitto_strdup(value); if(mosq->wsd.http_path){ return MOSQ_ERR_SUCCESS; }else{ @@ -400,16 +399,16 @@ int mosquitto_tls_psk_set(struct mosquitto *mosq, const char *psk, const char *i if(strspn(psk, "0123456789abcdefABCDEF") < strlen(psk)){ return MOSQ_ERR_INVAL; } - mosq->tls_psk = mosquitto__strdup(psk); + mosq->tls_psk = mosquitto_strdup(psk); if(!mosq->tls_psk) return MOSQ_ERR_NOMEM; - mosq->tls_psk_identity = mosquitto__strdup(identity); + mosq->tls_psk_identity = mosquitto_strdup(identity); if(!mosq->tls_psk_identity){ - mosquitto__FREE(mosq->tls_psk); + mosquitto_FREE(mosq->tls_psk); return MOSQ_ERR_NOMEM; } if(ciphers){ - mosq->tls_ciphers = mosquitto__strdup(ciphers); + mosq->tls_ciphers = mosquitto_strdup(ciphers); if(!mosq->tls_ciphers) return MOSQ_ERR_NOMEM; }else{ mosq->tls_ciphers = NULL; diff --git a/lib/packet_datatypes.c b/lib/packet_datatypes.c index 4f21c74b..90d2d610 100644 --- a/lib/packet_datatypes.c +++ b/lib/packet_datatypes.c @@ -34,7 +34,6 @@ Contributors: # include "read_handle.h" #endif -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" #include "packet_mosq.h" @@ -102,7 +101,7 @@ int packet__read_binary(struct mosquitto__packet_in *packet, uint8_t **data, uin if(packet->pos+slen > packet->remaining_length) return MOSQ_ERR_MALFORMED_PACKET; - *data = mosquitto__malloc(slen+1U); + *data = mosquitto_malloc(slen+1U); if(*data){ memcpy(*data, &(packet->payload[packet->pos]), slen); ((uint8_t *)(*data))[slen] = '\0'; @@ -125,7 +124,7 @@ int packet__read_string(struct mosquitto__packet_in *packet, char **str, uint16_ if(*length == 0) return MOSQ_ERR_SUCCESS; if(mosquitto_validate_utf8(*str, *length)){ - mosquitto__FREE(*str); + mosquitto_FREE(*str); *length = 0; return MOSQ_ERR_MALFORMED_UTF8; } diff --git a/lib/packet_mosq.c b/lib/packet_mosq.c index 8b3a6f34..d9f114fa 100644 --- a/lib/packet_mosq.c +++ b/lib/packet_mosq.c @@ -32,7 +32,6 @@ Contributors: #endif #include "callbacks.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" #include "packet_mosq.h" @@ -71,7 +70,7 @@ int packet__alloc(struct mosquitto__packet **packet, uint8_t command, uint32_t r if(remaining_count == 5) return MOSQ_ERR_PAYLOAD_SIZE; packet_length = remaining_length_stored + 1 + (uint8_t)remaining_count; - (*packet) = mosquitto__malloc(sizeof(struct mosquitto__packet) + packet_length + WS_PACKET_OFFSET); + (*packet) = mosquitto_malloc(sizeof(struct mosquitto__packet) + packet_length + WS_PACKET_OFFSET); if((*packet) == NULL) return MOSQ_ERR_NOMEM; /* Clear memory for everything but the payload - that will be set to valid @@ -100,7 +99,7 @@ void packet__cleanup(struct mosquitto__packet_in *packet) packet->remaining_count = 0; packet->remaining_mult = 1; packet->remaining_length = 0; - mosquitto__FREE(packet->payload); + mosquitto_FREE(packet->payload); packet->to_process = 0; packet->pos = 0; } @@ -116,7 +115,7 @@ void packet__cleanup_all_no_locks(struct mosquitto *mosq) /* Free data and reset values */ mosq->out_packet = mosq->out_packet->next; - mosquitto__FREE(packet); + mosquitto_FREE(packet); } metrics__int_dec(mosq_gauge_out_packets, mosq->out_packet_count); metrics__int_dec(mosq_gauge_out_packet_bytes, mosq->out_packet_bytes); @@ -139,7 +138,7 @@ static void packet__queue_append(struct mosquitto *mosq, struct mosquitto__packe { #ifdef WITH_BROKER if(db.config->max_queued_messages > 0 && mosq->out_packet_count >= db.config->max_queued_messages){ - mosquitto__free(packet); + mosquitto_free(packet); if(mosq->is_dropping == false){ mosq->is_dropping = true; log__printf(NULL, MOSQ_LOG_NOTICE, @@ -330,7 +329,7 @@ int packet__write(struct mosquitto *mosq) } next_packet = packet__get_next_out(mosq); - mosquitto__FREE(packet); + mosquitto_FREE(packet); packet = next_packet; #ifdef WITH_BROKER @@ -515,7 +514,7 @@ int packet__read(struct mosquitto *mosq) /* FIXME - client case for incoming message received from broker too large */ #endif if(mosq->in_packet.remaining_length > 0){ - mosq->in_packet.payload = mosquitto__malloc(mosq->in_packet.remaining_length*sizeof(uint8_t)); + mosq->in_packet.payload = mosquitto_malloc(mosq->in_packet.remaining_length*sizeof(uint8_t)); if(!mosq->in_packet.payload){ return MOSQ_ERR_NOMEM; } diff --git a/lib/property_mosq.c b/lib/property_mosq.c index 2ec5b9f7..8741f320 100644 --- a/lib/property_mosq.c +++ b/lib/property_mosq.c @@ -26,7 +26,6 @@ Contributors: #endif #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -134,7 +133,7 @@ static int property__read(struct mosquitto__packet_in *packet, uint32_t *len, mo rc = packet__read_string(packet, &str2, &slen2); if(rc){ - mosquitto__FREE(str1); + mosquitto_FREE(str1); return rc; } *len = (*len) - 2 - slen2; /* uint16, string len */ @@ -171,7 +170,7 @@ int property__read_all(int command, struct mosquitto__packet_in *packet, mosquit /* The order of properties must be preserved for some types, so keep the * same order for all */ while(proplen > 0){ - p = mosquitto__calloc(1, sizeof(mosquitto_property)); + p = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!p){ mosquitto_property_free_all(properties); return MOSQ_ERR_NOMEM; @@ -179,7 +178,7 @@ int property__read_all(int command, struct mosquitto__packet_in *packet, mosquit rc = property__read(packet, &proplen, p); if(rc){ - mosquitto__FREE(p); + mosquitto_FREE(p); mosquitto_property_free_all(properties); return rc; } @@ -208,16 +207,16 @@ void property__free(mosquitto_property **property) switch((*property)->property_type){ case MQTT_PROP_TYPE_STRING: - mosquitto__FREE((*property)->value.s.v); + mosquitto_FREE((*property)->value.s.v); break; case MQTT_PROP_TYPE_BINARY: - mosquitto__FREE((*property)->value.bin.v); + mosquitto_FREE((*property)->value.bin.v); break; case MQTT_PROP_TYPE_STRING_PAIR: - mosquitto__FREE((*property)->name.v); - mosquitto__FREE((*property)->value.s.v); + mosquitto_FREE((*property)->name.v); + mosquitto_FREE((*property)->value.s.v); break; case MQTT_PROP_TYPE_BYTE: @@ -668,7 +667,7 @@ BROKER_EXPORT int mosquitto_property_add_byte(mosquitto_property **proplist, int return MOSQ_ERR_INVAL; } - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; @@ -693,7 +692,7 @@ BROKER_EXPORT int mosquitto_property_add_int16(mosquitto_property **proplist, in return MOSQ_ERR_INVAL; } - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; @@ -719,7 +718,7 @@ BROKER_EXPORT int mosquitto_property_add_int32(mosquitto_property **proplist, in return MOSQ_ERR_INVAL; } - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; @@ -739,7 +738,7 @@ BROKER_EXPORT int mosquitto_property_add_varint(mosquitto_property **proplist, i if(!proplist || value > 268435455) return MOSQ_ERR_INVAL; if(identifier != MQTT_PROP_SUBSCRIPTION_IDENTIFIER) return MOSQ_ERR_INVAL; - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; @@ -763,7 +762,7 @@ BROKER_EXPORT int mosquitto_property_add_binary(mosquitto_property **proplist, i return MOSQ_ERR_INVAL; } - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; @@ -771,9 +770,9 @@ BROKER_EXPORT int mosquitto_property_add_binary(mosquitto_property **proplist, i prop->property_type = MQTT_PROP_TYPE_BINARY; if(len){ - prop->value.bin.v = mosquitto__malloc(len); + prop->value.bin.v = mosquitto_malloc(len); if(!prop->value.bin.v){ - mosquitto__FREE(prop); + mosquitto_FREE(prop); return MOSQ_ERR_NOMEM; } @@ -808,16 +807,16 @@ BROKER_EXPORT int mosquitto_property_add_string(mosquitto_property **proplist, i return MOSQ_ERR_INVAL; } - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; prop->identifier = identifier; prop->property_type = MQTT_PROP_TYPE_STRING; if(value && slen > 0){ - prop->value.s.v = mosquitto__strdup(value); + prop->value.s.v = mosquitto_strdup(value); if(!prop->value.s.v){ - mosquitto__FREE(prop); + mosquitto_FREE(prop); return MOSQ_ERR_NOMEM; } prop->value.s.len = (uint16_t)slen; @@ -843,7 +842,7 @@ BROKER_EXPORT int mosquitto_property_add_string_pair(mosquitto_property **propli if(mosquitto_validate_utf8(value, (int)slen_value)) return MOSQ_ERR_MALFORMED_UTF8; } - prop = mosquitto__calloc(1, sizeof(mosquitto_property)); + prop = mosquitto_calloc(1, sizeof(mosquitto_property)); if(!prop) return MOSQ_ERR_NOMEM; prop->client_generated = true; @@ -851,19 +850,19 @@ BROKER_EXPORT int mosquitto_property_add_string_pair(mosquitto_property **propli prop->property_type = MQTT_PROP_TYPE_STRING_PAIR; if(name){ - prop->name.v = mosquitto__strdup(name); + prop->name.v = mosquitto_strdup(name); if(!prop->name.v){ - mosquitto__FREE(prop); + mosquitto_FREE(prop); return MOSQ_ERR_NOMEM; } prop->name.len = (uint16_t)strlen(name); } if(value){ - prop->value.s.v = mosquitto__strdup(value); + prop->value.s.v = mosquitto_strdup(value); if(!prop->value.s.v){ - mosquitto__FREE(prop->name.v); - mosquitto__FREE(prop); + mosquitto_FREE(prop->name.v); + mosquitto_FREE(prop); return MOSQ_ERR_NOMEM; } prop->value.s.len = (uint16_t)strlen(value); diff --git a/lib/read_handle.c b/lib/read_handle.c index 5ea007a8..708c91fd 100644 --- a/lib/read_handle.c +++ b/lib/read_handle.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "messages_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" diff --git a/lib/send_connect.c b/lib/send_connect.c index 28a89d69..872e4d92 100644 --- a/lib/send_connect.c +++ b/lib/send_connect.c @@ -27,7 +27,6 @@ Contributors: #endif #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto.h" #include "mosquitto_internal.h" #include "mosquitto/mqtt_protocol.h" @@ -133,7 +132,7 @@ int send__connect(struct mosquitto *mosq, uint16_t keepalive, bool clean_session rc = packet__alloc(&packet, CMD_CONNECT, headerlen + payloadlen); if(rc){ - mosquitto__FREE(packet); + mosquitto_FREE(packet); return rc; } diff --git a/lib/send_disconnect.c b/lib/send_disconnect.c index 79b088f1..e00094db 100644 --- a/lib/send_disconnect.c +++ b/lib/send_disconnect.c @@ -28,7 +28,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_internal.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -68,7 +67,7 @@ int send__disconnect(struct mosquitto *mosq, uint8_t reason_code, const mosquitt rc = packet__alloc(&packet, CMD_DISCONNECT, remaining_length); if(rc){ - mosquitto__FREE(packet); + mosquitto_FREE(packet); return rc; } if(mosq->protocol == mosq_p_mqtt5 && (reason_code != 0 || properties)){ diff --git a/lib/send_mosq.c b/lib/send_mosq.c index 0fd6e176..3babe360 100644 --- a/lib/send_mosq.c +++ b/lib/send_mosq.c @@ -31,7 +31,6 @@ Contributors: #include "mosquitto_internal.h" #include "logging_mosq.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "net_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" diff --git a/lib/send_publish.c b/lib/send_publish.c index 703ba352..337d5938 100644 --- a/lib/send_publish.c +++ b/lib/send_publish.c @@ -33,7 +33,6 @@ Contributors: #include "mosquitto_internal.h" #include "logging_mosq.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "net_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -94,8 +93,8 @@ int send__publish(struct mosquitto *mosq, uint16_t mid, const char *topic, uint3 "Rejected PUBLISH to %s, quota exceeded.", mosq->id); } - if(payload_changed) mosquitto__free((void *) payload); - if(topic_changed) mosquitto__free((char *) topic); + if(payload_changed) mosquitto_free((void *) payload); + if(topic_changed) mosquitto_free((char *) topic); if(properties_changed) mosquitto_property_free_all((mosquitto_property **) &store_props); return MOSQ_ERR_SUCCESS; @@ -129,13 +128,13 @@ int send__publish(struct mosquitto *mosq, uint16_t mid, const char *topic, uint3 return rc; } if(match){ - mapped_topic = mosquitto__strdup(topic); + mapped_topic = mosquitto_strdup(topic); if(!mapped_topic) return MOSQ_ERR_NOMEM; if(cur_topic->local_prefix){ /* This prefix needs removing. */ if(!strncmp(cur_topic->local_prefix, mapped_topic, strlen(cur_topic->local_prefix))){ - topic_temp = mosquitto__strdup(mapped_topic+strlen(cur_topic->local_prefix)); - mosquitto__FREE(mapped_topic); + topic_temp = mosquitto_strdup(mapped_topic+strlen(cur_topic->local_prefix)); + mosquitto_FREE(mapped_topic); if(!topic_temp){ return MOSQ_ERR_NOMEM; } @@ -146,20 +145,20 @@ int send__publish(struct mosquitto *mosq, uint16_t mid, const char *topic, uint3 if(cur_topic->remote_prefix){ /* This prefix needs adding. */ len = strlen(mapped_topic) + strlen(cur_topic->remote_prefix)+1; - topic_temp = mosquitto__malloc(len+1); + topic_temp = mosquitto_malloc(len+1); if(!topic_temp){ - mosquitto__FREE(mapped_topic); + mosquitto_FREE(mapped_topic); return MOSQ_ERR_NOMEM; } snprintf(topic_temp, len, "%s%s", cur_topic->remote_prefix, mapped_topic); topic_temp[len] = '\0'; - mosquitto__FREE(mapped_topic); + mosquitto_FREE(mapped_topic); mapped_topic = topic_temp; } log__printf(mosq, 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); metrics__int_inc(mosq_counter_pub_bytes_sent, payloadlen); rc = send__real_publish(mosq, mid, mapped_topic, payloadlen, payload, qos, retain, dup, subscription_identifier, store_props, expiry_interval); - mosquitto__FREE(mapped_topic); + mosquitto_FREE(mapped_topic); return rc; } } @@ -174,8 +173,8 @@ int send__publish(struct mosquitto *mosq, uint16_t mid, const char *topic, uint3 #ifdef WITH_BROKER rc = send__real_publish(mosq, mid, topic, payloadlen, payload, qos, retain, dup, subscription_identifier, store_props, expiry_interval); - if(payload_changed) mosquitto__free((void *) payload); - if(topic_changed) mosquitto__free((char *) topic); + if(payload_changed) mosquitto_free((void *) payload); + if(topic_changed) mosquitto_free((char *) topic); if(properties_changed) mosquitto_property_free_all((mosquitto_property **) &store_props); return rc; #else diff --git a/lib/send_subscribe.c b/lib/send_subscribe.c index 68b8a2e8..adaae220 100644 --- a/lib/send_subscribe.c +++ b/lib/send_subscribe.c @@ -29,7 +29,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_internal.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -63,7 +62,7 @@ int send__subscribe(struct mosquitto *mosq, int *mid, int topic_count, char *con rc = packet__alloc(&packet, CMD_SUBSCRIBE | 2, packetlen); if(rc){ - mosquitto__FREE(packet); + mosquitto_FREE(packet); return rc; } diff --git a/lib/send_unsubscribe.c b/lib/send_unsubscribe.c index d80b89d3..af5b3c96 100644 --- a/lib/send_unsubscribe.c +++ b/lib/send_unsubscribe.c @@ -28,7 +28,6 @@ Contributors: #include "mosquitto.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "property_mosq.h" diff --git a/lib/socks_mosq.c b/lib/socks_mosq.c index 5b81eabb..2cfe142c 100644 --- a/lib/socks_mosq.c +++ b/lib/socks_mosq.c @@ -36,7 +36,6 @@ Contributors: #endif #include "mosquitto_internal.h" -#include "memory_mosq.h" #include "net_mosq.h" #include "packet_mosq.h" #include "send_mosq.h" @@ -69,22 +68,22 @@ int mosquitto_socks5_set(struct mosquitto *mosq, const char *host, int port, con if(!host || strlen(host) > 256) return MOSQ_ERR_INVAL; if(port < 1 || port > UINT16_MAX) return MOSQ_ERR_INVAL; - mosquitto__FREE(mosq->socks5_host); - mosq->socks5_host = mosquitto__strdup(host); + mosquitto_FREE(mosq->socks5_host); + mosq->socks5_host = mosquitto_strdup(host); if(!mosq->socks5_host){ return MOSQ_ERR_NOMEM; } mosq->socks5_port = (uint16_t)port; - mosquitto__FREE(mosq->socks5_username); - mosquitto__FREE(mosq->socks5_password); + mosquitto_FREE(mosq->socks5_username); + mosquitto_FREE(mosq->socks5_password); if(username){ if(strlen(username) > UINT8_MAX){ return MOSQ_ERR_INVAL; } - mosq->socks5_username = mosquitto__strdup(username); + mosq->socks5_username = mosquitto_strdup(username); if(!mosq->socks5_username){ return MOSQ_ERR_NOMEM; } @@ -93,9 +92,9 @@ int mosquitto_socks5_set(struct mosquitto *mosq, const char *host, int port, con if(strlen(password) > UINT8_MAX){ return MOSQ_ERR_INVAL; } - mosq->socks5_password = mosquitto__strdup(password); + mosq->socks5_password = mosquitto_strdup(password); if(!mosq->socks5_password){ - mosquitto__FREE(mosq->socks5_username); + mosquitto_FREE(mosq->socks5_username); return MOSQ_ERR_NOMEM; } } @@ -116,7 +115,7 @@ int mosquitto_socks5_set(struct mosquitto *mosq, const char *host, int port, con #ifdef WITH_SOCKS static void socks5__packet_alloc(struct mosquitto__packet **packet, uint32_t packet_length) { - *packet = mosquitto__calloc(1, sizeof(struct mosquitto__packet) + packet_length + WS_PACKET_OFFSET); + *packet = mosquitto_calloc(1, sizeof(struct mosquitto__packet) + packet_length + WS_PACKET_OFFSET); if(!(*packet)) return; (*packet)->pos = WS_PACKET_OFFSET; (*packet)->packet_length = packet_length + WS_PACKET_OFFSET; @@ -164,9 +163,9 @@ int socks5__send(struct mosquitto *mosq) mosq->in_packet.pos = 0; mosq->in_packet.packet_length = 2; mosq->in_packet.to_process = 2; - mosq->in_packet.payload = mosquitto__malloc(sizeof(uint8_t)*2); + mosq->in_packet.payload = mosquitto_malloc(sizeof(uint8_t)*2); if(!mosq->in_packet.payload){ - mosquitto__FREE(packet); + mosquitto_FREE(packet); return MOSQ_ERR_NOMEM; } @@ -220,9 +219,9 @@ int socks5__send(struct mosquitto *mosq) mosq->in_packet.pos = 0; mosq->in_packet.packet_length = 5; mosq->in_packet.to_process = 5; - mosq->in_packet.payload = mosquitto__malloc(sizeof(uint8_t)*5); + mosq->in_packet.payload = mosquitto_malloc(sizeof(uint8_t)*5); if(!mosq->in_packet.payload){ - mosquitto__FREE(packet); + mosquitto_FREE(packet); return MOSQ_ERR_NOMEM; } @@ -246,9 +245,9 @@ int socks5__send(struct mosquitto *mosq) mosq->in_packet.pos = 0; mosq->in_packet.packet_length = 2; mosq->in_packet.to_process = 2; - mosq->in_packet.payload = mosquitto__malloc(sizeof(uint8_t)*2); + mosq->in_packet.payload = mosquitto_malloc(sizeof(uint8_t)*2); if(!mosq->in_packet.payload){ - mosquitto__FREE(packet); + mosquitto_FREE(packet); return MOSQ_ERR_NOMEM; } @@ -414,7 +413,7 @@ int socks5__read(struct mosquitto *mosq) * Coverity most likely doesn't realise this because the += * promotes to the size of packet_length. */ /* coverity[tainted_data] */ - payload = mosquitto__realloc(mosq->in_packet.payload, mosq->in_packet.packet_length); + payload = mosquitto_realloc(mosq->in_packet.payload, mosq->in_packet.packet_length); if(payload){ mosq->in_packet.payload = payload; }else{ diff --git a/lib/srv_mosq.c b/lib/srv_mosq.c index b5205dae..ba22b6b5 100644 --- a/lib/srv_mosq.c +++ b/lib/srv_mosq.c @@ -28,7 +28,6 @@ Contributors: #include "callbacks.h" #include "logging_mosq.h" -#include "memory_mosq.h" #include "mosquitto_internal.h" #include "mosquitto.h" #include "util_mosq.h" @@ -78,19 +77,19 @@ int mosquitto_connect_srv(struct mosquitto *mosq, const char *host, int keepaliv }else{ #ifdef WITH_TLS if(mosq->tls_cafile || mosq->tls_capath || mosq->tls_psk){ - h = mosquitto__malloc(strlen(host) + strlen("_secure-mqtt._tcp.") + 1); + h = mosquitto_malloc(strlen(host) + strlen("_secure-mqtt._tcp.") + 1); if(!h) return MOSQ_ERR_NOMEM; sprintf(h, "_secure-mqtt._tcp.%s", host); }else{ #endif - h = mosquitto__malloc(strlen(host) + strlen("_mqtt._tcp.") + 1); + h = mosquitto_malloc(strlen(host) + strlen("_mqtt._tcp.") + 1); if(!h) return MOSQ_ERR_NOMEM; sprintf(h, "_mqtt._tcp.%s", host); #ifdef WITH_TLS } #endif ares_search(mosq->achan, h, ns_c_in, ns_t_srv, srv_callback, mosq); - mosquitto__FREE(h); + mosquitto_FREE(h); } mosquitto__set_state(mosq, mosq_cs_connect_srv); diff --git a/lib/util_mosq.c b/lib/util_mosq.c index c54c6fcf..828e74fc 100644 --- a/lib/util_mosq.c +++ b/lib/util_mosq.c @@ -50,7 +50,6 @@ Contributors: #endif #include "mosquitto.h" -#include "memory_mosq.h" #include "net_mosq.h" #include "send_mosq.h" #include "tls_mosq.h" @@ -159,7 +158,7 @@ int mosquitto__hex2bin_sha1(const char *hex, unsigned char **bin) return MOSQ_ERR_INVAL; } - sha = mosquitto__malloc(SHA_DIGEST_LENGTH); + sha = mosquitto_malloc(SHA_DIGEST_LENGTH); if(!sha){ return MOSQ_ERR_NOMEM; } diff --git a/lib/will_mosq.c b/lib/will_mosq.c index 71f2c0ba..c57cd1a9 100644 --- a/lib/will_mosq.c +++ b/lib/will_mosq.c @@ -29,7 +29,6 @@ Contributors: #include "mosquitto_internal.h" #include "logging_mosq.h" #include "messages_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" #include "read_handle.h" @@ -62,15 +61,15 @@ int will__set(struct mosquitto *mosq, const char *topic, int payloadlen, const v } if(mosq->will){ - mosquitto__FREE(mosq->will->msg.topic); - mosquitto__FREE(mosq->will->msg.payload); + mosquitto_FREE(mosq->will->msg.topic); + mosquitto_FREE(mosq->will->msg.payload); mosquitto_property_free_all(&mosq->will->properties); - mosquitto__FREE(mosq->will); + mosquitto_FREE(mosq->will); } - mosq->will = mosquitto__calloc(1, sizeof(struct mosquitto_message_all)); + mosq->will = mosquitto_calloc(1, sizeof(struct mosquitto_message_all)); if(!mosq->will) return MOSQ_ERR_NOMEM; - mosq->will->msg.topic = mosquitto__strdup(topic); + mosq->will->msg.topic = mosquitto_strdup(topic); if(!mosq->will->msg.topic){ rc = MOSQ_ERR_NOMEM; goto cleanup; @@ -81,7 +80,7 @@ int will__set(struct mosquitto *mosq, const char *topic, int payloadlen, const v rc = MOSQ_ERR_INVAL; goto cleanup; } - mosq->will->msg.payload = mosquitto__malloc(sizeof(char)*(unsigned int)mosq->will->msg.payloadlen); + mosq->will->msg.payload = mosquitto_malloc(sizeof(char)*(unsigned int)mosq->will->msg.payloadlen); if(!mosq->will->msg.payload){ rc = MOSQ_ERR_NOMEM; goto cleanup; @@ -98,9 +97,9 @@ int will__set(struct mosquitto *mosq, const char *topic, int payloadlen, const v cleanup: if(mosq->will){ - mosquitto__FREE(mosq->will->msg.topic); - mosquitto__FREE(mosq->will->msg.payload); - mosquitto__FREE(mosq->will); + mosquitto_FREE(mosq->will->msg.topic); + mosquitto_FREE(mosq->will->msg.payload); + mosquitto_FREE(mosq->will); } return rc; @@ -110,12 +109,12 @@ int will__clear(struct mosquitto *mosq) { if(!mosq->will) return MOSQ_ERR_SUCCESS; - mosquitto__FREE(mosq->will->msg.topic); - mosquitto__FREE(mosq->will->msg.payload); + mosquitto_FREE(mosq->will->msg.topic); + mosquitto_FREE(mosq->will->msg.payload); mosquitto_property_free_all(&mosq->will->properties); - mosquitto__FREE(mosq->will); + mosquitto_FREE(mosq->will); mosq->will_delay_interval = 0; return MOSQ_ERR_SUCCESS; diff --git a/libcommon/CMakeLists.txt b/libcommon/CMakeLists.txt index 75a9c49d..097050c3 100644 --- a/libcommon/CMakeLists.txt +++ b/libcommon/CMakeLists.txt @@ -1,4 +1,5 @@ set(C_SRC + memory_common.c strings_common.c time_common.c topic_common.c diff --git a/libcommon/Makefile b/libcommon/Makefile index d164b973..f7b9890c 100644 --- a/libcommon/Makefile +++ b/libcommon/Makefile @@ -12,6 +12,7 @@ LOCAL_LIBADD+= .PHONY : really clean install OBJS= \ + memory_common.o \ strings_common.o \ time_common.o \ topic_common.o \ diff --git a/lib/memory_mosq.c b/libcommon/memory_common.c similarity index 85% rename from lib/memory_mosq.c rename to libcommon/memory_common.c index 44c91f1d..b6a8341c 100644 --- a/lib/memory_mosq.c +++ b/libcommon/memory_common.c @@ -21,7 +21,7 @@ Contributors: #include #include -#include "memory_mosq.h" +#include "memory_common.h" #ifdef REAL_WITH_MEMORY_TRACKING # if defined(__APPLE__) @@ -39,15 +39,13 @@ static unsigned long memcount = 0; static unsigned long max_memcount = 0; #endif -#ifdef WITH_BROKER static size_t mem_limit = 0; -void memory__set_limit(size_t lim) +void mosquitto_memory_set_limit(size_t lim) { mem_limit = lim; } -#endif -void *mosquitto__calloc(size_t nmemb, size_t size) +BROKER_EXPORT void *mosquitto_calloc(size_t nmemb, size_t size) { void *mem; #ifdef REAL_WITH_MEMORY_TRACKING @@ -69,7 +67,7 @@ void *mosquitto__calloc(size_t nmemb, size_t size) return mem; } -void mosquitto__free(void *mem) +BROKER_EXPORT void mosquitto_free(void *mem) { #ifdef REAL_WITH_MEMORY_TRACKING if(!mem){ @@ -80,7 +78,7 @@ void mosquitto__free(void *mem) free(mem); } -void *mosquitto__malloc(size_t size) +BROKER_EXPORT void *mosquitto_malloc(size_t size) { void *mem; @@ -105,18 +103,18 @@ void *mosquitto__malloc(size_t size) } #ifdef REAL_WITH_MEMORY_TRACKING -unsigned long mosquitto__memory_used(void) +unsigned long mosquitto_memory_used(void) { return memcount; } -unsigned long mosquitto__max_memory_used(void) +unsigned long mosquitto_max_memory_used(void) { return max_memcount; } #endif -void *mosquitto__realloc(void *ptr, size_t size) +BROKER_EXPORT void *mosquitto_realloc(void *ptr, size_t size) { void *mem; #ifdef REAL_WITH_MEMORY_TRACKING @@ -141,7 +139,7 @@ void *mosquitto__realloc(void *ptr, size_t size) return mem; } -char *mosquitto__strdup(const char *s) +BROKER_EXPORT char *mosquitto_strdup(const char *s) { char *str; #ifdef REAL_WITH_MEMORY_TRACKING @@ -163,7 +161,7 @@ char *mosquitto__strdup(const char *s) return str; } -char *mosquitto__strndup(const char *s, size_t n) +BROKER_EXPORT char *mosquitto_strndup(const char *s, size_t n) { char *str; #ifdef REAL_WITH_MEMORY_TRACKING diff --git a/lib/memory_mosq.h b/libcommon/memory_common.h similarity index 79% rename from lib/memory_mosq.h rename to libcommon/memory_common.h index b2890372..6f45e76b 100644 --- a/lib/memory_mosq.h +++ b/libcommon/memory_common.h @@ -29,21 +29,19 @@ Contributors: #endif void *mosquitto__calloc(size_t nmemb, size_t size); -void mosquitto__free(void *mem); -void *mosquitto__malloc(size_t size); +void mosquitto_free(void *mem); +void *mosquitto_malloc(size_t size); #ifdef REAL_WITH_MEMORY_TRACKING unsigned long mosquitto__memory_used(void); unsigned long mosquitto__max_memory_used(void); #endif -void *mosquitto__realloc(void *ptr, size_t size); -char *mosquitto__strdup(const char *s); +void *mosquitto_realloc(void *ptr, size_t size); +char *mosquitto_strdup(const char *s); char *mosquitto__strndup(const char *s, size_t n); #ifdef WITH_BROKER void memory__set_limit(size_t lim); #endif -#define mosquitto__FREE(A) do { mosquitto__free(A); (A) = NULL;} while(0) -#define SAFE_FREE(A) do { free(A); (A) = NULL;} while(0) #endif diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 56eca388..924dca52 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -29,8 +29,6 @@ set (MOSQ_SRCS listeners.c logging.c loop.c - ../lib/memory_mosq.c ../lib/memory_mosq.h - memory_public.c mosquitto.c ../include/mosquitto_broker.h mosquitto_broker_internal.h ../common/misc_mosq.c ../common/misc_mosq.h diff --git a/src/Makefile b/src/Makefile index da726c49..8a30397b 100644 --- a/src/Makefile +++ b/src/Makefile @@ -62,7 +62,6 @@ OBJS= mosquitto.o \ listeners.o \ logging.o \ loop.o \ - memory_public.o \ mux.o \ mux_epoll.o \ mux_kqueue.o \ @@ -121,7 +120,6 @@ OBJS_EXTERNAL= \ handle_suback.o \ handle_unsuback.o \ json_help.o \ - memory_mosq.o \ misc_mosq.o \ net_mosq.o \ net_mosq_ocsp.o \ @@ -180,9 +178,6 @@ handle_unsuback.o : ${R}/lib/handle_unsuback.c ${R}/lib/read_handle.h json_help.o : ${R}/common/json_help.c ${R}/common/json_help.h ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ -memory_mosq.o : ${R}/lib/memory_mosq.c ${R}/lib/memory_mosq.h - ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ - misc_mosq.o : ${R}/common/misc_mosq.c ${R}/common/misc_mosq.h ${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(LOCAL_CFLAGS) -c $< -o $@ diff --git a/src/bridge.c b/src/bridge.c index 7a4f0abf..5c4ff197 100644 --- a/src/bridge.c +++ b/src/bridge.c @@ -46,7 +46,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto_internal.h" #include "net_mosq.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "send_mosq.h" #include "sys_tree.h" @@ -72,7 +71,7 @@ static struct mosquitto *bridge__new(struct mosquitto__bridge *bridge) assert(bridge); - local_id = mosquitto__strdup(bridge->local_clientid); + local_id = mosquitto_strdup(bridge->local_clientid); if(!local_id){ return NULL; } @@ -80,12 +79,12 @@ static struct mosquitto *bridge__new(struct mosquitto__bridge *bridge) HASH_FIND(hh_id, db.contexts_by_id, local_id, strlen(local_id), new_context); if(new_context){ /* (possible from persistent db) */ - mosquitto__FREE(local_id); + mosquitto_FREE(local_id); }else{ /* id wasn't found, so generate a new context */ new_context = context__init(); if(!new_context){ - mosquitto__FREE(local_id); + mosquitto_FREE(local_id); return NULL; } new_context->id = local_id; @@ -132,7 +131,7 @@ static struct mosquitto *bridge__new(struct mosquitto__bridge *bridge) plugin_persist__handle_client_add(new_context); } - bridges = mosquitto__realloc(db.bridges, (size_t)(db.bridge_count+1)*sizeof(struct mosquitto *)); + bridges = mosquitto_realloc(db.bridges, (size_t)(db.bridge_count+1)*sizeof(struct mosquitto *)); if(bridges){ db.bridges = bridges; db.bridge_count++; @@ -295,7 +294,7 @@ static int bridge__connect_step1(struct mosquitto *context) } }else{ notification_topic_len = strlen(context->bridge->remote_clientid)+strlen("$SYS/broker/connection//state"); - notification_topic = mosquitto__malloc(sizeof(char)*(notification_topic_len+1)); + notification_topic = mosquitto_malloc(sizeof(char)*(notification_topic_len+1)); if(!notification_topic) return MOSQ_ERR_NOMEM; snprintf(notification_topic, notification_topic_len+1, "$SYS/broker/connection/%s/state", context->bridge->remote_clientid); @@ -308,7 +307,7 @@ static int bridge__connect_step1(struct mosquitto *context) notification_payload = '0'; rc = will__set(context, notification_topic, 1, ¬ification_payload, qos, true, NULL); - mosquitto__FREE(notification_topic); + mosquitto_FREE(notification_topic); if(rc != MOSQ_ERR_SUCCESS){ return rc; } @@ -522,7 +521,7 @@ int bridge__connect(struct mosquitto *context) } }else{ notification_topic_len = strlen(context->bridge->remote_clientid)+strlen("$SYS/broker/connection//state"); - notification_topic = mosquitto__malloc(sizeof(char)*(notification_topic_len+1)); + notification_topic = mosquitto_malloc(sizeof(char)*(notification_topic_len+1)); if(!notification_topic) return MOSQ_ERR_NOMEM; snprintf(notification_topic, notification_topic_len+1, "$SYS/broker/connection/%s/state", context->bridge->remote_clientid); @@ -536,10 +535,10 @@ int bridge__connect(struct mosquitto *context) notification_payload = '0'; rc = will__set(context, notification_topic, 1, ¬ification_payload, qos, true, NULL); if(rc != MOSQ_ERR_SUCCESS){ - mosquitto__FREE(notification_topic); + mosquitto_FREE(notification_topic); return rc; } - mosquitto__FREE(notification_topic); + mosquitto_FREE(notification_topic); } } @@ -650,7 +649,7 @@ int bridge__on_connect(struct mosquitto *context) db__messages_easy_queue(context, context->bridge->notification_topic, qos, 1, ¬ification_payload, 1, 0, NULL); }else{ notification_topic_len = strlen(context->bridge->remote_clientid)+strlen("$SYS/broker/connection//state"); - notification_topic = mosquitto__malloc(sizeof(char)*(notification_topic_len+1)); + notification_topic = mosquitto_malloc(sizeof(char)*(notification_topic_len+1)); if(!notification_topic) return MOSQ_ERR_NOMEM; snprintf(notification_topic, notification_topic_len+1, "$SYS/broker/connection/%s/state", context->bridge->remote_clientid); @@ -659,12 +658,12 @@ int bridge__on_connect(struct mosquitto *context) if(send__real_publish(context, mosquitto__mid_generate(context), notification_topic, 1, ¬ification_payload, qos, retain, 0, 0, NULL, 0)){ - mosquitto__FREE(notification_topic); + mosquitto_FREE(notification_topic); return 1; } } db__messages_easy_queue(context, notification_topic, qos, 1, ¬ification_payload, 1, 0, NULL); - mosquitto__FREE(notification_topic); + mosquitto_FREE(notification_topic); } } @@ -784,7 +783,7 @@ void bridge__db_cleanup(void) context__cleanup(db.bridges[i], true); } } - mosquitto__FREE(db.bridges); + mosquitto_FREE(db.bridges); } @@ -802,27 +801,27 @@ void bridge__cleanup(struct mosquitto *context) } db.bridge_count--; - db.bridges = mosquitto__realloc(db.bridges, (unsigned) db.bridge_count * sizeof(db.bridges[0])); + db.bridges = mosquitto_realloc(db.bridges, (unsigned) db.bridge_count * sizeof(db.bridges[0])); - mosquitto__FREE(context->bridge->name); - mosquitto__FREE(context->bridge->local_clientid); - mosquitto__FREE(context->bridge->local_username); - mosquitto__FREE(context->bridge->local_password); - mosquitto__FREE(context->bridge->tls_certfile); - mosquitto__FREE(context->bridge->tls_keyfile); + mosquitto_FREE(context->bridge->name); + mosquitto_FREE(context->bridge->local_clientid); + mosquitto_FREE(context->bridge->local_username); + mosquitto_FREE(context->bridge->local_password); + mosquitto_FREE(context->bridge->tls_certfile); + mosquitto_FREE(context->bridge->tls_keyfile); if(context->bridge->remote_clientid != context->id){ - mosquitto__FREE(context->bridge->remote_clientid); + mosquitto_FREE(context->bridge->remote_clientid); } context->bridge->remote_clientid = NULL; if(context->bridge->remote_username != context->username){ - mosquitto__FREE(context->bridge->remote_username); + mosquitto_FREE(context->bridge->remote_username); } context->bridge->remote_username = NULL; if(context->bridge->remote_password != context->password){ - mosquitto__FREE(context->bridge->remote_password); + mosquitto_FREE(context->bridge->remote_password); } context->bridge->remote_password = NULL; #ifdef WITH_TLS @@ -833,10 +832,10 @@ void bridge__cleanup(struct mosquitto *context) #endif for(i=0; ibridge->address_count; i++){ - mosquitto__FREE(context->bridge->addresses[i].address); + mosquitto_FREE(context->bridge->addresses[i].address); } - mosquitto__FREE(context->bridge->addresses); + mosquitto_FREE(context->bridge->addresses); config__bridge_cleanup(context->bridge); context->bridge = NULL; @@ -851,7 +850,7 @@ static void bridge__packet_cleanup(struct mosquitto *context) while(context->out_packet){ packet = context->out_packet; context->out_packet = context->out_packet->next; - mosquitto__FREE(packet); + mosquitto_FREE(packet); } context->out_packet = NULL; context->out_packet_last = NULL; @@ -1058,7 +1057,7 @@ void bridge_check(void) if(context->adns->ar_result){ freeaddrinfo(context->adns->ar_result); } - mosquitto__FREE(context->adns); + mosquitto_FREE(context->adns); context->bridge->restart_t = 0; } }else{ diff --git a/src/bridge_topic.c b/src/bridge_topic.c index 56986e24..0391cdef 100644 --- a/src/bridge_topic.c +++ b/src/bridge_topic.c @@ -20,7 +20,6 @@ Contributors: #include "mosquitto.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "utlist.h" #ifdef WITH_BRIDGE @@ -29,7 +28,7 @@ static int bridge__create_remap_topic(const char *prefix, const char *topic, cha if(prefix){ if(topic){ size_t len = strlen(topic) + strlen(prefix)+1; - *remap_topic = mosquitto__malloc(len+1); + *remap_topic = mosquitto_malloc(len+1); if(!(*remap_topic)){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -37,14 +36,14 @@ static int bridge__create_remap_topic(const char *prefix, const char *topic, cha snprintf(*remap_topic, len+1, "%s%s", prefix, topic); (*remap_topic)[len] = '\0'; }else{ - *remap_topic = mosquitto__strdup(prefix); + *remap_topic = mosquitto_strdup(prefix); if(!(*remap_topic)){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } } }else{ - *remap_topic = mosquitto__strdup(topic); + *remap_topic = mosquitto_strdup(topic); if(!(*remap_topic)){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -68,7 +67,7 @@ static int bridge__create_prefix(char **full_prefix, const char *topic, const ch }else{ len = strlen(prefix) + 1; } - *full_prefix = mosquitto__malloc(len); + *full_prefix = mosquitto_malloc(len); if(*full_prefix == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -166,7 +165,7 @@ int bridge__add_topic(struct mosquitto__bridge *bridge, const char *topic, enum } bridge->topic_count++; - cur_topic = mosquitto__calloc(1, sizeof(struct mosquitto__bridge_topic)); + cur_topic = mosquitto_calloc(1, sizeof(struct mosquitto__bridge_topic)); if(cur_topic == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -181,7 +180,7 @@ int bridge__add_topic(struct mosquitto__bridge *bridge, const char *topic, enum if(topic == NULL || !strcmp(topic, "\"\"")){ cur_topic->topic = NULL; }else{ - cur_topic->topic = mosquitto__strdup(topic); + cur_topic->topic = mosquitto_strdup(topic); if(cur_topic->topic == NULL){ goto error; } @@ -218,12 +217,12 @@ int bridge__add_topic(struct mosquitto__bridge *bridge, const char *topic, enum return MOSQ_ERR_SUCCESS; error: - mosquitto__FREE(cur_topic->local_prefix); - mosquitto__FREE(cur_topic->remote_prefix); - mosquitto__FREE(cur_topic->local_topic); - mosquitto__FREE(cur_topic->remote_topic); - mosquitto__FREE(cur_topic->topic); - mosquitto__FREE(cur_topic); + mosquitto_FREE(cur_topic->local_prefix); + mosquitto_FREE(cur_topic->remote_prefix); + mosquitto_FREE(cur_topic->local_topic); + mosquitto_FREE(cur_topic->remote_topic); + mosquitto_FREE(cur_topic->topic); + mosquitto_FREE(cur_topic); log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } @@ -243,7 +242,7 @@ int bridge__remap_topic_in(struct mosquitto *context, char **topic) int rc = mosquitto_topic_matches_sub(cur_topic->remote_topic, *topic, &match); if(rc){ - mosquitto__FREE(*topic); + mosquitto_FREE(*topic); return rc; } if(match){ @@ -252,12 +251,12 @@ int bridge__remap_topic_in(struct mosquitto *context, char **topic) if(cur_topic->remote_prefix){ /* This prefix needs removing. */ if(!strncmp(cur_topic->remote_prefix, *topic, strlen(cur_topic->remote_prefix))){ - topic_temp = mosquitto__strdup((*topic)+strlen(cur_topic->remote_prefix)); + topic_temp = mosquitto_strdup((*topic)+strlen(cur_topic->remote_prefix)); if(!topic_temp){ - mosquitto__FREE(*topic); + mosquitto_FREE(*topic); return MOSQ_ERR_NOMEM; } - mosquitto__FREE(*topic); + mosquitto_FREE(*topic); *topic = topic_temp; } } @@ -265,15 +264,15 @@ int bridge__remap_topic_in(struct mosquitto *context, char **topic) if(cur_topic->local_prefix){ /* This prefix needs adding. */ size_t len = strlen(*topic) + strlen(cur_topic->local_prefix)+1; - topic_temp = mosquitto__malloc(len+1); + topic_temp = mosquitto_malloc(len+1); if(!topic_temp){ - mosquitto__FREE(*topic); + mosquitto_FREE(*topic); return MOSQ_ERR_NOMEM; } snprintf(topic_temp, len, "%s%s", cur_topic->local_prefix, *topic); topic_temp[len] = '\0'; - mosquitto__FREE(*topic); + mosquitto_FREE(*topic); *topic = topic_temp; } break; diff --git a/src/broker_control.c b/src/broker_control.c index 514a5446..9222579d 100644 --- a/src/broker_control.c +++ b/src/broker_control.c @@ -32,7 +32,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto/broker_control.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" static mosquitto_plugin_id_t plg_id; diff --git a/src/conf.c b/src/conf.c index 783c7e80..b7754292 100644 --- a/src/conf.c +++ b/src/conf.c @@ -43,7 +43,6 @@ Contributors: #endif #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "misc_mosq.h" #include "tls_mosq.h" #include "util_mosq.h" @@ -155,7 +154,7 @@ static int config__add_listener(struct mosquitto__config *config) } } config->listener_count++; - config->listeners = mosquitto__realloc(config->listeners, sizeof(struct mosquitto__listener)*(size_t)config->listener_count); + config->listeners = mosquitto_realloc(config->listeners, sizeof(struct mosquitto__listener)*(size_t)config->listener_count); if(!config->listeners){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -250,9 +249,9 @@ static void config__init_reload(struct mosquitto__config *config) config->local_only = true; config->allow_duplicate_messages = true; - mosquitto__FREE(config->security_options.acl_file); - mosquitto__FREE(config->security_options.password_file); - mosquitto__FREE(config->security_options.psk_file); + mosquitto_FREE(config->security_options.acl_file); + mosquitto_FREE(config->security_options.password_file); + mosquitto_FREE(config->security_options.psk_file); config->security_options.allow_anonymous = -1; config->security_options.allow_zero_length_clientid = true; @@ -262,7 +261,7 @@ static void config__init_reload(struct mosquitto__config *config) config->autosave_interval = 1800; config->autosave_on_changes = false; - mosquitto__FREE(config->clientid_prefixes); + mosquitto_FREE(config->clientid_prefixes); config->connection_messages = true; config->clientid_prefixes = NULL; @@ -271,7 +270,7 @@ static void config__init_reload(struct mosquitto__config *config) fclose(config->log_fptr); config->log_fptr = NULL; } - mosquitto__FREE(config->log_file); + mosquitto_FREE(config->log_file); #if defined(WIN32) || defined(__CYGWIN__) if(service_handle){ @@ -294,7 +293,7 @@ static void config__init_reload(struct mosquitto__config *config) } #endif config->log_timestamp = true; - mosquitto__FREE(config->log_timestamp_format); + mosquitto_FREE(config->log_timestamp_format); config->global_max_clients = -1; config->global_max_connections = -1; config->log_timestamp_format = NULL; @@ -305,8 +304,8 @@ static void config__init_reload(struct mosquitto__config *config) config->max_inflight_bytes = 0; config->max_queued_bytes = 0; config->persistence = false; - mosquitto__FREE(config->persistence_location); - mosquitto__FREE(config->persistence_file); + mosquitto_FREE(config->persistence_location); + mosquitto_FREE(config->persistence_file); config->persistent_client_expiration = 0; config->queue_qos0_messages = false; config->retain_available = true; @@ -321,19 +320,19 @@ static void config__init_reload(struct mosquitto__config *config) static void config__cleanup_plugin_config(mosquitto_plugin_id_t *plugin) { - mosquitto__FREE(plugin->config.path); - mosquitto__FREE(plugin->config.name); + mosquitto_FREE(plugin->config.path); + mosquitto_FREE(plugin->config.name); if(plugin->config.options){ for(int j=0; jconfig.option_count; j++){ - mosquitto__FREE(plugin->config.options[j].key); - mosquitto__FREE(plugin->config.options[j].value); + mosquitto_FREE(plugin->config.options[j].key); + mosquitto_FREE(plugin->config.options[j].value); } - mosquitto__FREE(plugin->config.options); + mosquitto_FREE(plugin->config.options); plugin->config.option_count = 0; } - mosquitto__FREE(plugin->config.security_options); - mosquitto__FREE(plugin); + mosquitto_FREE(plugin->config.security_options); + mosquitto_FREE(plugin); } @@ -342,7 +341,7 @@ static void config__cleanup_plugins(void) for(int i=0; iclientid_prefixes); - mosquitto__FREE(config->persistence_location); - mosquitto__FREE(config->persistence_file); - mosquitto__FREE(config->persistence_filepath); - mosquitto__FREE(config->security_options.auto_id_prefix); - mosquitto__FREE(config->security_options.acl_file); - mosquitto__FREE(config->security_options.password_file); - mosquitto__FREE(config->security_options.psk_file); - mosquitto__FREE(config->security_options.plugins); - mosquitto__FREE(config->pid_file); - mosquitto__FREE(config->user); - mosquitto__FREE(config->log_timestamp_format); + mosquitto_FREE(config->clientid_prefixes); + mosquitto_FREE(config->persistence_location); + mosquitto_FREE(config->persistence_file); + mosquitto_FREE(config->persistence_filepath); + mosquitto_FREE(config->security_options.auto_id_prefix); + mosquitto_FREE(config->security_options.acl_file); + mosquitto_FREE(config->security_options.password_file); + mosquitto_FREE(config->security_options.psk_file); + mosquitto_FREE(config->security_options.plugins); + mosquitto_FREE(config->pid_file); + mosquitto_FREE(config->user); + mosquitto_FREE(config->log_timestamp_format); if(config->listeners){ for(int i=0; ilistener_count; i++){ - mosquitto__FREE(config->listeners[i].host); - mosquitto__FREE(config->listeners[i].bind_interface); - mosquitto__FREE(config->listeners[i].mount_point); - mosquitto__FREE(config->listeners[i].socks); + mosquitto_FREE(config->listeners[i].host); + mosquitto_FREE(config->listeners[i].bind_interface); + mosquitto_FREE(config->listeners[i].mount_point); + mosquitto_FREE(config->listeners[i].socks); if(config->listeners[i].security_options){ - mosquitto__FREE(config->listeners[i].security_options->auto_id_prefix); - mosquitto__FREE(config->listeners[i].security_options->acl_file); - mosquitto__FREE(config->listeners[i].security_options->password_file); - mosquitto__FREE(config->listeners[i].security_options->psk_file); - mosquitto__FREE(config->listeners[i].security_options->plugins); - mosquitto__FREE(config->listeners[i].security_options); + mosquitto_FREE(config->listeners[i].security_options->auto_id_prefix); + mosquitto_FREE(config->listeners[i].security_options->acl_file); + mosquitto_FREE(config->listeners[i].security_options->password_file); + mosquitto_FREE(config->listeners[i].security_options->psk_file); + mosquitto_FREE(config->listeners[i].security_options->plugins); + mosquitto_FREE(config->listeners[i].security_options); } #ifdef WITH_TLS - mosquitto__FREE(config->listeners[i].cafile); - mosquitto__FREE(config->listeners[i].capath); - mosquitto__FREE(config->listeners[i].certfile); - mosquitto__FREE(config->listeners[i].keyfile); - mosquitto__FREE(config->listeners[i].ciphers); - mosquitto__FREE(config->listeners[i].ciphers_tls13); - mosquitto__FREE(config->listeners[i].psk_hint); - mosquitto__FREE(config->listeners[i].crlfile); - mosquitto__FREE(config->listeners[i].tls_version); - mosquitto__FREE(config->listeners[i].tls_engine); - mosquitto__FREE(config->listeners[i].tls_engine_kpass_sha1); + mosquitto_FREE(config->listeners[i].cafile); + mosquitto_FREE(config->listeners[i].capath); + mosquitto_FREE(config->listeners[i].certfile); + mosquitto_FREE(config->listeners[i].keyfile); + mosquitto_FREE(config->listeners[i].ciphers); + mosquitto_FREE(config->listeners[i].ciphers_tls13); + mosquitto_FREE(config->listeners[i].psk_hint); + mosquitto_FREE(config->listeners[i].crlfile); + mosquitto_FREE(config->listeners[i].tls_version); + mosquitto_FREE(config->listeners[i].tls_engine); + mosquitto_FREE(config->listeners[i].tls_engine_kpass_sha1); #if defined(WITH_WEBSOCKETS) && WITH_WEBSOCKETS == WS_IS_LWS if(!config->listeners[i].ws_context) /* libwebsockets frees its own SSL_CTX */ #endif @@ -403,25 +402,25 @@ void config__cleanup(struct mosquitto__config *config) #endif #ifdef WITH_WEBSOCKETS # if WITH_WEBSOCKETS == WS_IS_LWS - mosquitto__FREE(config->listeners[i].http_dir); + mosquitto_FREE(config->listeners[i].http_dir); # endif for(int j=0; jlisteners[i].ws_origin_count; j++){ - mosquitto__FREE(config->listeners[i].ws_origins[j]); + mosquitto_FREE(config->listeners[i].ws_origins[j]); } - mosquitto__FREE(config->listeners[i].ws_origins); + mosquitto_FREE(config->listeners[i].ws_origins); #endif #ifdef WITH_UNIX_SOCKETS - mosquitto__FREE(config->listeners[i].unix_socket_path); + mosquitto_FREE(config->listeners[i].unix_socket_path); #endif } - mosquitto__FREE(config->listeners); + mosquitto_FREE(config->listeners); } #ifdef WITH_BRIDGE if(config->bridges){ for(int i=0; ibridge_count; i++){ config__bridge_cleanup(config->bridges[i]); } - mosquitto__FREE(config->bridges); + mosquitto_FREE(config->bridges); } #endif config__cleanup_plugins(); @@ -431,7 +430,7 @@ void config__cleanup(struct mosquitto__config *config) config->log_fptr = NULL; } if(config->log_file){ - mosquitto__FREE(config->log_file); + mosquitto_FREE(config->log_file); config->log_file = NULL; } } @@ -441,50 +440,50 @@ void config__bridge_cleanup(struct mosquitto__bridge *bridge) { if(bridge == NULL) return; - mosquitto__FREE(bridge->name); + mosquitto_FREE(bridge->name); if(bridge->addresses){ for(int i=0; iaddress_count; i++){ - mosquitto__FREE(bridge->addresses[i].address); + mosquitto_FREE(bridge->addresses[i].address); } - mosquitto__FREE(bridge->addresses); + mosquitto_FREE(bridge->addresses); } - mosquitto__FREE(bridge->bind_address); - mosquitto__FREE(bridge->remote_clientid); - mosquitto__FREE(bridge->remote_username); - mosquitto__FREE(bridge->remote_password); - mosquitto__FREE(bridge->local_clientid); - mosquitto__FREE(bridge->local_username); - mosquitto__FREE(bridge->local_password); + mosquitto_FREE(bridge->bind_address); + mosquitto_FREE(bridge->remote_clientid); + mosquitto_FREE(bridge->remote_username); + mosquitto_FREE(bridge->remote_password); + mosquitto_FREE(bridge->local_clientid); + mosquitto_FREE(bridge->local_username); + mosquitto_FREE(bridge->local_password); if(bridge->topics){ struct mosquitto__bridge_topic *cur_topic, *topic_tmp; LL_FOREACH_SAFE(bridge->topics, cur_topic, topic_tmp){ - mosquitto__FREE(cur_topic->topic); - mosquitto__FREE(cur_topic->local_prefix); - mosquitto__FREE(cur_topic->remote_prefix); - mosquitto__FREE(cur_topic->local_topic); - mosquitto__FREE(cur_topic->remote_topic); + mosquitto_FREE(cur_topic->topic); + mosquitto_FREE(cur_topic->local_prefix); + mosquitto_FREE(cur_topic->remote_prefix); + mosquitto_FREE(cur_topic->local_topic); + mosquitto_FREE(cur_topic->remote_topic); LL_DELETE(bridge->topics, cur_topic); - mosquitto__FREE(cur_topic); + mosquitto_FREE(cur_topic); } - mosquitto__FREE(bridge->topics); + mosquitto_FREE(bridge->topics); } - mosquitto__FREE(bridge->notification_topic); + mosquitto_FREE(bridge->notification_topic); #ifdef WITH_TLS - mosquitto__FREE(bridge->tls_certfile); - mosquitto__FREE(bridge->tls_keyfile); - mosquitto__FREE(bridge->tls_version); - mosquitto__FREE(bridge->tls_cafile); - mosquitto__FREE(bridge->tls_capath); - mosquitto__FREE(bridge->tls_alpn); - mosquitto__FREE(bridge->tls_ciphers); - mosquitto__FREE(bridge->tls_13_ciphers); + mosquitto_FREE(bridge->tls_certfile); + mosquitto_FREE(bridge->tls_keyfile); + mosquitto_FREE(bridge->tls_version); + mosquitto_FREE(bridge->tls_cafile); + mosquitto_FREE(bridge->tls_capath); + mosquitto_FREE(bridge->tls_alpn); + mosquitto_FREE(bridge->tls_ciphers); + mosquitto_FREE(bridge->tls_13_ciphers); #ifdef FINAL_WITH_TLS_PSK - mosquitto__FREE(bridge->tls_psk_identity); - mosquitto__FREE(bridge->tls_psk); + mosquitto_FREE(bridge->tls_psk_identity); + mosquitto_FREE(bridge->tls_psk); #endif #endif - mosquitto__FREE(bridge); + mosquitto_FREE(bridge); } #endif @@ -584,7 +583,7 @@ int config__parse_args(struct mosquitto__config *config, int argc, char *argv[]) /* Default to drop to mosquitto user if we are privileged and no user specified. */ if(!config->user){ - config->user = mosquitto__strdup("mosquitto"); + config->user = mosquitto_strdup("mosquitto"); if(config->user == NULL){ return MOSQ_ERR_NOMEM; } @@ -596,7 +595,7 @@ int config__parse_args(struct mosquitto__config *config, int argc, char *argv[]) } if(getenv("MOSQUITTO_PERSISTENCE_LOCATION")){ - mosquitto__FREE(config->persistence_location); + mosquitto_FREE(config->persistence_location); config->persistence_location = mosquitto_strdup(getenv("MOSQUITTO_PERSISTENCE_LOCATION")); if(!config->persistence_location){ return MOSQ_ERR_NOMEM; @@ -607,23 +606,23 @@ int config__parse_args(struct mosquitto__config *config, int argc, char *argv[]) static void config__copy(struct mosquitto__config *src, struct mosquitto__config *dest) { - mosquitto__FREE(dest->security_options.acl_file); + mosquitto_FREE(dest->security_options.acl_file); dest->security_options.acl_file = src->security_options.acl_file; dest->security_options.allow_anonymous = src->security_options.allow_anonymous; dest->security_options.allow_zero_length_clientid = src->security_options.allow_zero_length_clientid; - mosquitto__FREE(dest->security_options.auto_id_prefix); + mosquitto_FREE(dest->security_options.auto_id_prefix); dest->security_options.auto_id_prefix = src->security_options.auto_id_prefix; dest->security_options.auto_id_prefix_len = src->security_options.auto_id_prefix_len; - mosquitto__FREE(dest->security_options.password_file); + mosquitto_FREE(dest->security_options.password_file); dest->security_options.password_file = src->security_options.password_file; - mosquitto__FREE(dest->security_options.psk_file); + mosquitto_FREE(dest->security_options.psk_file); dest->security_options.psk_file = src->security_options.psk_file; - mosquitto__FREE(dest->security_options.plugins); + mosquitto_FREE(dest->security_options.plugins); dest->security_options.plugin_count = src->security_options.plugin_count; dest->security_options.plugins = src->security_options.plugins; @@ -633,7 +632,7 @@ static void config__copy(struct mosquitto__config *src, struct mosquitto__config dest->autosave_interval = src->autosave_interval; dest->autosave_on_changes = src->autosave_on_changes; - mosquitto__FREE(dest->clientid_prefixes); + mosquitto_FREE(dest->clientid_prefixes); dest->clientid_prefixes = src->clientid_prefixes; dest->connection_messages = src->connection_messages; @@ -642,23 +641,23 @@ static void config__copy(struct mosquitto__config *src, struct mosquitto__config dest->log_type = src->log_type; dest->log_timestamp = src->log_timestamp; - mosquitto__FREE(dest->log_timestamp_format); + mosquitto_FREE(dest->log_timestamp_format); dest->log_timestamp_format = src->log_timestamp_format; - mosquitto__FREE(dest->log_file); + mosquitto_FREE(dest->log_file); dest->log_file = src->log_file; dest->message_size_limit = src->message_size_limit; dest->persistence = src->persistence; - mosquitto__FREE(dest->persistence_location); + mosquitto_FREE(dest->persistence_location); dest->persistence_location = src->persistence_location; - mosquitto__FREE(dest->persistence_file); + mosquitto_FREE(dest->persistence_file); dest->persistence_file = src->persistence_file; - mosquitto__FREE(dest->persistence_filepath); + mosquitto_FREE(dest->persistence_filepath); dest->persistence_filepath = src->persistence_filepath; dest->persistent_client_expiration = src->persistent_client_expiration; @@ -676,7 +675,7 @@ static void config__copy(struct mosquitto__config *src, struct mosquitto__config for(int i=0;ibridge_count;i++){ if(dest->bridges[i]) config__bridge_cleanup(dest->bridges[i]); } - mosquitto__FREE(dest->bridges); + mosquitto_FREE(dest->bridges); dest->bridges = src->bridges; dest->bridge_count = src->bridge_count; #endif @@ -746,13 +745,13 @@ int config__read(struct mosquitto__config *config, bool reload) #ifdef WITH_PERSISTENCE if(config->persistence){ if(!config->persistence_file){ - config->persistence_file = mosquitto__strdup("mosquitto.db"); + config->persistence_file = mosquitto_strdup("mosquitto.db"); if(!config->persistence_file) return MOSQ_ERR_NOMEM; } - mosquitto__FREE(config->persistence_filepath); + mosquitto_FREE(config->persistence_filepath); if(config->persistence_location && strlen(config->persistence_location)){ len = strlen(config->persistence_location) + strlen(config->persistence_file) + 2; - config->persistence_filepath = mosquitto__malloc(len); + config->persistence_filepath = mosquitto_malloc(len); if(!config->persistence_filepath) return MOSQ_ERR_NOMEM; #ifdef WIN32 snprintf(config->persistence_filepath, len, "%s\\%s", config->persistence_location, config->persistence_file); @@ -760,7 +759,7 @@ int config__read(struct mosquitto__config *config, bool reload) snprintf(config->persistence_filepath, len, "%s/%s", config->persistence_location, config->persistence_file); #endif }else{ - config->persistence_filepath = mosquitto__strdup(config->persistence_file); + config->persistence_filepath = mosquitto_strdup(config->persistence_file); if(!config->persistence_filepath) return MOSQ_ERR_NOMEM; } } @@ -769,7 +768,7 @@ int config__read(struct mosquitto__config *config, bool reload) * remain here even though it is covered in config__parse_args() because this * function may be called on its own. */ if(!config->user){ - config->user = mosquitto__strdup("mosquitto"); + config->user = mosquitto_strdup("mosquitto"); } #ifdef WITH_BRIDGE @@ -840,11 +839,11 @@ static mosquitto_plugin_id_t *config__plugin_load(const char *name, const char * return NULL; } - plugin = mosquitto__calloc(1, sizeof(mosquitto_plugin_id_t)); + plugin = mosquitto_calloc(1, sizeof(mosquitto_plugin_id_t)); if(!plugin) goto error; - if(name) plugin->config.name = mosquitto__strdup(name); - plugin->config.path = mosquitto__strdup(path); + if(name) plugin->config.name = mosquitto_strdup(name); + plugin->config.path = mosquitto_strdup(path); if((name && !plugin->config.name) || !plugin->config.path){ goto error; } @@ -853,7 +852,7 @@ static mosquitto_plugin_id_t *config__plugin_load(const char *name, const char * plugin->config.deny_special_chars = true; /* Add to db list */ - plugins = mosquitto__realloc(db.plugins, (size_t)(db.plugin_count+1)*sizeof(struct mosquitto__plugin_config *)); + plugins = mosquitto_realloc(db.plugins, (size_t)(db.plugin_count+1)*sizeof(struct mosquitto__plugin_config *)); if(!plugins) goto error; plugins[db.plugin_count] = plugin; @@ -864,10 +863,10 @@ static mosquitto_plugin_id_t *config__plugin_load(const char *name, const char * error: log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); if(plugin){ - mosquitto__FREE(plugin->config.name); - mosquitto__FREE(plugin->config.path); + mosquitto_FREE(plugin->config.name); + mosquitto_FREE(plugin->config.path); } - mosquitto__FREE(plugin); + mosquitto_FREE(plugin); return NULL; } @@ -877,12 +876,12 @@ int config__plugin_add_secopt(mosquitto_plugin_id_t *plugin, struct mosquitto__s struct mosquitto__security_options **new_options; mosquitto_plugin_id_t **new_plugins; - new_options = mosquitto__realloc(plugin->config.security_options, (size_t)(plugin->config.security_option_count+1)*sizeof(struct mosquitto__security_options *)); - new_plugins = mosquitto__realloc(security_options->plugins, (size_t)(security_options->plugin_count+1)*sizeof(mosquitto_plugin_id_t *)); + new_options = mosquitto_realloc(plugin->config.security_options, (size_t)(plugin->config.security_option_count+1)*sizeof(struct mosquitto__security_options *)); + new_plugins = mosquitto_realloc(security_options->plugins, (size_t)(security_options->plugin_count+1)*sizeof(mosquitto_plugin_id_t *)); if(!new_options || !new_plugins){ - mosquitto__FREE(new_options); - mosquitto__FREE(new_plugins); + mosquitto_FREE(new_options); + mosquitto_FREE(new_plugins); log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } @@ -966,7 +965,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, REQUIRE_LISTENER_IF_PER_LISTENER(token); conf__set_cur_security_options(config, &cur_listener, &cur_security_options, token); - mosquitto__FREE(cur_security_options->acl_file); + mosquitto_FREE(cur_security_options->acl_file); if(conf__parse_string(&token, "acl_file", &cur_security_options->acl_file, &saveptr)) return MOSQ_ERR_INVAL; }else if(!strcmp(token, "address") || !strcmp(token, "addresses")){ #ifdef WITH_BRIDGE @@ -980,13 +979,13 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, break; } cur_bridge->address_count++; - cur_bridge->addresses = mosquitto__realloc(cur_bridge->addresses, sizeof(struct bridge_address)*(size_t)cur_bridge->address_count); + cur_bridge->addresses = mosquitto_realloc(cur_bridge->addresses, sizeof(struct bridge_address)*(size_t)cur_bridge->address_count); if(!cur_bridge->addresses){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } memset(&cur_bridge->addresses[cur_bridge->address_count-1], 0, sizeof(struct bridge_address)); - cur_bridge->addresses[cur_bridge->address_count-1].address = mosquitto__strdup(token); + cur_bridge->addresses[cur_bridge->address_count-1].address = mosquitto_strdup(token); if(!cur_bridge->addresses[cur_bridge->address_count-1].address){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -1048,13 +1047,13 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, log__printf(NULL, MOSQ_LOG_ERR, "Error: Invalid 'plugin_opt_' config option."); return MOSQ_ERR_INVAL; } - key = mosquitto__strdup(&token[prefix_len]); + key = mosquitto_strdup(&token[prefix_len]); if(!key){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; }else if(STREMPTY(key)){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Empty 'plugin_opt_' config option."); - mosquitto__FREE(key); + mosquitto_FREE(key); return MOSQ_ERR_INVAL; } token = saveptr; @@ -1063,21 +1062,21 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, token++; } cur_plugin->config.option_count++; - cur_plugin->config.options = mosquitto__realloc(cur_plugin->config.options, (size_t)cur_plugin->config.option_count*sizeof(struct mosquitto_auth_opt)); + cur_plugin->config.options = mosquitto_realloc(cur_plugin->config.options, (size_t)cur_plugin->config.option_count*sizeof(struct mosquitto_auth_opt)); if(!cur_plugin->config.options){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); - mosquitto__FREE(key); + mosquitto_FREE(key); return MOSQ_ERR_NOMEM; } cur_plugin->config.options[cur_plugin->config.option_count-1].key = key; - cur_plugin->config.options[cur_plugin->config.option_count-1].value = mosquitto__strdup(token); + cur_plugin->config.options[cur_plugin->config.option_count-1].value = mosquitto_strdup(token); if(!cur_plugin->config.options[cur_plugin->config.option_count-1].value){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } }else{ log__printf(NULL, MOSQ_LOG_ERR, "Error: Empty '%s' value in configuration.", key); - mosquitto__FREE(key); + mosquitto_FREE(key); return MOSQ_ERR_INVAL; } }else if(!strcmp(token, "auth_plugin") || !strcmp(token, "plugin") || !strcmp(token, "global_plugin")){ @@ -1124,10 +1123,10 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, cur_plugin = config__plugin_find(name); if(!cur_plugin){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Plugin '%s' not previously loaded.", name); - mosquitto__FREE(name); + mosquitto_FREE(name); return MOSQ_ERR_INVAL; } - mosquitto__FREE(name); + mosquitto_FREE(name); if(config__plugin_add_secopt(cur_plugin, cur_listener->security_options)) return MOSQ_ERR_INVAL; }else if(!strcmp(token, "auto_id_prefix")){ REQUIRE_LISTENER_IF_PER_LISTENER(token); @@ -1304,7 +1303,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, return MOSQ_ERR_INVAL; } #endif - mosquitto__FREE(cur_bridge->tls_keyfile); + mosquitto_FREE(cur_bridge->tls_keyfile); if(conf__parse_string(&token, "bridge_keyfile", &cur_bridge->tls_keyfile, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: Bridge and/or TLS support not available."); @@ -1450,7 +1449,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, log__printf(NULL, MOSQ_LOG_ERR, "Error: Cannot use both certificate and psk encryption in a single listener."); return MOSQ_ERR_INVAL; } - mosquitto__FREE(cur_listener->cafile); + mosquitto_FREE(cur_listener->cafile); if(conf__parse_string(&token, "cafile", &cur_listener->cafile, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); @@ -1458,7 +1457,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, }else if(!strcmp(token, "capath")){ #ifdef WITH_TLS REQUIRE_LISTENER_OR_DEFAULT_LISTENER(token); - mosquitto__FREE(cur_listener->capath); + mosquitto_FREE(cur_listener->capath); if(conf__parse_string(&token, "capath", &cur_listener->capath, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); @@ -1470,7 +1469,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, log__printf(NULL, MOSQ_LOG_ERR, "Error: Cannot use both certificate and psk encryption in a single listener."); return MOSQ_ERR_INVAL; } - mosquitto__FREE(cur_listener->certfile); + mosquitto_FREE(cur_listener->certfile); if(conf__parse_string(&token, "certfile", &cur_listener->certfile, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); @@ -1480,7 +1479,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, }else if(!strcmp(token, "ciphers")){ #ifdef WITH_TLS REQUIRE_LISTENER_OR_DEFAULT_LISTENER(token); - mosquitto__FREE(cur_listener->ciphers); + mosquitto_FREE(cur_listener->ciphers); if(conf__parse_string(&token, "ciphers", &cur_listener->ciphers, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); @@ -1488,7 +1487,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, }else if(!strcmp(token, "ciphers_tls1.3")){ #if defined(WITH_TLS) && (!defined(LIBRESSL_VERSION_NUMBER) || LIBRESSL_VERSION_NUMBER > 0x3040000FL) REQUIRE_LISTENER_OR_DEFAULT_LISTENER(token); - mosquitto__FREE(cur_listener->ciphers_tls13); + mosquitto_FREE(cur_listener->ciphers_tls13); if(conf__parse_string(&token, "ciphers_tls1.3", &cur_listener->ciphers_tls13, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: ciphers_tls1.3 support not available."); @@ -1516,7 +1515,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, #endif }else if(!strcmp(token, "clientid_prefixes")){ OPTION_DEPRECATED(token, ""); - mosquitto__FREE(config->clientid_prefixes); + mosquitto_FREE(config->clientid_prefixes); if(conf__parse_string(&token, "clientid_prefixes", &config->clientid_prefixes, &saveptr)) return MOSQ_ERR_INVAL; }else if(!strcmp(token, "connection")){ #ifdef WITH_BRIDGE @@ -1531,12 +1530,12 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, } } - config->bridges = mosquitto__realloc(config->bridges, (size_t)(config->bridge_count+1)*sizeof(struct mosquitto__bridge *)); + config->bridges = mosquitto_realloc(config->bridges, (size_t)(config->bridge_count+1)*sizeof(struct mosquitto__bridge *)); if(!config->bridges){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } - cur_bridge = mosquitto__malloc(sizeof(struct mosquitto__bridge)); + cur_bridge = mosquitto_malloc(sizeof(struct mosquitto__bridge)); if(!cur_bridge){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -1546,7 +1545,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, config->bridges[config->bridge_count-1] = cur_bridge; memset(cur_bridge, 0, sizeof(struct mosquitto__bridge)); - cur_bridge->name = mosquitto__strdup(token); + cur_bridge->name = mosquitto_strdup(token); if(!cur_bridge->name){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -1580,7 +1579,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, }else if(!strcmp(token, "crlfile")){ #ifdef WITH_TLS REQUIRE_LISTENER_OR_DEFAULT_LISTENER(token); - mosquitto__FREE(cur_listener->crlfile); + mosquitto_FREE(cur_listener->crlfile); if(conf__parse_string(&token, "crlfile", &cur_listener->crlfile, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); @@ -1654,9 +1653,9 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, } } for(i=0; ikeyfile); + mosquitto_FREE(cur_listener->keyfile); if(conf__parse_string(&token, "keyfile", &cur_listener->keyfile, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); @@ -1762,20 +1761,20 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, listener__set_defaults(cur_listener); cur_listener->port = (uint16_t)tmp_int; - mosquitto__FREE(cur_listener->host); + mosquitto_FREE(cur_listener->host); #ifdef WITH_UNIX_SOCKETS - mosquitto__FREE(cur_listener->unix_socket_path); + mosquitto_FREE(cur_listener->unix_socket_path); #endif if(token){ #ifdef WITH_UNIX_SOCKETS if(cur_listener->port == 0){ - cur_listener->unix_socket_path = mosquitto__strdup(token); + cur_listener->unix_socket_path = mosquitto_strdup(token); }else #endif { - cur_listener->host = mosquitto__strdup(token); + cur_listener->host = mosquitto_strdup(token); } } }else if(!strcmp(token, "local_clientid")){ @@ -1833,7 +1832,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, } } if(token[0]){ - config->log_file = mosquitto__strdup(token); + config->log_file = mosquitto_strdup(token); if(!config->log_file){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -1982,7 +1981,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, log__printf(NULL, MOSQ_LOG_ERR, "Error: Invalid 'memory_limit' value (%ld).", lim); return MOSQ_ERR_INVAL; } - memory__set_limit((size_t)lim); + mosquitto_memory_set_limit((size_t)lim); }else if(!strcmp(token, "message_size_limit")){ log__printf(NULL, MOSQ_LOG_NOTICE, "Note: It is recommended to replace `message_size_limit` with `max_packet_size`."); if(conf__parse_int(&token, "message_size_limit", (int *)&config->message_size_limit, &saveptr)) return MOSQ_ERR_INVAL; @@ -1992,7 +1991,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, } }else if(!strcmp(token, "mount_point")){ REQUIRE_LISTENER(token); - mosquitto__FREE(cur_listener->mount_point); + mosquitto_FREE(cur_listener->mount_point); if(conf__parse_string(&token, "mount_point", &cur_listener->mount_point, &saveptr)) return MOSQ_ERR_INVAL; if(mosquitto_pub_topic_check(cur_listener->mount_point) != MOSQ_ERR_SUCCESS){ log__printf(NULL, MOSQ_LOG_ERR, @@ -2031,7 +2030,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, }else if(!strcmp(token, "password_file")){ REQUIRE_LISTENER_IF_PER_LISTENER(token); conf__set_cur_security_options(config, &cur_listener, &cur_security_options, token); - mosquitto__FREE(cur_security_options->password_file); + mosquitto_FREE(cur_security_options->password_file); if(conf__parse_string(&token, "password_file", &cur_security_options->password_file, &saveptr)) return MOSQ_ERR_INVAL; }else if(!strcmp(token, "per_listener_settings")){ OPTION_DEPRECATED(token, "Please see the documentation for how to achieve the same effect."); @@ -2128,7 +2127,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, #ifdef FINAL_WITH_TLS_PSK REQUIRE_LISTENER_IF_PER_LISTENER(token); conf__set_cur_security_options(config, &cur_listener, &cur_security_options, token); - mosquitto__FREE(cur_security_options->psk_file); + mosquitto_FREE(cur_security_options->psk_file); if(conf__parse_string(&token, "psk_file", &cur_security_options->psk_file, &saveptr)) return MOSQ_ERR_INVAL; #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS/TLS-PSK support not available."); @@ -2276,12 +2275,12 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, REQUIRE_LISTENER_OR_DEFAULT_LISTENER(token); if(conf__parse_string(&token, "tls_engine_kpass_sha1", &kpass_sha, &saveptr)) return MOSQ_ERR_INVAL; if(mosquitto__hex2bin_sha1(kpass_sha, (unsigned char**)&kpass_sha_bin) != MOSQ_ERR_SUCCESS){ - mosquitto__FREE(kpass_sha); + mosquitto_FREE(kpass_sha); return MOSQ_ERR_INVAL; } mosquitto_free(cur_listener->tls_engine_kpass_sha1); cur_listener->tls_engine_kpass_sha1 = kpass_sha_bin; - mosquitto__FREE(kpass_sha); + mosquitto_FREE(kpass_sha); #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); #endif @@ -2294,7 +2293,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, if(conf__parse_string(&token, "tls_keyform", &keyform, &saveptr)) return MOSQ_ERR_INVAL; cur_listener->tls_keyform = mosq_k_pem; if(!strcmp(keyform, "engine")) cur_listener->tls_keyform = mosq_k_engine; - mosquitto__FREE(keyform); + mosquitto_FREE(keyform); #else log__printf(NULL, MOSQ_LOG_WARNING, "Warning: TLS support not available."); #endif @@ -2413,7 +2412,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, #endif }else if(!strcmp(token, "user")){ if(reload) continue; /* Drop privileges user not valid for reloading. */ - mosquitto__FREE(config->user); + mosquitto_FREE(config->user); if(conf__parse_string(&token, "user", &config->user, &saveptr)) return MOSQ_ERR_INVAL; }else if(!strcmp(token, "use_username_as_clientid")){ REQUIRE_LISTENER_OR_DEFAULT_LISTENER(token); @@ -2444,7 +2443,7 @@ static int config__read_file_core(struct mosquitto__config *config, bool reload, #ifdef WITH_WEBSOCKETS # if LWS_LIBRARY_VERSION_NUMBER >= 3001000 || WITH_WEBSOCKETS == WS_IS_BUILTIN REQUIRE_LISTENER(token); - ws_origins = mosquitto__realloc(cur_listener->ws_origins, sizeof(char *)*(size_t)(cur_listener->ws_origin_count+1)); + ws_origins = mosquitto_realloc(cur_listener->ws_origins, sizeof(char *)*(size_t)(cur_listener->ws_origin_count+1)); if(ws_origins == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -2497,7 +2496,7 @@ int config__read_file(struct mosquitto__config *config, bool reload, const char } buflen = 1000; - buf = mosquitto__malloc((size_t)buflen); + buf = mosquitto_malloc((size_t)buflen); if(!buf){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); fclose(fptr); @@ -2505,7 +2504,7 @@ int config__read_file(struct mosquitto__config *config, bool reload, const char } rc = config__read_file_core(config, reload, cr, level, lineno, fptr, &buf, &buflen); - mosquitto__FREE(buf); + mosquitto_FREE(buf); fclose(fptr); return rc; @@ -2521,7 +2520,7 @@ static int config__check(struct mosquitto__config *config) if(config->per_listener_settings){ for(i=0; ilistener_count; i++){ if(!config->listeners[i].security_options->auto_id_prefix){ - config->listeners[i].security_options->auto_id_prefix = mosquitto__strdup("auto-"); + config->listeners[i].security_options->auto_id_prefix = mosquitto_strdup("auto-"); if(!config->listeners[i].security_options->auto_id_prefix){ return MOSQ_ERR_NOMEM; } @@ -2530,7 +2529,7 @@ static int config__check(struct mosquitto__config *config) } }else{ if(!config->security_options.auto_id_prefix){ - config->security_options.auto_id_prefix = mosquitto__strdup("auto-"); + config->security_options.auto_id_prefix = mosquitto_strdup("auto-"); if(!config->security_options.auto_id_prefix){ return MOSQ_ERR_NOMEM; } @@ -2558,7 +2557,7 @@ static int config__check_bridges(struct mosquitto__config *config) if(!bridge1->remote_clientid){ if(!gethostname(hostname, 256)){ len = strlen(hostname) + strlen(bridge1->name) + 2; - bridge1->remote_clientid = mosquitto__malloc(len); + bridge1->remote_clientid = mosquitto_malloc(len); if(!bridge1->remote_clientid){ return MOSQ_ERR_NOMEM; } @@ -2570,7 +2569,7 @@ static int config__check_bridges(struct mosquitto__config *config) if(!bridge1->local_clientid){ len = strlen(bridge1->remote_clientid) + strlen("local.") + 2; - bridge1->local_clientid = mosquitto__malloc(len); + bridge1->local_clientid = mosquitto_malloc(len); if(!bridge1->local_clientid){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -2669,7 +2668,7 @@ static int conf__parse_string(char **token, const char *name, char **value, char log__printf(NULL, MOSQ_LOG_ERR, "Error: Malformed UTF-8 in configuration."); return MOSQ_ERR_INVAL; } - *value = mosquitto__strdup(*token); + *value = mosquitto_strdup(*token); if(!*value){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; diff --git a/src/conf_includedir.c b/src/conf_includedir.c index 846a5bbb..68eaa2dc 100644 --- a/src/conf_includedir.c +++ b/src/conf_includedir.c @@ -46,7 +46,6 @@ Contributors: #endif #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "tls_mosq.h" #include "util_mosq.h" #include "mosquitto/mqtt_protocol.h" @@ -101,23 +100,23 @@ int config__get_dir_files(const char *include_dir, char ***files, int *file_coun len = strlen(include_dir)+1+strlen(find_data.cFileName)+1; l_file_count++; - files_tmp = mosquitto__realloc(l_files, l_file_count*sizeof(char *)); + files_tmp = mosquitto_realloc(l_files, l_file_count*sizeof(char *)); if(!files_tmp){ for(int i=0; id_name)+1; l_file_count++; - files_tmp = mosquitto__realloc(l_files, (size_t)l_file_count*sizeof(char *)); + files_tmp = mosquitto_realloc(l_files, (size_t)l_file_count*sizeof(char *)); if(!files_tmp) goto error; l_files = files_tmp; - l_files[l_file_count-1] = mosquitto__malloc(len+1); + l_files[l_file_count-1] = mosquitto_malloc(len+1); if(!l_files[l_file_count-1]) goto error; snprintf(l_files[l_file_count-1], len, "%s/%s", include_dir, de->d_name); l_files[l_file_count-1][len] = '\0'; @@ -183,9 +182,9 @@ int config__get_dir_files(const char *include_dir, char ***files, int *file_coun return 0; error: for(int i=0; iremote_port)){ - context->address = mosquitto__strdup(address); + context->address = mosquitto_strdup(address); } if(!context->address){ /* getpeername and inet_ntop failed and not a bridge */ @@ -60,7 +59,7 @@ struct mosquitto *context__init(void) { struct mosquitto *context; - context = mosquitto__calloc(1, sizeof(struct mosquitto)); + context = mosquitto_calloc(1, sizeof(struct mosquitto)); if(!context) return NULL; #if defined(WITH_EPOLL) || defined(WITH_KQUEUE) @@ -123,7 +122,7 @@ static void context__cleanup_out_packets(struct mosquitto *context) while(context->out_packet){ packet = context->out_packet; context->out_packet = context->out_packet->next; - mosquitto__free(packet); + mosquitto_free(packet); } metrics__int_dec(mosq_gauge_out_packets, context->out_packet_count); metrics__int_dec(mosq_gauge_out_packet_bytes, context->out_packet_bytes); @@ -156,9 +155,9 @@ void context__cleanup(struct mosquitto *context, bool force_free) keepalive__remove(context); context__cleanup_out_packets(context); - mosquitto__FREE(context->auth_method); - mosquitto__FREE(context->username); - mosquitto__FREE(context->password); + mosquitto_FREE(context->auth_method); + mosquitto_FREE(context->username); + mosquitto_FREE(context->password); net__socket_close(context); if(force_free){ @@ -166,13 +165,13 @@ void context__cleanup(struct mosquitto *context, bool force_free) } db__messages_delete(context, force_free); - mosquitto__FREE(context->address); + mosquitto_FREE(context->address); context__send_will(context); if(context->id){ context__remove_from_by_id(context); - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); } packet__cleanup(&(context->in_packet)); context__cleanup_out_packets(context); @@ -180,16 +179,16 @@ void context__cleanup(struct mosquitto *context, bool force_free) if(context->adns){ gai_cancel(context->adns); struct addrinfo *ar_request = (struct addrinfo *)context->adns->ar_request; - mosquitto__FREE(ar_request); - mosquitto__FREE(context->adns); + mosquitto_FREE(ar_request); + mosquitto_FREE(context->adns); } #endif #if defined(WITH_WEBSOCKETS) && WITH_WEBSOCKETS == WS_IS_BUILTIN - mosquitto__FREE(context->http_request); + mosquitto_FREE(context->http_request); #endif if(force_free){ - mosquitto__FREE(context); + mosquitto_FREE(context); } } diff --git a/src/control.c b/src/control.c index 1db3de9e..45d8717a 100644 --- a/src/control.c +++ b/src/control.c @@ -23,7 +23,6 @@ Contributors: #include "mosquitto/mqtt_protocol.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "send_mosq.h" #ifdef WITH_CONTROL @@ -102,13 +101,13 @@ int control__register_callback(mosquitto_plugin_id_t *pid, MOSQ_FUNC_generic_cal return MOSQ_ERR_ALREADY_EXISTS; } - cb_new = mosquitto__calloc(1, sizeof(struct mosquitto__callback)); + cb_new = mosquitto_calloc(1, sizeof(struct mosquitto__callback)); if(cb_new == NULL){ return MOSQ_ERR_NOMEM; } - cb_new->data = mosquitto__strdup(topic); + cb_new->data = mosquitto_strdup(topic); if(cb_new->data == NULL){ - mosquitto__FREE(cb_new); + mosquitto_FREE(cb_new); return MOSQ_ERR_NOMEM; } cb_new->cb = cb_func; @@ -152,13 +151,13 @@ int control__unregister_callback(mosquitto_plugin_id_t *identifier, MOSQ_FUNC_ge HASH_FIND(hh, opts->plugin_callbacks.control, topic, topic_len, cb_found); if(cb_found && cb_found->cb == cb_func){ HASH_DELETE(hh, opts->plugin_callbacks.control, cb_found); - mosquitto__FREE(cb_found->data); - mosquitto__FREE(cb_found); + mosquitto_FREE(cb_found->data); + mosquitto_FREE(cb_found); DL_FOREACH(identifier->control_endpoints, ep){ if(!strcmp(topic, ep->topic)){ DL_DELETE(identifier->control_endpoints, ep); - mosquitto__FREE(ep); + mosquitto_FREE(ep); break; } } @@ -184,11 +183,11 @@ void control__unregister_all_callbacks(mosquitto_plugin_id_t *identifier) HASH_FIND(hh, opts->plugin_callbacks.control, ep->topic, strlen(ep->topic), cb_found); if(cb_found){ HASH_DELETE(hh, opts->plugin_callbacks.control, cb_found); - mosquitto__FREE(cb_found->data); - mosquitto__FREE(cb_found); + mosquitto_FREE(cb_found->data); + mosquitto_FREE(cb_found); } DL_DELETE(identifier->control_endpoints, ep); - mosquitto__FREE(ep); + mosquitto_FREE(ep); } } diff --git a/src/database.c b/src/database.c index 58f94a4c..4c115ee5 100644 --- a/src/database.c +++ b/src/database.c @@ -23,7 +23,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "send_mosq.h" #include "sys_tree.h" #include "util_mosq.h" @@ -224,13 +223,13 @@ static void subhier_clean(struct mosquitto__subhier **subhier) leaf = peer->subs; while(leaf){ nextleaf = leaf->next; - mosquitto__FREE(leaf); + mosquitto_FREE(leaf); leaf = nextleaf; } subhier_clean(&peer->children); HASH_DELETE(hh, *subhier, peer); - mosquitto__FREE(peer); + mosquitto_FREE(peer); } } @@ -262,18 +261,18 @@ int db__msg_store_add(struct mosquitto__base_msg *base_msg) void db__msg_store_free(struct mosquitto__base_msg *base_msg) { - mosquitto__FREE(base_msg->data.source_id); - mosquitto__FREE(base_msg->data.source_username); + mosquitto_FREE(base_msg->data.source_id); + mosquitto_FREE(base_msg->data.source_username); if(base_msg->dest_ids){ for(int i=0; idest_id_count; i++){ - mosquitto__FREE(base_msg->dest_ids[i]); + mosquitto_FREE(base_msg->dest_ids[i]); } - mosquitto__FREE(base_msg->dest_ids); + mosquitto_FREE(base_msg->dest_ids); } - mosquitto__FREE(base_msg->data.topic); + mosquitto_FREE(base_msg->data.topic); mosquitto_property_free_all(&base_msg->data.properties); - mosquitto__FREE(base_msg->data.payload); - mosquitto__FREE(base_msg); + mosquitto_FREE(base_msg->data.payload); + mosquitto_FREE(base_msg); } void db__msg_store_remove(struct mosquitto__base_msg *base_msg, bool notify) @@ -339,7 +338,7 @@ static void db__message_remove_inflight(struct mosquitto *context, struct mosqui db__msg_store_ref_dec(&item->base_msg); } - mosquitto__FREE(item); + mosquitto_FREE(item); } @@ -357,7 +356,7 @@ static void db__message_remove_queued(struct mosquitto *context, struct mosquitt db__msg_store_ref_dec(&item->base_msg); } - mosquitto__FREE(item); + mosquitto_FREE(item); } static void db__fill_inflight_out_from_queue(struct mosquitto *context) @@ -485,7 +484,7 @@ int db__message_insert_incoming(struct mosquitto *context, uint64_t cmsg_id, str } #endif - client_msg = mosquitto__malloc(sizeof(struct mosquitto__client_msg)); + client_msg = mosquitto_malloc(sizeof(struct mosquitto__client_msg)); if(!client_msg) return MOSQ_ERR_NOMEM; client_msg->prev = NULL; client_msg->next = NULL; @@ -626,7 +625,7 @@ int db__message_insert_outgoing(struct mosquitto *context, uint64_t cmsg_id, uin } #endif - client_msg = mosquitto__malloc(sizeof(struct mosquitto__client_msg)); + client_msg = mosquitto_malloc(sizeof(struct mosquitto__client_msg)); if(!client_msg) return MOSQ_ERR_NOMEM; client_msg->prev = NULL; client_msg->next = NULL; @@ -670,11 +669,11 @@ int db__message_insert_outgoing(struct mosquitto *context, uint64_t cmsg_id, uin * multiple times for overlapping subscriptions, although this is only the * case for SUBSCRIPTION with multiple subs in so is a minor concern. */ - dest_ids = mosquitto__realloc(base_msg->dest_ids, sizeof(char *)*(size_t)(base_msg->dest_id_count+1)); + dest_ids = mosquitto_realloc(base_msg->dest_ids, sizeof(char *)*(size_t)(base_msg->dest_id_count+1)); if(dest_ids){ base_msg->dest_ids = dest_ids; base_msg->dest_id_count++; - base_msg->dest_ids[base_msg->dest_id_count-1] = mosquitto__strdup(context->id); + base_msg->dest_ids[base_msg->dest_id_count-1] = mosquitto_strdup(context->id); if(!base_msg->dest_ids[base_msg->dest_id_count-1]){ return MOSQ_ERR_NOMEM; } @@ -732,7 +731,7 @@ static void db__messages_delete_list(struct mosquitto__client_msg **head) DL_FOREACH_SAFE(*head, client_msg, tmp){ DL_DELETE(*head, client_msg); db__msg_store_ref_dec(&client_msg->base_msg); - mosquitto__FREE(client_msg); + mosquitto_FREE(client_msg); } *head = NULL; } @@ -801,10 +800,10 @@ int db__messages_easy_queue(struct mosquitto *context, const char *topic, uint8_ if(!topic) return MOSQ_ERR_INVAL; - base_msg = mosquitto__calloc(1, sizeof(struct mosquitto__base_msg)); + base_msg = mosquitto_calloc(1, sizeof(struct mosquitto__base_msg)); if(base_msg == NULL) return MOSQ_ERR_NOMEM; - base_msg->data.topic = mosquitto__strdup(topic); + base_msg->data.topic = mosquitto_strdup(topic); if(base_msg->data.topic == NULL){ db__msg_store_free(base_msg); return MOSQ_ERR_INVAL; @@ -818,7 +817,7 @@ int db__messages_easy_queue(struct mosquitto *context, const char *topic, uint8_ } base_msg->data.payloadlen = payloadlen; - base_msg->data.payload = mosquitto__malloc(base_msg->data.payloadlen+1); + base_msg->data.payload = mosquitto_malloc(base_msg->data.payloadlen+1); if(base_msg->data.payload == NULL){ db__msg_store_free(base_msg); return MOSQ_ERR_NOMEM; @@ -919,9 +918,9 @@ int db__message_store(const struct mosquitto *source, struct mosquitto__base_msg assert(base_msg); if(source && source->id){ - base_msg->data.source_id = mosquitto__strdup(source->id); + base_msg->data.source_id = mosquitto_strdup(source->id); }else{ - base_msg->data.source_id = mosquitto__strdup(""); + base_msg->data.source_id = mosquitto_strdup(""); } if(!base_msg->data.source_id){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); @@ -930,7 +929,7 @@ int db__message_store(const struct mosquitto *source, struct mosquitto__base_msg } if(source && source->username){ - base_msg->data.source_username = mosquitto__strdup(source->username); + base_msg->data.source_username = mosquitto_strdup(source->username); if(!base_msg->data.source_username){ db__msg_store_free(base_msg); return MOSQ_ERR_NOMEM; @@ -1248,7 +1247,7 @@ static void db__client_messages_check_acl(struct mosquitto *context, struct mosq decrement_stats_fn(msg_data, client_msg); plugin_persist__handle_client_msg_delete(context, client_msg); db__msg_store_ref_dec(&client_msg->base_msg); - mosquitto__FREE(client_msg); + mosquitto_FREE(client_msg); } } } diff --git a/src/handle_auth.c b/src/handle_auth.c index 9661974c..4631ff08 100644 --- a/src/handle_auth.c +++ b/src/handle_auth.c @@ -23,7 +23,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "send_mosq.h" @@ -83,12 +82,12 @@ int handle__auth(struct mosquitto *context) if(!auth_method || strcmp(auth_method, context->auth_method)){ /* No method, or non-matching method */ - mosquitto__FREE(auth_method); + mosquitto_FREE(auth_method); mosquitto_property_free_all(&properties); send__disconnect(context, MQTT_RC_PROTOCOL_ERROR, NULL); return MOSQ_ERR_PROTOCOL; } - mosquitto__FREE(auth_method); + mosquitto_FREE(auth_method); mosquitto_property_read_binary(properties, MQTT_PROP_AUTHENTICATION_DATA, &auth_data, &auth_data_len, false); @@ -108,7 +107,7 @@ int handle__auth(struct mosquitto *context) } rc = mosquitto_security_auth_continue(context, auth_data, auth_data_len, &auth_data_out, &auth_data_out_len); } - mosquitto__FREE(auth_data); + mosquitto_FREE(auth_data); if(rc == MOSQ_ERR_SUCCESS){ if(context->state == mosq_cs_authenticating){ return connect__on_authorised(context, auth_data_out, auth_data_out_len); @@ -131,7 +130,7 @@ int handle__auth(struct mosquitto *context) if(rc == MOSQ_ERR_AUTH){ if(context->state == mosq_cs_authenticating){ send__connack(context, 0, MQTT_RC_NOT_AUTHORIZED, NULL); - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); }else{ send__disconnect(context, MQTT_RC_NOT_AUTHORIZED, NULL); } @@ -140,14 +139,14 @@ int handle__auth(struct mosquitto *context) /* Client has requested extended authentication, but we don't support it. */ if(context->state == mosq_cs_authenticating){ send__connack(context, 0, MQTT_RC_BAD_AUTHENTICATION_METHOD, NULL); - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); }else{ send__disconnect(context, MQTT_RC_BAD_AUTHENTICATION_METHOD, NULL); } return MOSQ_ERR_PROTOCOL; }else{ if(context->state == mosq_cs_authenticating){ - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); } return rc; } diff --git a/src/handle_connack.c b/src/handle_connack.c index 56beebc2..a29d7e26 100644 --- a/src/handle_connack.c +++ b/src/handle_connack.c @@ -22,7 +22,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "send_mosq.h" diff --git a/src/handle_connect.c b/src/handle_connect.c index 2a618ce3..cdc391fb 100644 --- a/src/handle_connect.c +++ b/src/handle_connect.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "send_mosq.h" @@ -57,7 +56,7 @@ static char *clientid_gen(uint16_t *idlen, const char *auto_id_prefix, uint16_t *idlen = (uint16_t)(auto_id_prefix_len + 36); - clientid = (char *)mosquitto__calloc((size_t)(*idlen) + 1, sizeof(char)); + clientid = (char *)mosquitto_calloc((size_t)(*idlen) + 1, sizeof(char)); if(!clientid){ return NULL; } @@ -338,7 +337,7 @@ static int will__read(struct mosquitto *context, const char *clientid, struct mo uint16_t payloadlen; mosquitto_property *properties = NULL; - will_struct = mosquitto__calloc(1, sizeof(struct mosquitto_message_all)); + will_struct = mosquitto_calloc(1, sizeof(struct mosquitto_message_all)); if(!will_struct){ rc = MOSQ_ERR_NOMEM; goto error_cleanup; @@ -360,7 +359,7 @@ static int will__read(struct mosquitto *context, const char *clientid, struct mo if(context->listener->mount_point){ slen = strlen(context->listener->mount_point) + strlen(will_struct->msg.topic) + 1; - will_topic_mount = mosquitto__malloc(slen+1); + will_topic_mount = mosquitto_malloc(slen+1); if(!will_topic_mount){ rc = MOSQ_ERR_NOMEM; goto error_cleanup; @@ -369,7 +368,7 @@ static int will__read(struct mosquitto *context, const char *clientid, struct mo snprintf(will_topic_mount, slen, "%s%s", context->listener->mount_point, will_struct->msg.topic); will_topic_mount[slen] = '\0'; - mosquitto__FREE(will_struct->msg.topic); + mosquitto_FREE(will_struct->msg.topic); will_struct->msg.topic = will_topic_mount; } @@ -395,7 +394,7 @@ static int will__read(struct mosquitto *context, const char *clientid, struct mo rc = MOSQ_ERR_PAYLOAD_SIZE; goto error_cleanup; } - will_struct->msg.payload = mosquitto__malloc((size_t)will_struct->msg.payloadlen); + will_struct->msg.payload = mosquitto_malloc((size_t)will_struct->msg.payloadlen); if(!will_struct->msg.payload){ rc = MOSQ_ERR_NOMEM; goto error_cleanup; @@ -413,10 +412,10 @@ static int will__read(struct mosquitto *context, const char *clientid, struct mo error_cleanup: if(will_struct){ - mosquitto__FREE(will_struct->msg.topic); - mosquitto__FREE(will_struct->msg.payload); + mosquitto_FREE(will_struct->msg.topic); + mosquitto_FREE(will_struct->msg.payload); mosquitto_property_free_all(&will_struct->properties); - mosquitto__FREE(will_struct); + mosquitto_FREE(will_struct); } return rc; } @@ -503,7 +502,7 @@ static int get_username_from_cert(struct mosquitto *context) X509_free(client_cert); return MOSQ_ERR_AUTH; } - context->username = mosquitto__strdup(new_username); + context->username = mosquitto_strdup(new_username); if(!context->username){ if(context->protocol == mosq_p_mqtt5){ send__connack(context, 0, MQTT_RC_SERVER_UNAVAILABLE, NULL); @@ -534,7 +533,7 @@ static int get_username_from_cert(struct mosquitto *context) X509_NAME_print_ex(subject_bio, X509_get_subject_name(client_cert), 0, XN_FLAG_RFC2253); data_start = NULL; name_length = BIO_get_mem_data(subject_bio, &data_start); - subject = mosquitto__malloc(sizeof(char)*(size_t)(name_length+1)); + subject = mosquitto_malloc(sizeof(char)*(size_t)(name_length+1)); if(!subject){ if(context->protocol == mosq_p_mqtt5){ send__connack(context, 0, MQTT_RC_SERVER_UNAVAILABLE, NULL); @@ -779,7 +778,7 @@ int handle__connect(struct mosquitto *context) rc = MOSQ_ERR_PROTOCOL; goto handle_connect_error; }else{ /* mqtt311/mqtt5 */ - mosquitto__FREE(clientid); + mosquitto_FREE(clientid); if(db.config->per_listener_settings){ allow_zero_length_clientid = context->listener->security_options->allow_zero_length_clientid; @@ -907,8 +906,8 @@ int handle__connect(struct mosquitto *context) #ifdef WITH_TLS if(context->listener->ssl_ctx && (context->listener->use_identity_as_username || context->listener->use_subject_as_username)){ /* Don't need the username or password if provided */ - mosquitto__FREE(username); - mosquitto__FREE(password); + mosquitto_FREE(username); + mosquitto_FREE(password); if(!context->ssl){ if(context->protocol == mosq_p_mqtt5){ @@ -951,8 +950,8 @@ int handle__connect(struct mosquitto *context) if(context->listener->use_username_as_clientid){ if(context->username){ - mosquitto__FREE(context->id); - context->id = mosquitto__strdup(context->username); + mosquitto_FREE(context->id); + context->id = mosquitto_strdup(context->username); if(!context->id){ rc = MOSQ_ERR_NOMEM; goto handle_connect_error; @@ -973,7 +972,7 @@ int handle__connect(struct mosquitto *context) if(context->auth_method){ rc = mosquitto_security_auth_start(context, false, auth_data, auth_data_len, &auth_data_out, &auth_data_out_len); - mosquitto__FREE(auth_data); + mosquitto_FREE(auth_data); if(rc == MOSQ_ERR_SUCCESS){ return connect__on_authorised(context, auth_data_out, auth_data_out_len); }else if(rc == MOSQ_ERR_AUTH_CONTINUE){ @@ -986,15 +985,15 @@ int handle__connect(struct mosquitto *context) will__clear(context); if(rc == MOSQ_ERR_AUTH){ send__connack(context, 0, MQTT_RC_NOT_AUTHORIZED, NULL); - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); goto handle_connect_error; }else if(rc == MOSQ_ERR_NOT_SUPPORTED){ /* Client has requested extended authentication, but we don't support it. */ send__connack(context, 0, MQTT_RC_BAD_AUTHENTICATION_METHOD, NULL); - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); goto handle_connect_error; }else{ - mosquitto__FREE(context->id); + mosquitto_FREE(context->id); goto handle_connect_error; } } @@ -1050,15 +1049,15 @@ int handle__connect(struct mosquitto *context) handle_connect_error: mosquitto_property_free_all(&properties); - mosquitto__FREE(auth_data); - mosquitto__FREE(clientid); - mosquitto__FREE(username); - mosquitto__FREE(password); + mosquitto_FREE(auth_data); + mosquitto_FREE(clientid); + mosquitto_FREE(username); + mosquitto_FREE(password); if(will_struct){ mosquitto_property_free_all(&will_struct->properties); - mosquitto__FREE(will_struct->msg.payload); - mosquitto__FREE(will_struct->msg.topic); - mosquitto__FREE(will_struct); + mosquitto_FREE(will_struct->msg.payload); + mosquitto_FREE(will_struct->msg.topic); + mosquitto_FREE(will_struct); } will__clear(context); /* We return an error here which means the client is freed later on. */ diff --git a/src/handle_publish.c b/src/handle_publish.c index d4159893..e16fbdb3 100644 --- a/src/handle_publish.c +++ b/src/handle_publish.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "alias_mosq.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "read_handle.h" @@ -57,7 +56,7 @@ int handle__publish(struct mosquitto *context) context->stats.messages_received++; - base_msg = mosquitto__calloc(1, sizeof(struct mosquitto__base_msg)); + base_msg = mosquitto_calloc(1, sizeof(struct mosquitto__base_msg)); if(base_msg == NULL){ return MOSQ_ERR_NOMEM; } @@ -167,7 +166,7 @@ int handle__publish(struct mosquitto *context) metrics__int_inc(mosq_counter_pub_bytes_received, base_msg->data.payloadlen); if(context->listener && context->listener->mount_point){ len = strlen(context->listener->mount_point) + strlen(base_msg->data.topic) + 1; - topic_mount = mosquitto__malloc(len+1); + topic_mount = mosquitto_malloc(len+1); if(!topic_mount){ db__msg_store_free(base_msg); return MOSQ_ERR_NOMEM; @@ -175,7 +174,7 @@ int handle__publish(struct mosquitto *context) snprintf(topic_mount, len, "%s%s", context->listener->mount_point, base_msg->data.topic); topic_mount[len] = '\0'; - mosquitto__FREE(base_msg->data.topic); + mosquitto_FREE(base_msg->data.topic); base_msg->data.topic = topic_mount; } @@ -185,7 +184,7 @@ int handle__publish(struct mosquitto *context) reason_code = MQTT_RC_PACKET_TOO_LARGE; goto process_bad_message; } - base_msg->data.payload = mosquitto__malloc(base_msg->data.payloadlen+1); + base_msg->data.payload = mosquitto_malloc(base_msg->data.payloadlen+1); if(base_msg->data.payload == NULL){ db__msg_store_free(base_msg); return MOSQ_ERR_NOMEM; diff --git a/src/handle_subscribe.c b/src/handle_subscribe.c index e7e13910..40f319f8 100644 --- a/src/handle_subscribe.c +++ b/src/handle_subscribe.c @@ -22,7 +22,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -97,7 +96,7 @@ int handle__subscribe(struct mosquitto *context) sub.identifier = subscription_identifier; sub.properties = properties; if(packet__read_string(&context->in_packet, &sub.topic_filter, &slen)){ - mosquitto__FREE(payload); + mosquitto_FREE(payload); return MOSQ_ERR_MALFORMED_PACKET; } @@ -106,27 +105,27 @@ int handle__subscribe(struct mosquitto *context) log__printf(NULL, MOSQ_LOG_INFO, "Empty subscription string from %s, disconnecting.", context->address); - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_MALFORMED_PACKET; } if(mosquitto_sub_topic_check(sub.topic_filter)){ log__printf(NULL, MOSQ_LOG_INFO, "Invalid subscription string from %s, disconnecting.", context->address); - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_MALFORMED_PACKET; } if(packet__read_byte(&context->in_packet, &sub.options)){ - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_MALFORMED_PACKET; } if(sub.options & MQTT_SUB_OPT_NO_LOCAL && !strncmp(sub.topic_filter, "$share/", strlen("$share/"))){ - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_PROTOCOL; } @@ -142,8 +141,8 @@ int handle__subscribe(struct mosquitto *context) retain_handling = MQTT_SUB_OPT_GET_SEND_RETAIN(sub.options); if(retain_handling == 0x30 || (sub.options & 0xC0) != 0){ - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_MALFORMED_PACKET; } } @@ -151,8 +150,8 @@ int handle__subscribe(struct mosquitto *context) log__printf(NULL, MOSQ_LOG_INFO, "Invalid QoS in subscription command from %s, disconnecting.", context->address); - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_MALFORMED_PACKET; } if(qos > context->max_qos){ @@ -163,16 +162,16 @@ int handle__subscribe(struct mosquitto *context) if(context->listener && context->listener->mount_point){ len = strlen(context->listener->mount_point) + slen + 1; - sub_mount = mosquitto__malloc(len+1); + sub_mount = mosquitto_malloc(len+1); if(!sub_mount){ - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(payload); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(payload); return MOSQ_ERR_NOMEM; } snprintf(sub_mount, len, "%s%s", context->listener->mount_point, sub.topic_filter); sub_mount[len] = '\0'; - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); sub.topic_filter = sub_mount; } @@ -191,7 +190,7 @@ int handle__subscribe(struct mosquitto *context) } break; default: - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); return rc2; } if(qos > 127){ @@ -203,19 +202,19 @@ int handle__subscribe(struct mosquitto *context) if(allowed){ rc2 = plugin__handle_subscribe(context, &sub); if(rc2){ - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); return rc2; } rc2 = sub__add(context, &sub); if(rc2 > 0){ - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); return rc2; } if(context->protocol == mosq_p_mqtt311 || context->protocol == mosq_p_mqtt31){ if(rc2 == MOSQ_ERR_SUCCESS || rc2 == MOSQ_ERR_SUB_EXISTS){ if(retain__queue(context, &sub)){ - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); return rc; } } @@ -224,7 +223,7 @@ int handle__subscribe(struct mosquitto *context) || (rc2 == MOSQ_ERR_SUCCESS && retain_handling == MQTT_SUB_OPT_SEND_RETAIN_NEW)){ if(retain__queue(context, &sub)){ - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); return rc; } } @@ -233,15 +232,15 @@ int handle__subscribe(struct mosquitto *context) plugin_persist__handle_subscription_add(context, &sub); } - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); - tmp_payload = mosquitto__realloc(payload, payloadlen + 1); + tmp_payload = mosquitto_realloc(payload, payloadlen + 1); if(tmp_payload){ payload = tmp_payload; payload[payloadlen] = qos; payloadlen++; }else{ - mosquitto__FREE(payload); + mosquitto_FREE(payload); return MOSQ_ERR_NOMEM; } @@ -255,7 +254,7 @@ int handle__subscribe(struct mosquitto *context) } } if(send__suback(context, mid, payloadlen, payload)) rc = 1; - mosquitto__FREE(payload); + mosquitto_FREE(payload); #ifdef WITH_PERSISTENCE db.persistence_changes++; diff --git a/src/handle_unsubscribe.c b/src/handle_unsubscribe.c index c7ae0524..fa3f6237 100644 --- a/src/handle_unsubscribe.c +++ b/src/handle_unsubscribe.c @@ -22,7 +22,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "send_mosq.h" @@ -82,7 +81,7 @@ int handle__unsubscribe(struct mosquitto *context) } reason_code_max = 10; - reason_codes = mosquitto__malloc((size_t)reason_code_max); + reason_codes = mosquitto_malloc((size_t)reason_code_max); if(!reason_codes){ return MOSQ_ERR_NOMEM; } @@ -91,7 +90,7 @@ int handle__unsubscribe(struct mosquitto *context) memset(&sub, 0, sizeof(sub)); sub.properties = properties; if(packet__read_string(&context->in_packet, &sub.topic_filter, &slen)){ - mosquitto__FREE(reason_codes); + mosquitto_FREE(reason_codes); return MOSQ_ERR_MALFORMED_PACKET; } @@ -99,16 +98,16 @@ int handle__unsubscribe(struct mosquitto *context) log__printf(NULL, MOSQ_LOG_INFO, "Empty unsubscription string from %s, disconnecting.", context->id); - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(reason_codes); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(reason_codes); return MOSQ_ERR_MALFORMED_PACKET; } if(mosquitto_sub_topic_check(sub.topic_filter)){ log__printf(NULL, MOSQ_LOG_INFO, "Invalid unsubscription string from %s, disconnecting.", context->id); - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(reason_codes); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(reason_codes); return MOSQ_ERR_MALFORMED_PACKET; } @@ -123,8 +122,8 @@ int handle__unsubscribe(struct mosquitto *context) reason = MQTT_RC_NOT_AUTHORIZED; break; default: - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(reason_codes); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(reason_codes); return rc; } @@ -132,8 +131,8 @@ int handle__unsubscribe(struct mosquitto *context) if(allowed){ rc = plugin__handle_unsubscribe(context, &sub); if(rc){ - mosquitto__FREE(sub.topic_filter); - mosquitto__FREE(reason_codes); + mosquitto_FREE(sub.topic_filter); + mosquitto_FREE(reason_codes); return rc; } rc = sub__remove(context, sub.topic_filter, &reason); @@ -142,18 +141,18 @@ int handle__unsubscribe(struct mosquitto *context) rc = MOSQ_ERR_SUCCESS; } log__printf(NULL, MOSQ_LOG_UNSUBSCRIBE, "%s %s", context->id, sub.topic_filter); - mosquitto__FREE(sub.topic_filter); + mosquitto_FREE(sub.topic_filter); if(rc){ - mosquitto__FREE(reason_codes); + mosquitto_FREE(reason_codes); return rc; } reason_codes[reason_code_count] = reason; reason_code_count++; if(reason_code_count == reason_code_max){ - reason_tmp = mosquitto__realloc(reason_codes, (size_t)(reason_code_max*2)); + reason_tmp = mosquitto_realloc(reason_codes, (size_t)(reason_code_max*2)); if(!reason_tmp){ - mosquitto__FREE(reason_codes); + mosquitto_FREE(reason_codes); return MOSQ_ERR_NOMEM; } reason_codes = reason_tmp; @@ -168,6 +167,6 @@ int handle__unsubscribe(struct mosquitto *context) /* We don't use Reason String or User Property yet. */ rc = send__unsuback(context, mid, reason_code_count, reason_codes, NULL); - mosquitto__FREE(reason_codes); + mosquitto_FREE(reason_codes); return rc; } diff --git a/src/http_serv.c b/src/http_serv.c index 94ef4eba..f996dcac 100644 --- a/src/http_serv.c +++ b/src/http_serv.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "base64_mosq.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "net_mosq.h" #include "packet_mosq.h" @@ -39,7 +38,7 @@ Contributors: int http__context_init(struct mosquitto *context) { context->transport = mosq_t_http; - context->http_request = mosquitto__calloc(1, db.config->websockets_headers_size); + context->http_request = mosquitto_calloc(1, db.config->websockets_headers_size); if(context->http_request == NULL){ return MOSQ_ERR_NOMEM; } @@ -50,7 +49,7 @@ int http__context_init(struct mosquitto *context) int http__context_cleanup(struct mosquitto *context) { - mosquitto__FREE(context->http_request); + mosquitto_FREE(context->http_request); return MOSQ_ERR_SUCCESS; } @@ -133,7 +132,7 @@ int http__read(struct mosquitto *mosq) } if(strncmp(http_method, "GET", http_method_len) && strncmp(http_method, "HEAD", http_method_len)){ - mosquitto__FREE(mosq->http_request); + mosquitto_FREE(mosq->http_request); /* FIXME Not supported - send 501 response */ return MOSQ_ERR_UNKNOWN; } @@ -234,7 +233,7 @@ int http__read(struct mosquitto *mosq) return MOSQ_ERR_UNKNOWN; } - packet = mosquitto__calloc(1, sizeof(struct mosquitto__packet) + 1024 + WS_PACKET_OFFSET); + packet = mosquitto_calloc(1, sizeof(struct mosquitto__packet) + 1024 + WS_PACKET_OFFSET); if(!packet){ SAFE_FREE(accept_key); return MOSQ_ERR_NOMEM; diff --git a/src/keepalive.c b/src/keepalive.c index 05ba074d..6dadace3 100644 --- a/src/keepalive.c +++ b/src/keepalive.c @@ -19,7 +19,6 @@ Contributors: #include "config.h" #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include @@ -81,7 +80,7 @@ int keepalive__init(void) }else{ keepalive_list_max = (db.config->max_keepalive * 3)/2 + 1; } - keepalive_list = mosquitto__calloc((size_t)keepalive_list_max, sizeof(struct mosquitto *)); + keepalive_list = mosquitto_calloc((size_t)keepalive_list_max, sizeof(struct mosquitto *)); if(keepalive_list == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); keepalive_list_max = 0; @@ -101,7 +100,7 @@ int keepalive__init(void) void keepalive__cleanup(void) { #ifndef WITH_OLD_KEEPALIVE - mosquitto__FREE(keepalive_list); + mosquitto_FREE(keepalive_list); keepalive_list_max = 0; #endif } diff --git a/src/listeners.c b/src/listeners.c index 4da91d1a..82afe4fc 100644 --- a/src/listeners.c +++ b/src/listeners.c @@ -17,7 +17,6 @@ Contributors: */ #include "config.h" -#include "memory_mosq.h" #include "net_mosq.h" #include "mosquitto_broker_internal.h" @@ -34,14 +33,14 @@ void listener__set_defaults(struct mosquitto__listener *listener) listener->max_topic_alias = 10; listener->max_topic_alias_broker = 10; listener->protocol = mp_mqtt; - mosquitto__FREE(listener->mount_point); + mosquitto_FREE(listener->mount_point); - mosquitto__FREE(listener->security_options->acl_file); - mosquitto__FREE(listener->security_options->password_file); - mosquitto__FREE(listener->security_options->psk_file); + mosquitto_FREE(listener->security_options->acl_file); + mosquitto_FREE(listener->security_options->password_file); + mosquitto_FREE(listener->security_options->psk_file); listener->security_options->allow_anonymous = -1; listener->security_options->allow_zero_length_clientid = true; - mosquitto__FREE(listener->security_options->auto_id_prefix); + mosquitto_FREE(listener->security_options->auto_id_prefix); listener->security_options->auto_id_prefix_len = 0; #ifdef WITH_TLS listener->require_certificate = false; @@ -53,9 +52,9 @@ void listener__set_defaults(struct mosquitto__listener *listener) #if defined(WITH_WEBSOCKETS) && (LWS_LIBRARY_VERSION_NUMBER >= 3001000 || WITH_WEBSOCKETS == WS_IS_BUILTIN) for(int i=0; iws_origin_count; i++){ - mosquitto__FREE(listener->ws_origins[i]); + mosquitto_FREE(listener->ws_origins[i]); } - mosquitto__FREE(listener->ws_origins); + mosquitto_FREE(listener->ws_origins); listener->ws_origin_count = 0; #endif } @@ -86,7 +85,7 @@ static int listeners__start_single_mqtt(struct mosquitto__listener *listener) return 1; } g_listensock_count += listener->sock_count; - listensock_new = mosquitto__realloc(g_listensock, sizeof(struct mosquitto__listener_sock)*(size_t)g_listensock_count); + listensock_new = mosquitto_realloc(g_listensock, sizeof(struct mosquitto__listener_sock)*(size_t)g_listensock_count); if(!listensock_new){ return 1; } @@ -128,7 +127,7 @@ void listeners__add_websockets(struct lws_context *ws_context, mosq_sock_t fd) } g_listensock_count++; - listensock_new = mosquitto__realloc(g_listensock, sizeof(struct mosquitto__listener_sock)*(size_t)g_listensock_count); + listensock_new = mosquitto_realloc(g_listensock, sizeof(struct mosquitto__listener_sock)*(size_t)g_listensock_count); if(!listensock_new){ return; } @@ -149,7 +148,7 @@ static int listeners__add_local(const char *host, uint16_t port) struct mosquitto__listener *listeners; listeners = db.config->listeners; - listeners[db.config->listener_count].security_options = mosquitto__calloc(1, sizeof(struct mosquitto__security_options)); + listeners[db.config->listener_count].security_options = mosquitto_calloc(1, sizeof(struct mosquitto__security_options)); if(listeners[db.config->listener_count].security_options == NULL){ return MOSQ_ERR_NOMEM; } @@ -157,14 +156,14 @@ static int listeners__add_local(const char *host, uint16_t port) listener__set_defaults(&listeners[db.config->listener_count]); listeners[db.config->listener_count].security_options->allow_anonymous = true; listeners[db.config->listener_count].port = port; - listeners[db.config->listener_count].host = mosquitto__strdup(host); + listeners[db.config->listener_count].host = mosquitto_strdup(host); if(listeners[db.config->listener_count].host == NULL){ - mosquitto__FREE(listeners[db.config->listener_count].security_options); + mosquitto_FREE(listeners[db.config->listener_count].security_options); return MOSQ_ERR_NOMEM; } if(listeners__start_single_mqtt(&listeners[db.config->listener_count])){ - mosquitto__FREE(listeners[db.config->listener_count].security_options); - mosquitto__FREE(listeners[db.config->listener_count].host); + mosquitto_FREE(listeners[db.config->listener_count].security_options); + mosquitto_FREE(listeners[db.config->listener_count].host); return MOSQ_ERR_UNKNOWN; } db.config->listener_count++; @@ -185,7 +184,7 @@ static int listeners__start_local_only(void) count = (size_t)(db.config->cmd_port_count*2); } - listeners = mosquitto__realloc(db.config->listeners, count*sizeof(struct mosquitto__listener)); + listeners = mosquitto_realloc(db.config->listeners, count*sizeof(struct mosquitto__listener)); if(listeners == NULL){ return MOSQ_ERR_NOMEM; } @@ -280,7 +279,7 @@ void listeners__stop(void) if(db.config->listeners[i].ws_context){ lws_context_destroy(db.config->listeners[i].ws_context); } - mosquitto__FREE(db.config->listeners[i].ws_protocol); + mosquitto_FREE(db.config->listeners[i].ws_protocol); #endif #ifdef WITH_UNIX_SOCKETS if(db.config->listeners[i].unix_socket_path != NULL){ @@ -294,7 +293,7 @@ void listeners__stop(void) COMPAT_CLOSE(g_listensock[i].sock); } } - mosquitto__FREE(g_listensock); + mosquitto_FREE(g_listensock); g_listensock_count = 0; listensock_index = 0; } diff --git a/src/logging.c b/src/logging.c index 72bfad85..1c3301d1 100644 --- a/src/logging.c +++ b/src/logging.c @@ -38,7 +38,6 @@ Contributors: #include "logging_mosq.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "misc_mosq.h" #include "util_mosq.h" diff --git a/src/loop.c b/src/loop.c index ef08b365..71e76f01 100644 --- a/src/loop.c +++ b/src/loop.c @@ -46,7 +46,6 @@ Contributors: #endif #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "packet_mosq.h" #include "send_mosq.h" @@ -68,14 +67,14 @@ static int single_publish(struct mosquitto *context, struct mosquitto__message_v struct mosquitto__base_msg *base_msg; uint16_t mid; - base_msg = mosquitto__calloc(1, sizeof(struct mosquitto__base_msg)); + base_msg = mosquitto_calloc(1, sizeof(struct mosquitto__base_msg)); if(base_msg == NULL) return MOSQ_ERR_NOMEM; base_msg->data.topic = pub_msg->topic; pub_msg->topic = NULL; base_msg->data.retain = 0; base_msg->data.payloadlen = (uint32_t)pub_msg->payloadlen; - base_msg->data.payload = mosquitto__malloc(base_msg->data.payloadlen+1); + base_msg->data.payload = mosquitto_malloc(base_msg->data.payloadlen+1); if(base_msg->data.payload == NULL){ db__msg_store_free(base_msg); return MOSQ_ERR_NOMEM; @@ -145,11 +144,11 @@ static void queue_plugin_msgs(void) }else{ db__messages_easy_queue(NULL, msg->topic, (uint8_t)msg->qos, (uint32_t)msg->payloadlen, msg->payload, msg->retain, message_expiry, &msg->properties); } - mosquitto__FREE(msg->topic); - mosquitto__FREE(msg->payload); + mosquitto_FREE(msg->topic); + mosquitto_FREE(msg->payload); mosquitto_property_free_all(&msg->properties); - mosquitto__FREE(msg->clientid); - mosquitto__FREE(msg); + mosquitto_FREE(msg->clientid); + mosquitto_FREE(msg); } } diff --git a/src/memory_public.c b/src/memory_public.c deleted file mode 100644 index 76e6b41d..00000000 --- a/src/memory_public.c +++ /dev/null @@ -1,51 +0,0 @@ -/* -Copyright (c) 2020-2021 Roger Light - -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. -*/ -#include "config.h" - -#include "mosquitto/broker.h" -#include "memory_mosq.h" - -BROKER_EXPORT void *mosquitto_calloc(size_t nmemb, size_t size) -{ - return mosquitto__calloc(nmemb, size); -} - -BROKER_EXPORT void mosquitto_free(void *mem) -{ - mosquitto__free(mem); -} - -BROKER_EXPORT void *mosquitto_malloc(size_t size) -{ - return mosquitto__malloc(size); -} - -BROKER_EXPORT void *mosquitto_realloc(void *ptr, size_t size) -{ - return mosquitto__realloc(ptr, size); -} - -BROKER_EXPORT char *mosquitto_strdup(const char *s) -{ - return mosquitto__strdup(s); -} - -BROKER_EXPORT char *mosquitto_strndup(const char *s, size_t n) -{ - return mosquitto__strndup(s,n); -} diff --git a/src/mosquitto.c b/src/mosquitto.c index f4e415a2..bfd137e0 100644 --- a/src/mosquitto.c +++ b/src/mosquitto.c @@ -52,7 +52,6 @@ Contributors: #endif #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "misc_mosq.h" #include "util_mosq.h" @@ -506,7 +505,7 @@ int main(int argc, char *argv[]) keepalive__cleanup(); #ifdef WITH_TLS - mosquitto__FREE(db.tls_keylog); + mosquitto_FREE(db.tls_keylog); #endif db__close(); @@ -537,12 +536,12 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine UNUSED(hPrevInstance); UNUSED(nCmdShow); - argv = mosquitto__malloc(sizeof(char *)*1); + argv = mosquitto_malloc(sizeof(char *)*1); argv[0] = "mosquitto"; token = strtok_r(lpCmdLine, " ", &saveptr); while(token){ argc++; - argv = mosquitto__realloc(argv, sizeof(char *)*argc); + argv = mosquitto_realloc(argv, sizeof(char *)*argc); if(!argv){ fprintf(stderr, "Error: Out of memory.\n"); return MOSQ_ERR_NOMEM; @@ -551,7 +550,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine token = strtok_r(NULL, " ", &saveptr); } rc = main(argc, argv); - mosquitto__FREE(argv); + mosquitto_FREE(argv); return rc; } #endif diff --git a/src/mux_poll.c b/src/mux_poll.c index b3dba3b2..bb51dac5 100644 --- a/src/mux_poll.c +++ b/src/mux_poll.c @@ -48,7 +48,6 @@ Contributors: #endif #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "send_mosq.h" #include "sys_tree.h" @@ -68,7 +67,7 @@ int mux_poll__init(void) pollfd_max = (size_t)sysconf(_SC_OPEN_MAX); #endif - pollfds = mosquitto__calloc(pollfd_max, sizeof(struct pollfd)); + pollfds = mosquitto_calloc(pollfd_max, sizeof(struct pollfd)); if(!pollfds){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -254,7 +253,7 @@ int mux_poll__handle(struct mosquitto__listener_sock *listensock, int listensock int mux_poll__cleanup(void) { - mosquitto__FREE(pollfds); + mosquitto_FREE(pollfds); return MOSQ_ERR_SUCCESS; } diff --git a/src/net.c b/src/net.c index 0d02b901..94f9a470 100644 --- a/src/net.c +++ b/src/net.c @@ -54,7 +54,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "misc_mosq.h" #include "net_mosq.h" #include "util_mosq.h" @@ -298,33 +297,33 @@ static unsigned int psk_server_callback(SSL *ssl, const char *identity, unsigned /* The hex to BN conversion results in the length halving, so we can pass * max_psk_len*2 as the max hex key here. */ - psk_key = mosquitto__calloc(1, (size_t)max_psk_len*2 + 1); + psk_key = mosquitto_calloc(1, (size_t)max_psk_len*2 + 1); if(!psk_key) return 0; if(mosquitto_psk_key_get(context, psk_hint, identity, psk_key, (int)max_psk_len*2) != MOSQ_ERR_SUCCESS){ - mosquitto__FREE(psk_key); + mosquitto_FREE(psk_key); return 0; } len = mosquitto__hex2bin(psk_key, psk, (int)max_psk_len); if (len < 0){ - mosquitto__FREE(psk_key); + mosquitto_FREE(psk_key); return 0; } if(listener->use_identity_as_username){ if(mosquitto_validate_utf8(identity, (int)strlen(identity))){ - mosquitto__free(psk_key); + mosquitto_free(psk_key); return 0; } - context->username = mosquitto__strdup(identity); + context->username = mosquitto_strdup(identity); if(!context->username){ - mosquitto__FREE(psk_key); + mosquitto_FREE(psk_key); return 0; } } - mosquitto__FREE(psk_key); + mosquitto_FREE(psk_key); return (unsigned int)len; } #endif @@ -767,7 +766,7 @@ static int net__socket_listen_tcp(struct mosquitto__listener *listener) continue; } listener->sock_count++; - listener->socks = mosquitto__realloc(listener->socks, sizeof(mosq_sock_t)*(size_t)listener->sock_count); + listener->socks = mosquitto_realloc(listener->socks, sizeof(mosq_sock_t)*(size_t)listener->sock_count); if(!listener->socks){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); freeaddrinfo(ainfo); @@ -788,7 +787,7 @@ static int net__socket_listen_tcp(struct mosquitto__listener *listener) if(net__socket_nonblock(&sock)){ freeaddrinfo(ainfo); - mosquitto__FREE(listener->socks); + mosquitto_FREE(listener->socks); return 1; } @@ -821,7 +820,7 @@ static int net__socket_listen_tcp(struct mosquitto__listener *listener) net__print_error(MOSQ_LOG_ERR, "Error: %s"); COMPAT_CLOSE(sock); freeaddrinfo(ainfo); - mosquitto__FREE(listener->socks); + mosquitto_FREE(listener->socks); return 1; } @@ -829,7 +828,7 @@ static int net__socket_listen_tcp(struct mosquitto__listener *listener) net__print_error(MOSQ_LOG_ERR, "Error: %s"); freeaddrinfo(ainfo); COMPAT_CLOSE(sock); - mosquitto__FREE(listener->socks); + mosquitto_FREE(listener->socks); return 1; } } @@ -837,7 +836,7 @@ static int net__socket_listen_tcp(struct mosquitto__listener *listener) #ifndef WIN32 if(listener->bind_interface && !interface_bound){ - mosquitto__FREE(listener->socks); + mosquitto_FREE(listener->socks); return 1; } #endif @@ -874,7 +873,7 @@ static int net__socket_listen_unix(struct mosquitto__listener *listener) return 1; } listener->sock_count++; - listener->socks = mosquitto__realloc(listener->socks, sizeof(mosq_sock_t)*(size_t)listener->sock_count); + listener->socks = mosquitto_realloc(listener->socks, sizeof(mosq_sock_t)*(size_t)listener->sock_count); if(!listener->socks){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); COMPAT_CLOSE(sock); diff --git a/src/persist_read.c b/src/persist_read.c index 5914a760..26cc87ad 100644 --- a/src/persist_read.c +++ b/src/persist_read.c @@ -33,7 +33,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "persist.h" #include "misc_mosq.h" #include "util_mosq.h" @@ -60,9 +59,9 @@ static struct mosquitto *persist__find_or_add_context(const char *clientid, uint if(!context){ context = context__init(); if(!context) return NULL; - context->id = mosquitto__strdup(clientid); + context->id = mosquitto_strdup(clientid); if(!context->id){ - mosquitto__FREE(context); + mosquitto_FREE(context); return NULL; } @@ -82,13 +81,13 @@ int persist__read_string_len(FILE *db_fptr, char **str, uint16_t len) char *s = NULL; if(len){ - s = mosquitto__malloc(len+1U); + s = mosquitto_malloc(len+1U); if(!s){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } if(fread(s, 1, len, db_fptr) != len){ - mosquitto__FREE(s); + mosquitto_FREE(s); return MOSQ_ERR_NOMEM; } s[len] = '\0'; @@ -132,7 +131,7 @@ static int persist__client_msg_restore(struct P_client_msg *chunk) return 0; } - cmsg = mosquitto__calloc(1, sizeof(struct mosquitto__client_msg)); + cmsg = mosquitto_calloc(1, sizeof(struct mosquitto__client_msg)); if(!cmsg){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -217,8 +216,8 @@ static int persist__client_chunk_restore(FILE *db_fptr) rc = 1; } - mosquitto__FREE(chunk.clientid); - mosquitto__FREE(chunk.username); + mosquitto_FREE(chunk.clientid); + mosquitto_FREE(chunk.username); if(rc == 0) client_count++; return rc; } @@ -241,7 +240,7 @@ static int persist__client_msg_chunk_restore(FILE *db_fptr, uint32_t length) } rc = persist__client_msg_restore(&chunk); - mosquitto__FREE(chunk.clientid); + mosquitto_FREE(chunk.clientid); if(rc == 0) client_msg_count++; return rc; @@ -287,7 +286,7 @@ static int persist__base_msg_chunk_restore(FILE *db_fptr, uint32_t length) message_expiry_interval = 0; } - base_msg = mosquitto__calloc(1, sizeof(struct mosquitto__base_msg)); + base_msg = mosquitto_calloc(1, sizeof(struct mosquitto__base_msg)); if(base_msg == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); rc = MOSQ_ERR_NOMEM; @@ -307,8 +306,8 @@ static int persist__base_msg_chunk_restore(FILE *db_fptr, uint32_t length) rc = db__message_store(&chunk.source, base_msg, &message_expiry_interval, mosq_mo_client); - mosquitto__FREE(chunk.source.id); - mosquitto__FREE(chunk.source.username); + mosquitto_FREE(chunk.source.id); + mosquitto_FREE(chunk.source.username); if(rc == MOSQ_ERR_SUCCESS){ base_msg_count++; @@ -317,10 +316,10 @@ static int persist__base_msg_chunk_restore(FILE *db_fptr, uint32_t length) return rc; } cleanup: - mosquitto__FREE(chunk.source.id); - mosquitto__FREE(chunk.source.username); - mosquitto__FREE(chunk.topic); - mosquitto__FREE(chunk.payload); + mosquitto_FREE(chunk.source.id); + mosquitto_FREE(chunk.source.username); + mosquitto_FREE(chunk.topic); + mosquitto_FREE(chunk.payload); return rc; } @@ -347,8 +346,8 @@ static int persist__retain_chunk_restore(FILE *db_fptr) if(base_msg){ if(sub__topic_tokenise(base_msg->data.topic, &local_topic, &split_topics, NULL)) return 1; retain__store(base_msg->data.topic, base_msg, split_topics, true); - mosquitto__FREE(local_topic); - mosquitto__FREE(split_topics); + mosquitto_FREE(local_topic); + mosquitto_FREE(split_topics); retained_count++; }else{ /* Can't find the message - probably expired */ @@ -379,8 +378,8 @@ static int persist__sub_chunk_restore(FILE *db_fptr) sub.identifier = chunk.F.identifier; rc = persist__restore_sub(&sub); - mosquitto__FREE(chunk.clientid); - mosquitto__FREE(chunk.topic); + mosquitto_FREE(chunk.clientid); + mosquitto_FREE(chunk.topic); if(rc == 0) subscription_count++; return rc; diff --git a/src/persist_read_v234.c b/src/persist_read_v234.c index bfcbc4ff..1c02ba82 100644 --- a/src/persist_read_v234.c +++ b/src/persist_read_v234.c @@ -31,7 +31,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "persist.h" #include "util_mosq.h" @@ -90,7 +89,7 @@ int persist__chunk_client_read_v234(FILE *db_fptr, struct P_client *chunk, uint3 return MOSQ_ERR_SUCCESS; error: log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno)); - mosquitto__FREE(chunk->clientid); + mosquitto_FREE(chunk->clientid); return 1; } @@ -122,7 +121,7 @@ int persist__chunk_client_msg_read_v234(FILE *db_fptr, struct P_client_msg *chun return MOSQ_ERR_SUCCESS; error: log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno)); - mosquitto__FREE(chunk->clientid); + mosquitto_FREE(chunk->clientid); return 1; } @@ -177,10 +176,10 @@ int persist__chunk_base_msg_read_v234(FILE *db_fptr, struct P_base_msg *chunk, u return MOSQ_ERR_SUCCESS; error: - mosquitto__FREE(chunk->payload); - mosquitto__FREE(chunk->source.id); - mosquitto__FREE(chunk->source.username); - mosquitto__FREE(chunk->topic); + mosquitto_FREE(chunk->payload); + mosquitto_FREE(chunk->source.id); + mosquitto_FREE(chunk->source.username); + mosquitto_FREE(chunk->topic); return rc; } @@ -213,8 +212,8 @@ int persist__chunk_sub_read_v234(FILE *db_fptr, struct P_sub *chunk) return MOSQ_ERR_SUCCESS; error: - mosquitto__FREE(chunk->clientid); - mosquitto__FREE(chunk->topic); + mosquitto_FREE(chunk->clientid); + mosquitto_FREE(chunk->topic); return rc; } diff --git a/src/persist_read_v5.c b/src/persist_read_v5.c index 4171cd9d..14e67d42 100644 --- a/src/persist_read_v5.c +++ b/src/persist_read_v5.c @@ -31,7 +31,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "persist.h" #include "property_mosq.h" @@ -93,7 +92,7 @@ int persist__chunk_client_read_v56(FILE *db_fptr, struct P_client *chunk, uint32 if(chunk->F.username_len > 0){ rc = persist__read_string_len(db_fptr, &chunk->username, chunk->F.username_len); if(rc || !chunk->username){ - mosquitto__FREE(chunk->clientid); + mosquitto_FREE(chunk->clientid); return 1; } } @@ -125,7 +124,7 @@ int persist__chunk_client_msg_read_v56(FILE *db_fptr, struct P_client_msg *chunk if(length > 0){ prop_packet.remaining_length = length; - prop_packet.payload = mosquitto__malloc(length); + prop_packet.payload = mosquitto_malloc(length); if(!prop_packet.payload){ errno = ENOMEM; goto error; @@ -133,9 +132,9 @@ int persist__chunk_client_msg_read_v56(FILE *db_fptr, struct P_client_msg *chunk read_e(db_fptr, prop_packet.payload, length); rc = property__read_all(CMD_PUBLISH, &prop_packet, &properties); - mosquitto__FREE(prop_packet.payload); + mosquitto_FREE(prop_packet.payload); if(rc){ - mosquitto__FREE(chunk->clientid); + mosquitto_FREE(chunk->clientid); return rc; } @@ -153,8 +152,8 @@ int persist__chunk_client_msg_read_v56(FILE *db_fptr, struct P_client_msg *chunk return MOSQ_ERR_SUCCESS; error: - mosquitto__FREE(chunk->clientid); - mosquitto__FREE(prop_packet.payload); + mosquitto_FREE(chunk->clientid); + mosquitto_FREE(prop_packet.payload); log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno)); return 1; } @@ -194,7 +193,7 @@ int persist__chunk_base_msg_read_v56(FILE *db_fptr, struct P_base_msg *chunk, ui if(rc) goto error; if(chunk->F.payloadlen > 0){ - chunk->payload = mosquitto__malloc(chunk->F.payloadlen+1); + chunk->payload = mosquitto_malloc(chunk->F.payloadlen+1); if(chunk->payload == NULL){ rc = MOSQ_ERR_NOMEM; goto error; @@ -206,14 +205,14 @@ int persist__chunk_base_msg_read_v56(FILE *db_fptr, struct P_base_msg *chunk, ui if(length > 0){ prop_packet.remaining_length = length; - prop_packet.payload = mosquitto__malloc(length); + prop_packet.payload = mosquitto_malloc(length); if(!prop_packet.payload){ rc = MOSQ_ERR_NOMEM; goto error; } read_e(db_fptr, prop_packet.payload, length); rc = property__read_all(CMD_PUBLISH, &prop_packet, &properties); - mosquitto__FREE(prop_packet.payload); + mosquitto_FREE(prop_packet.payload); if(rc){ rc = MOSQ_ERR_NOMEM; goto error; @@ -223,11 +222,11 @@ int persist__chunk_base_msg_read_v56(FILE *db_fptr, struct P_base_msg *chunk, ui return MOSQ_ERR_SUCCESS; error: - mosquitto__FREE(chunk->payload); - mosquitto__FREE(chunk->source.id); - mosquitto__FREE(chunk->source.username); - mosquitto__FREE(chunk->topic); - mosquitto__FREE(prop_packet.payload); + mosquitto_FREE(chunk->payload); + mosquitto_FREE(chunk->source.id); + mosquitto_FREE(chunk->source.username); + mosquitto_FREE(chunk->topic); + mosquitto_FREE(prop_packet.payload); return rc; } @@ -259,7 +258,7 @@ int persist__chunk_sub_read_v56(FILE *db_fptr, struct P_sub *chunk) return MOSQ_ERR_SUCCESS; error: - mosquitto__FREE(chunk->clientid); + mosquitto_FREE(chunk->clientid); return rc; } diff --git a/src/persist_write.c b/src/persist_write.c index ea088a36..e2a18882 100644 --- a/src/persist_write.c +++ b/src/persist_write.c @@ -32,7 +32,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "persist.h" #include "misc_mosq.h" #include "util_mosq.h" @@ -221,7 +220,7 @@ static int persist__subs_save(FILE *db_fptr, struct mosquitto__subhier *node, co int rc; slen = strlen(topic) + node->topic_len + 2; - thistopic = mosquitto__malloc(sizeof(char)*slen); + thistopic = mosquitto_malloc(sizeof(char)*slen); if(!thistopic) return MOSQ_ERR_NOMEM; if(level > 1 || strlen(topic)){ snprintf(thistopic, slen, "%s/%s", topic, node->topic); @@ -244,7 +243,7 @@ static int persist__subs_save(FILE *db_fptr, struct mosquitto__subhier *node, co rc = persist__chunk_sub_write_v6(db_fptr, &sub_chunk); if(rc){ - mosquitto__FREE(thistopic); + mosquitto_FREE(thistopic); return rc; } } @@ -254,7 +253,7 @@ static int persist__subs_save(FILE *db_fptr, struct mosquitto__subhier *node, co HASH_ITER(hh, node->children, subhier, subhier_tmp){ persist__subs_save(db_fptr, subhier, thistopic, level+1); } - mosquitto__FREE(thistopic); + mosquitto_FREE(thistopic); return MOSQ_ERR_SUCCESS; } diff --git a/src/persist_write_v5.c b/src/persist_write_v5.c index 0c2aa6cc..be878e53 100644 --- a/src/persist_write_v5.c +++ b/src/persist_write_v5.c @@ -32,7 +32,6 @@ Contributors: #include "mosquitto/mqtt_protocol.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "persist.h" #include "packet_mosq.h" #include "property_mosq.h" @@ -123,14 +122,14 @@ int persist__chunk_client_msg_write_v6(FILE *db_fptr, struct P_client_msg *chunk } write_e(db_fptr, prop_packet->payload, proplen); - mosquitto__FREE(prop_packet); + mosquitto_FREE(prop_packet); } } return MOSQ_ERR_SUCCESS; error: log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno)); - mosquitto__FREE(prop_packet); + mosquitto_FREE(prop_packet); return 1; } diff --git a/src/plugin_acl_check.c b/src/plugin_acl_check.c index 0d2ea849..7525abed 100644 --- a/src/plugin_acl_check.c +++ b/src/plugin_acl_check.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_basic_auth.c b/src/plugin_basic_auth.c index 76186732..da12bdd4 100644 --- a/src/plugin_basic_auth.c +++ b/src/plugin_basic_auth.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_callbacks.c b/src/plugin_callbacks.c index 90c6332f..d88824d1 100644 --- a/src/plugin_callbacks.c +++ b/src/plugin_callbacks.c @@ -19,7 +19,6 @@ Contributors: #include "config.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "utlist.h" #include "lib_load.h" @@ -181,14 +180,14 @@ static int remove_callback(mosquitto_plugin_id_t *plugin, struct plugin_own_call DL_FOREACH_SAFE(*cb_base, tail, tmp){ if(tail->cb == own->cb_func){ DL_DELETE(*cb_base, tail); - mosquitto__FREE(tail); + mosquitto_FREE(tail); break; } } } DL_DELETE(plugin->own_callbacks, own); - mosquitto__FREE(own); + mosquitto_FREE(own); return MOSQ_ERR_SUCCESS; } @@ -211,7 +210,7 @@ BROKER_EXPORT int mosquitto_callback_register( return control__register_callback(identifier, cb_func, event_data, userdata); } - own_callback = mosquitto__calloc(1, sizeof(struct plugin_own_callback)); + own_callback = mosquitto_calloc(1, sizeof(struct plugin_own_callback)); if(own_callback == NULL){ return MOSQ_ERR_NOMEM; } @@ -237,10 +236,10 @@ BROKER_EXPORT int mosquitto_callback_register( return MOSQ_ERR_ALREADY_EXISTS; } - cb_new = mosquitto__calloc(1, sizeof(struct mosquitto__callback)); + cb_new = mosquitto_calloc(1, sizeof(struct mosquitto__callback)); if(cb_new == NULL){ DL_DELETE(identifier->own_callbacks, own_callback); - mosquitto__FREE(own_callback); + mosquitto_FREE(own_callback); return MOSQ_ERR_NOMEM; } diff --git a/src/plugin_cleanup.c b/src/plugin_cleanup.c index 765ea3da..15293f11 100644 --- a/src/plugin_cleanup.c +++ b/src/plugin_cleanup.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" @@ -62,11 +61,11 @@ static void plugin__unload_single(mosquitto_plugin_id_t *plugin) } plugin__callback_unregister_all(plugin); - mosquitto__FREE(plugin->plugin_name); - mosquitto__FREE(plugin->plugin_version); + mosquitto_FREE(plugin->plugin_name); + mosquitto_FREE(plugin->plugin_version); DL_FOREACH_SAFE(plugin->control_endpoints, ep, tmp){ DL_DELETE(plugin->control_endpoints, ep); - mosquitto__FREE(ep); + mosquitto_FREE(ep); } if(plugin->lib.lib){ diff --git a/src/plugin_extended_auth.c b/src/plugin_extended_auth.c index bdca9a67..3ade9a7a 100644 --- a/src/plugin_extended_auth.c +++ b/src/plugin_extended_auth.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_init.c b/src/plugin_init.c index 5ebf2881..efdcafc7 100644 --- a/src/plugin_init.c +++ b/src/plugin_init.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_message.c b/src/plugin_message.c index 4c7a0b59..cea60aa4 100644 --- a/src/plugin_message.c +++ b/src/plugin_message.c @@ -19,7 +19,6 @@ Contributors: #include "config.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "utlist.h" struct should_free { @@ -50,13 +49,13 @@ static int plugin__handle_message_single(struct mosquitto__callback *callbacks, } if(stored->topic != event_data.topic){ - if(to_free->topic) mosquitto__FREE(stored->topic); + if(to_free->topic) mosquitto_FREE(stored->topic); stored->topic = event_data.topic; to_free->topic = true; } if(stored->payload != event_data.payload){ - if(to_free->payload) mosquitto__FREE(stored->payload); + if(to_free->payload) mosquitto_FREE(stored->payload); stored->payload = event_data.payload; stored->payloadlen = event_data.payloadlen; to_free->payload = true; diff --git a/src/plugin_persist.c b/src/plugin_persist.c index fd21233e..76937269 100644 --- a/src/plugin_persist.c +++ b/src/plugin_persist.c @@ -21,7 +21,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto_internal.h" #include "mosquitto/broker.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "send_mosq.h" #include "util_mosq.h" diff --git a/src/plugin_psk_key.c b/src/plugin_psk_key.c index 306338d3..24275f97 100644 --- a/src/plugin_psk_key.c +++ b/src/plugin_psk_key.c @@ -24,7 +24,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_public.c b/src/plugin_public.c index 94c3e7c7..5431d810 100644 --- a/src/plugin_public.c +++ b/src/plugin_public.c @@ -19,7 +19,6 @@ Contributors: #include "config.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "send_mosq.h" #include "util_mosq.h" @@ -215,24 +214,24 @@ BROKER_EXPORT int mosquitto_broker_publish( return MOSQ_ERR_INVAL; } - msg = mosquitto__malloc(sizeof(struct mosquitto__message_v5)); + msg = mosquitto_malloc(sizeof(struct mosquitto__message_v5)); if(msg == NULL) return MOSQ_ERR_NOMEM; msg->next = NULL; msg->prev = NULL; if(clientid){ - msg->clientid = mosquitto__strdup(clientid); + msg->clientid = mosquitto_strdup(clientid); if(msg->clientid == NULL){ - mosquitto__FREE(msg); + mosquitto_FREE(msg); return MOSQ_ERR_NOMEM; } }else{ msg->clientid = NULL; } - msg->topic = mosquitto__strdup(topic); + msg->topic = mosquitto_strdup(topic); if(msg->topic == NULL){ - mosquitto__FREE(msg->clientid); - mosquitto__FREE(msg); + mosquitto_FREE(msg->clientid); + mosquitto_FREE(msg); return MOSQ_ERR_NOMEM; } msg->payloadlen = payloadlen; @@ -302,7 +301,7 @@ BROKER_EXPORT int mosquitto_set_username(struct mosquitto *client, const char *u if(mosquitto_validate_utf8(username, (int)strlen(username))){ return MOSQ_ERR_MALFORMED_UTF8; } - u_dup = mosquitto__strdup(username); + u_dup = mosquitto_strdup(username); if(!u_dup) return MOSQ_ERR_NOMEM; }else{ u_dup = NULL; @@ -314,10 +313,10 @@ BROKER_EXPORT int mosquitto_set_username(struct mosquitto *client, const char *u rc = acl__find_acls(client); if(rc){ client->username = old; - mosquitto__FREE(u_dup); + mosquitto_FREE(u_dup); return rc; }else{ - mosquitto__FREE(old); + mosquitto_FREE(old); return MOSQ_ERR_SUCCESS; } } @@ -353,13 +352,13 @@ BROKER_EXPORT int mosquitto_set_clientid(struct mosquitto *client, const char *c return MOSQ_ERR_INVAL; } - id_dup = mosquitto__strdup(clientid); + id_dup = mosquitto_strdup(clientid); if(!id_dup) return MOSQ_ERR_NOMEM; if(in_by_id){ context__remove_from_by_id(client); } - mosquitto__free(client->id); + mosquitto_free(client->id); client->id = id_dup; if(in_by_id){ context__add_to_by_id(client); diff --git a/src/plugin_subscribe.c b/src/plugin_subscribe.c index 09ae2cb2..de61103c 100644 --- a/src/plugin_subscribe.c +++ b/src/plugin_subscribe.c @@ -20,7 +20,6 @@ Contributors: #include "config.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "utlist.h" @@ -44,7 +43,7 @@ static int plugin__handle_subscribe_single(struct mosquitto__security_options *o } if(sub->topic_filter != event_data.data.topic_filter){ - mosquitto__free(sub->topic_filter); + mosquitto_free(sub->topic_filter); sub->topic_filter = event_data.data.topic_filter; } } diff --git a/src/plugin_unsubscribe.c b/src/plugin_unsubscribe.c index 12ae6cca..5faaf521 100644 --- a/src/plugin_unsubscribe.c +++ b/src/plugin_unsubscribe.c @@ -20,7 +20,6 @@ Contributors: #include "config.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "utlist.h" @@ -42,7 +41,7 @@ static int plugin__handle_unsubscribe_single(struct mosquitto__security_options } if(sub->topic_filter != event_data.data.topic_filter){ - mosquitto__free(sub->topic_filter); + mosquitto_free(sub->topic_filter); sub->topic_filter = event_data.data.topic_filter; } } diff --git a/src/plugin_v2.c b/src/plugin_v2.c index 570775c0..2ae68808 100644 --- a/src/plugin_v2.c +++ b/src/plugin_v2.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_v3.c b/src/plugin_v3.c index da63deb6..24b55352 100644 --- a/src/plugin_v3.c +++ b/src/plugin_v3.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_v4.c b/src/plugin_v4.c index 96c69fc6..b8d817ab 100644 --- a/src/plugin_v4.c +++ b/src/plugin_v4.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto/broker.h" #include "mosquitto_broker_internal.h" #include "mosquitto/broker_plugin.h" -#include "memory_mosq.h" #include "lib_load.h" #include "utlist.h" diff --git a/src/plugin_v5.c b/src/plugin_v5.c index c2386e89..7d18d0d9 100644 --- a/src/plugin_v5.c +++ b/src/plugin_v5.c @@ -19,7 +19,6 @@ Contributors: #include "config.h" #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "utlist.h" #include "lib_load.h" diff --git a/src/read_handle.c b/src/read_handle.c index 5574b946..f368d268 100644 --- a/src/read_handle.c +++ b/src/read_handle.c @@ -23,7 +23,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "read_handle.h" #include "send_mosq.h" diff --git a/src/retain.c b/src/retain.c index 66bb37d6..6ed18929 100644 --- a/src/retain.c +++ b/src/retain.c @@ -23,7 +23,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "util_mosq.h" @@ -35,7 +34,7 @@ static struct mosquitto__retainhier *retain__add_hier_entry(struct mosquitto__re assert(sibling); - child = mosquitto__calloc(1, sizeof(struct mosquitto__retainhier) + len + 1); + child = mosquitto_calloc(1, sizeof(struct mosquitto__retainhier) + len + 1); if(!child){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return NULL; @@ -77,8 +76,8 @@ BROKER_EXPORT int mosquitto_persist_retain_msg_set(const char *topic, uint64_t b if(sub__topic_tokenise(topic, &local_topic, &split_topics, NULL)) return MOSQ_ERR_NOMEM; rc = retain__store(topic, base_msg, split_topics, false); - mosquitto__free(split_topics); - mosquitto__free(local_topic); + mosquitto_free(split_topics); + mosquitto_free(local_topic); } return rc; @@ -102,8 +101,8 @@ BROKER_EXPORT int mosquitto_persist_retain_msg_delete(const char *topic) /* With stored->payloadlen == 0, this means the message will be removed */ rc = retain__store(topic, &base_msg, split_topics, false); - mosquitto__FREE(split_topics); - mosquitto__FREE(local_topic); + mosquitto_FREE(split_topics); + mosquitto_FREE(local_topic); return rc; } @@ -119,7 +118,7 @@ void retain__clean_empty_hierarchy(struct mosquitto__retainhier *retainhier) HASH_DELETE(hh, retainhier->parent->children, retainhier); struct mosquitto__retainhier *parent = retainhier->parent; - mosquitto__FREE(retainhier); + mosquitto_FREE(retainhier); retainhier = parent; } } @@ -338,8 +337,8 @@ int retain__queue(struct mosquitto *context, const struct mosquitto_subscription if(retainhier){ retain__search(retainhier, split_topics, context, sub, 0); } - mosquitto__FREE(local_sub); - mosquitto__FREE(split_topics); + mosquitto_FREE(local_sub); + mosquitto_FREE(split_topics); return MOSQ_ERR_SUCCESS; } @@ -356,7 +355,7 @@ void retain__clean(struct mosquitto__retainhier **retainhier) retain__clean(&peer->children); HASH_DELETE(hh, *retainhier, peer); - mosquitto__FREE(peer); + mosquitto_FREE(peer); } } diff --git a/src/security_default.c b/src/security_default.c index e4ae4d97..3faba8f2 100644 --- a/src/security_default.c +++ b/src/security_default.c @@ -23,7 +23,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "send_mosq.h" #include "base64_mosq.h" @@ -50,22 +49,22 @@ int mosquitto_security_init_default(bool reload) /* Configure plugin identifier */ if(db.config->per_listener_settings){ for(int i=0; ilistener_count; i++){ - db.config->listeners[i].security_options->pid = mosquitto__calloc(1, sizeof(mosquitto_plugin_id_t)); + db.config->listeners[i].security_options->pid = mosquitto_calloc(1, sizeof(mosquitto_plugin_id_t)); if(db.config->listeners[i].security_options->pid == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } - db.config->listeners[i].security_options->pid->plugin_name = mosquitto__strdup("builtin-security"); + db.config->listeners[i].security_options->pid->plugin_name = mosquitto_strdup("builtin-security"); db.config->listeners[i].security_options->pid->listener = &db.config->listeners[i]; config__plugin_add_secopt(db.config->listeners[i].security_options->pid, db.config->listeners[i].security_options); } }else{ - db.config->security_options.pid = mosquitto__calloc(1, sizeof(mosquitto_plugin_id_t)); + db.config->security_options.pid = mosquitto_calloc(1, sizeof(mosquitto_plugin_id_t)); if(db.config->security_options.pid == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } - db.config->security_options.pid->plugin_name = mosquitto__strdup("builtin-security"); + db.config->security_options.pid->plugin_name = mosquitto_strdup("builtin-security"); config__plugin_add_secopt(db.config->security_options.pid, &db.config->security_options); } @@ -192,9 +191,9 @@ int mosquitto_security_cleanup_default(bool reload) mosquitto_callback_unregister(db.config->listeners[i].security_options->pid, MOSQ_EVT_ACL_CHECK, mosquitto_acl_check_default, NULL); - mosquitto__FREE(db.config->listeners[i].security_options->pid->plugin_name); - mosquitto__FREE(db.config->listeners[i].security_options->pid->config.security_options); - mosquitto__FREE(db.config->listeners[i].security_options->pid); + mosquitto_FREE(db.config->listeners[i].security_options->pid->plugin_name); + mosquitto_FREE(db.config->listeners[i].security_options->pid->config.security_options); + mosquitto_FREE(db.config->listeners[i].security_options->pid); } } }else{ @@ -204,9 +203,9 @@ int mosquitto_security_cleanup_default(bool reload) mosquitto_callback_unregister(db.config->security_options.pid, MOSQ_EVT_ACL_CHECK, mosquitto_acl_check_default, NULL); - mosquitto__FREE(db.config->security_options.pid->plugin_name); - mosquitto__FREE(db.config->security_options.pid->config.security_options); - mosquitto__FREE(db.config->security_options.pid); + mosquitto_FREE(db.config->security_options.pid->plugin_name); + mosquitto_FREE(db.config->security_options.pid->config.security_options); + mosquitto_FREE(db.config->security_options.pid); } } return MOSQ_ERR_SUCCESS; @@ -222,7 +221,7 @@ static int add__acl(struct mosquitto__security_options *security_opts, const cha if(!security_opts || !topic) return MOSQ_ERR_INVAL; - local_topic = mosquitto__strdup(topic); + local_topic = mosquitto_strdup(topic); if(!local_topic){ return MOSQ_ERR_NOMEM; } @@ -243,17 +242,17 @@ static int add__acl(struct mosquitto__security_options *security_opts, const cha } } if(!acl_user){ - acl_user = mosquitto__malloc(sizeof(struct mosquitto__acl_user)); + acl_user = mosquitto_malloc(sizeof(struct mosquitto__acl_user)); if(!acl_user){ - mosquitto__FREE(local_topic); + mosquitto_FREE(local_topic); return MOSQ_ERR_NOMEM; } new_user = true; if(user){ - acl_user->username = mosquitto__strdup(user); + acl_user->username = mosquitto_strdup(user); if(!acl_user->username){ - mosquitto__FREE(local_topic); - mosquitto__FREE(acl_user); + mosquitto_FREE(local_topic); + mosquitto_FREE(acl_user); return MOSQ_ERR_NOMEM; } }else{ @@ -263,11 +262,11 @@ static int add__acl(struct mosquitto__security_options *security_opts, const cha acl_user->acl = NULL; } - acl = mosquitto__malloc(sizeof(struct mosquitto__acl)); + acl = mosquitto_malloc(sizeof(struct mosquitto__acl)); if(!acl){ - mosquitto__FREE(local_topic); - mosquitto__FREE(acl_user->username); - mosquitto__FREE(acl_user); + mosquitto_FREE(local_topic); + mosquitto_FREE(acl_user->username); + mosquitto_FREE(acl_user); return MOSQ_ERR_NOMEM; } acl->access = access; @@ -317,14 +316,14 @@ static int add__acl_pattern(struct mosquitto__security_options *security_opts, c if(!security_opts| !topic) return MOSQ_ERR_INVAL; - local_topic = mosquitto__strdup(topic); + local_topic = mosquitto_strdup(topic); if(!local_topic){ return MOSQ_ERR_NOMEM; } - acl = mosquitto__malloc(sizeof(struct mosquitto__acl)); + acl = mosquitto_malloc(sizeof(struct mosquitto__acl)); if(!acl){ - mosquitto__FREE(local_topic); + mosquitto_FREE(local_topic); return MOSQ_ERR_NOMEM; } acl->access = access; @@ -500,7 +499,7 @@ static int aclfile__parse(struct mosquitto__security_options *security_opts) if(!security_opts) return MOSQ_ERR_INVAL; if(!security_opts->acl_file) return MOSQ_ERR_SUCCESS; - buf = mosquitto__malloc((size_t)buflen); + buf = mosquitto_malloc((size_t)buflen); if(buf == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -508,7 +507,7 @@ static int aclfile__parse(struct mosquitto__security_options *security_opts) aclfptr = mosquitto__fopen(security_opts->acl_file, "rt", true); if(!aclfptr){ - mosquitto__FREE(buf); + mosquitto_FREE(buf); log__printf(NULL, MOSQ_LOG_ERR, "Error: Unable to open acl_file \"%s\".", security_opts->acl_file); return MOSQ_ERR_UNKNOWN; } @@ -589,8 +588,8 @@ static int aclfile__parse(struct mosquitto__security_options *security_opts) rc = MOSQ_ERR_INVAL; break; } - mosquitto__FREE(user); - user = mosquitto__strdup(token); + mosquitto_FREE(user); + user = mosquitto_strdup(token); if(!user){ rc = MOSQ_ERR_NOMEM; break; @@ -608,8 +607,8 @@ static int aclfile__parse(struct mosquitto__security_options *security_opts) } } - mosquitto__FREE(buf); - mosquitto__FREE(user); + mosquitto_FREE(buf); + mosquitto_FREE(user); fclose(aclfptr); return rc; @@ -622,8 +621,8 @@ static void free__acl(struct mosquitto__acl *acl) if(acl->next){ free__acl(acl->next); } - mosquitto__FREE(acl->topic); - mosquitto__FREE(acl); + mosquitto_FREE(acl->topic); + mosquitto_FREE(acl); } @@ -635,8 +634,8 @@ static void acl__cleanup_single(struct mosquitto__security_options *security_opt user_tail = security_opts->acl_list->next; free__acl(security_opts->acl_list->acl); - mosquitto__FREE(security_opts->acl_list->username); - mosquitto__FREE(security_opts->acl_list); + mosquitto_FREE(security_opts->acl_list->username); + mosquitto_FREE(security_opts->acl_list); security_opts->acl_list = user_tail; } @@ -724,7 +723,7 @@ static int pwfile__parse(const char *file, struct mosquitto__unpwd **root) char *buf; int buflen = 256; - buf = mosquitto__malloc((size_t)buflen); + buf = mosquitto_malloc((size_t)buflen); if(buf == NULL){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; @@ -733,7 +732,7 @@ static int pwfile__parse(const char *file, struct mosquitto__unpwd **root) pwfile = mosquitto__fopen(file, "rt", true); if(!pwfile){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Unable to open pwfile \"%s\".", file); - mosquitto__FREE(buf); + mosquitto_FREE(buf); return MOSQ_ERR_UNKNOWN; } @@ -744,23 +743,23 @@ static int pwfile__parse(const char *file, struct mosquitto__unpwd **root) username = strtok_r(buf, ":", &saveptr); if(username){ - unpwd = mosquitto__calloc(1, sizeof(struct mosquitto__unpwd)); + unpwd = mosquitto_calloc(1, sizeof(struct mosquitto__unpwd)); if(!unpwd){ fclose(pwfile); - mosquitto__FREE(buf); + mosquitto_FREE(buf); return MOSQ_ERR_NOMEM; } username = misc__trimblanks(username); if(strlen(username) > 65535){ log__printf(NULL, MOSQ_LOG_NOTICE, "Warning: Invalid line in password file '%s', username too long.", file); - mosquitto__FREE(unpwd); + mosquitto_FREE(unpwd); continue; } - unpwd->username = mosquitto__strdup(username); + unpwd->username = mosquitto_strdup(username); if(!unpwd->username){ - mosquitto__FREE(unpwd); - mosquitto__FREE(buf); + mosquitto_FREE(unpwd); + mosquitto_FREE(buf); fclose(pwfile); return MOSQ_ERR_NOMEM; } @@ -770,31 +769,31 @@ static int pwfile__parse(const char *file, struct mosquitto__unpwd **root) if(strlen(password) > 65535){ log__printf(NULL, MOSQ_LOG_NOTICE, "Warning: Invalid line in password file '%s', password too long.", file); - mosquitto__FREE(unpwd->username); - mosquitto__FREE(unpwd); + mosquitto_FREE(unpwd->username); + mosquitto_FREE(unpwd); continue; } - unpwd->pw.encoded_password = mosquitto__strdup(password); + unpwd->pw.encoded_password = mosquitto_strdup(password); if(!unpwd->pw.encoded_password){ fclose(pwfile); - mosquitto__FREE(unpwd->username); - mosquitto__FREE(unpwd); - mosquitto__FREE(buf); + mosquitto_FREE(unpwd->username); + mosquitto_FREE(unpwd); + mosquitto_FREE(buf); return MOSQ_ERR_NOMEM; } HASH_ADD_KEYPTR(hh, *root, unpwd->username, strlen(unpwd->username), unpwd); }else{ log__printf(NULL, MOSQ_LOG_NOTICE, "Warning: Invalid line in password file '%s': %s", file, buf); - mosquitto__FREE(unpwd->username); - mosquitto__FREE(unpwd); + mosquitto_FREE(unpwd->username); + mosquitto_FREE(unpwd); } } } } fclose(pwfile); - mosquitto__FREE(buf); + mosquitto_FREE(buf); return MOSQ_ERR_SUCCESS; } @@ -802,10 +801,10 @@ static int pwfile__parse(const char *file, struct mosquitto__unpwd **root) void unpwd__free_item(struct mosquitto__unpwd **unpwd, struct mosquitto__unpwd *item) { - mosquitto__FREE(item->username); - mosquitto__FREE(item->pw.encoded_password); + mosquitto_FREE(item->username); + mosquitto_FREE(item->pw.encoded_password); HASH_DEL(*unpwd, item); - mosquitto__FREE(item); + mosquitto_FREE(item); } @@ -927,9 +926,9 @@ static int unpwd__cleanup(struct mosquitto__unpwd **root, bool reload) HASH_ITER(hh, *root, u, tmp){ HASH_DEL(*root, u); - mosquitto__FREE(u->pw.encoded_password); - mosquitto__FREE(u->username); - mosquitto__FREE(u); + mosquitto_FREE(u->pw.encoded_password); + mosquitto_FREE(u->username); + mosquitto_FREE(u); } *root = NULL; @@ -1033,8 +1032,8 @@ int mosquitto_security_apply_default(void) #endif /* FINAL_WITH_TLS_PSK */ { /* Free existing credentials and then recover them. */ - mosquitto__FREE(context->username); - mosquitto__FREE(context->password); + mosquitto_FREE(context->username); + mosquitto_FREE(context->password); X509 *client_cert = SSL_get_peer_certificate(context->ssl); if(!client_cert){ @@ -1062,7 +1061,7 @@ int mosquitto_security_apply_default(void) security__disconnect_auth(context); continue; } - context->username = mosquitto__strdup((char *) ASN1_STRING_get0_data(name_asn1)); + context->username = mosquitto_strdup((char *) ASN1_STRING_get0_data(name_asn1)); if(!context->username){ X509_free(client_cert); security__disconnect_auth(context); @@ -1080,7 +1079,7 @@ int mosquitto_security_apply_default(void) X509_NAME_print_ex(subject_bio, X509_get_subject_name(client_cert), 0, XN_FLAG_RFC2253); data_start = NULL; name_length = (size_t)BIO_get_mem_data(subject_bio, &data_start); - subject = mosquitto__malloc(sizeof(char)*name_length+1); + subject = mosquitto_malloc(sizeof(char)*name_length+1); if(!subject){ BIO_free(subject_bio); X509_free(client_cert); diff --git a/src/send_auth.c b/src/send_auth.c index 6bfdc1b7..e58a8781 100644 --- a/src/send_auth.c +++ b/src/send_auth.c @@ -20,7 +20,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "sys_tree.h" diff --git a/src/send_connack.c b/src/send_connack.c index c336e0c0..4c78a2f0 100644 --- a/src/send_connack.c +++ b/src/send_connack.c @@ -20,7 +20,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "sys_tree.h" diff --git a/src/send_suback.c b/src/send_suback.c index 80430ebb..2e7444ab 100644 --- a/src/send_suback.c +++ b/src/send_suback.c @@ -20,7 +20,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "sys_tree.h" diff --git a/src/send_unsuback.c b/src/send_unsuback.c index bd56f9b7..65e86d89 100644 --- a/src/send_unsuback.c +++ b/src/send_unsuback.c @@ -22,7 +22,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "property_mosq.h" #include "sys_tree.h" diff --git a/src/service.c b/src/service.c index 83abb212..f38d284a 100644 --- a/src/service.c +++ b/src/service.c @@ -22,7 +22,6 @@ Contributors: #include "mosquitto_broker_internal.h" #include -#include "memory_mosq.h" extern int g_run; SERVICE_STATUS_HANDLE service_handle = 0; @@ -115,7 +114,7 @@ void __stdcall service_main(DWORD dwArgc, LPTSTR *lpszArgv) } strcat(conf_path, "\\mosquitto.conf"); - argv = mosquitto__malloc(sizeof(char *)*3); + argv = mosquitto_malloc(sizeof(char *)*3); argv[0] = name; argv[1] = "-c"; argv[2] = conf_path; @@ -129,7 +128,7 @@ void __stdcall service_main(DWORD dwArgc, LPTSTR *lpszArgv) SetServiceStatus(service_handle, &service_status); main(argc, argv); - mosquitto__FREE(argv); + mosquitto_FREE(argv); service_status.dwCurrentState = SERVICE_STOPPED; SetServiceStatus(service_handle, &service_status); diff --git a/src/session_expiry.c b/src/session_expiry.c index 4cb9e436..c8697beb 100644 --- a/src/session_expiry.c +++ b/src/session_expiry.c @@ -23,7 +23,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "sys_tree.h" static struct session_expiry_list *expiry_list = NULL; @@ -74,7 +73,7 @@ int session_expiry__add(struct mosquitto *context) } } - item = mosquitto__calloc(1, sizeof(struct session_expiry_list)); + item = mosquitto_calloc(1, sizeof(struct session_expiry_list)); if(!item) return MOSQ_ERR_NOMEM; item->context = context; @@ -101,7 +100,7 @@ int session_expiry__add_from_persistence(struct mosquitto *context, time_t expir } } - item = mosquitto__calloc(1, sizeof(struct session_expiry_list)); + item = mosquitto_calloc(1, sizeof(struct session_expiry_list)); if(!item) return MOSQ_ERR_NOMEM; item->context = context; @@ -123,7 +122,7 @@ void session_expiry__remove(struct mosquitto *context) { if(context->expiry_list_item){ DL_DELETE(expiry_list, context->expiry_list_item); - mosquitto__FREE(context->expiry_list_item); + mosquitto_FREE(context->expiry_list_item); } } diff --git a/src/subs.c b/src/subs.c index 7f7e19b0..29c6f507 100644 --- a/src/subs.c +++ b/src/subs.c @@ -54,7 +54,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "util_mosq.h" @@ -168,7 +167,7 @@ static int sub__add_leaf(struct mosquitto *context, const struct mosquitto_subsc } leaf = leaf->next; } - leaf = mosquitto__calloc(1, sizeof(struct mosquitto__subleaf) + strlen(sub->topic_filter) + 1); + leaf = mosquitto_calloc(1, sizeof(struct mosquitto__subleaf) + strlen(sub->topic_filter) + 1); if(!leaf) return MOSQ_ERR_NOMEM; leaf->context = context; leaf->identifier = sub->identifier; @@ -187,7 +186,7 @@ static void sub__remove_shared_leaf(struct mosquitto__subhier *subhier, struct m DL_DELETE(shared->subs, leaf); if(shared->subs == NULL){ HASH_DELETE(hh, subhier->shared, shared); - mosquitto__FREE(shared); + mosquitto_FREE(shared); } } @@ -204,7 +203,7 @@ static int sub__add_shared(struct mosquitto *context, const struct mosquitto_sub HASH_FIND(hh, subhier->shared, sharename, slen, shared); if(shared == NULL){ - shared = mosquitto__calloc(1, sizeof(struct mosquitto__subshared) + slen + 1); + shared = mosquitto_calloc(1, sizeof(struct mosquitto__subshared) + slen + 1); if(!shared){ return MOSQ_ERR_NOMEM; } @@ -217,7 +216,7 @@ static int sub__add_shared(struct mosquitto *context, const struct mosquitto_sub if(rc > 0){ if(shared->subs == NULL){ HASH_DELETE(hh, subhier->shared, shared); - mosquitto__FREE(shared); + mosquitto_FREE(shared); } return rc; } @@ -236,10 +235,10 @@ static int sub__add_shared(struct mosquitto *context, const struct mosquitto_sub } } if(assigned == false){ - subs = mosquitto__realloc(context->subs, sizeof(struct mosquitto__subleaf *)*(size_t)(context->subs_capacity + 1)); + subs = mosquitto_realloc(context->subs, sizeof(struct mosquitto__subleaf *)*(size_t)(context->subs_capacity + 1)); if(!subs){ sub__remove_shared_leaf(subhier, shared, newleaf); - mosquitto__FREE(newleaf); + mosquitto_FREE(newleaf); return MOSQ_ERR_NOMEM; } context->subs = subs; @@ -287,10 +286,10 @@ static int sub__add_normal(struct mosquitto *context, const struct mosquitto_sub } } if(assigned == false){ - subs = mosquitto__realloc(context->subs, sizeof(struct mosquitto__subleaf *)*(size_t)(context->subs_capacity + 1)); + subs = mosquitto_realloc(context->subs, sizeof(struct mosquitto__subleaf *)*(size_t)(context->subs_capacity + 1)); if(!subs){ DL_DELETE(subhier->subs, newleaf); - mosquitto__FREE(newleaf); + mosquitto_FREE(newleaf); return MOSQ_ERR_NOMEM; } context->subs = subs; @@ -367,7 +366,7 @@ static int sub__remove_normal(struct mosquitto *context, struct mosquitto__subhi for(int i=0; isubs_capacity; i++){ if(context->subs[i] && context->subs[i]->hier == subhier){ context->subs_count--; - mosquitto__free(context->subs[i]); + mosquitto_free(context->subs[i]); context->subs[i] = NULL; break; } @@ -404,7 +403,7 @@ static int sub__remove_shared(struct mosquitto *context, struct mosquitto__subhi && context->subs[i]->hier == subhier && context->subs[i]->shared == shared){ - mosquitto__free(context->subs[i]); + mosquitto_free(context->subs[i]); context->subs[i] = NULL; context->subs_count--; break; @@ -413,7 +412,7 @@ static int sub__remove_shared(struct mosquitto *context, struct mosquitto__subhi if(shared->subs == NULL){ HASH_DELETE(hh, subhier->shared, shared); - mosquitto__FREE(shared); + mosquitto_FREE(shared); } *reason = 0; @@ -445,7 +444,7 @@ static int sub__remove_recurse(struct mosquitto *context, struct mosquitto__subh sub__remove_recurse(context, branch, &(topics[1]), reason, sharename); if(!branch->children && !branch->subs && !branch->shared){ HASH_DELETE(hh, subhier->children, branch); - mosquitto__FREE(branch); + mosquitto_FREE(branch); } } return MOSQ_ERR_SUCCESS; @@ -530,7 +529,7 @@ struct mosquitto__subhier *sub__add_hier_entry(struct mosquitto__subhier *parent assert(sibling); - child = mosquitto__calloc(1, sizeof(struct mosquitto__subhier) + len + 1); + child = mosquitto_calloc(1, sizeof(struct mosquitto__subhier) + len + 1); if(!child){ log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return NULL; @@ -562,16 +561,16 @@ int sub__add(struct mosquitto *context, const struct mosquitto_subscription *sub topiclen = strlen(topics[0]); if(topiclen > UINT16_MAX){ - mosquitto__FREE(local_sub); - mosquitto__FREE(topics); + mosquitto_FREE(local_sub); + mosquitto_FREE(topics); return MOSQ_ERR_INVAL; } HASH_FIND(hh, db.subs, topics[0], topiclen, subhier); if(!subhier){ subhier = sub__add_hier_entry(NULL, &db.subs, topics[0], (uint16_t)topiclen); if(!subhier){ - mosquitto__FREE(local_sub); - mosquitto__FREE(topics); + mosquitto_FREE(local_sub); + mosquitto_FREE(topics); log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } @@ -579,8 +578,8 @@ int sub__add(struct mosquitto *context, const struct mosquitto_subscription *sub } rc = sub__add_context(context, sub, subhier, topics, sharename); - mosquitto__FREE(local_sub); - mosquitto__FREE(topics); + mosquitto_FREE(local_sub); + mosquitto_FREE(topics); return rc; } @@ -604,8 +603,8 @@ int sub__remove(struct mosquitto *context, const char *sub, uint8_t *reason) rc = sub__remove_recurse(context, subhier, topics, reason, sharename); } - mosquitto__FREE(local_sub); - mosquitto__FREE(topics); + mosquitto_FREE(local_sub); + mosquitto_FREE(topics); return rc; } @@ -637,8 +636,8 @@ int sub__messages_queue(const char *source_id, const char *topic, uint8_t qos, i if(rc2) rc = rc2; } - mosquitto__FREE(split_topics); - mosquitto__FREE(local_topic); + mosquitto_FREE(split_topics); + mosquitto_FREE(local_topic); /* Remove our reference and free if needed. */ db__msg_store_ref_dec(stored); @@ -661,7 +660,7 @@ static struct mosquitto__subhier *tmp_remove_subs(struct mosquitto__subhier *sub parent = sub->parent; HASH_DELETE(hh, parent->children, sub); - mosquitto__FREE(sub); + mosquitto_FREE(sub); if(parent->subs == NULL && parent->children == NULL @@ -713,7 +712,7 @@ int sub__clean_session(struct mosquitto *context) leaf = leaf->next; } } - mosquitto__FREE(context->subs[i]); + mosquitto_FREE(context->subs[i]); if(hier->subs == NULL && hier->children == NULL @@ -725,7 +724,7 @@ int sub__clean_session(struct mosquitto *context) }while(hier); } } - mosquitto__FREE(context->subs); + mosquitto_FREE(context->subs); context->subs_capacity = 0; context->subs_count = 0; diff --git a/src/sys_tree.c b/src/sys_tree.c index acb0821b..6ef7f2a8 100644 --- a/src/sys_tree.c +++ b/src/sys_tree.c @@ -27,7 +27,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "sys_tree.h" #define BUFLEN 100 diff --git a/src/topic_tok.c b/src/topic_tok.c index 7e507b89..a1985660 100644 --- a/src/topic_tok.c +++ b/src/topic_tok.c @@ -22,7 +22,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" #include "mosquitto/mqtt_protocol.h" #include "util_mosq.h" @@ -68,7 +67,7 @@ int sub__topic_tokenise(const char *subtopic, char **local_sub, char ***topics, return MOSQ_ERR_INVAL; } - *local_sub = mosquitto__strdup(subtopic); + *local_sub = mosquitto_strdup(subtopic); if((*local_sub) == NULL) return MOSQ_ERR_NOMEM; count = 0; @@ -77,9 +76,9 @@ int sub__topic_tokenise(const char *subtopic, char **local_sub, char ***topics, saveptr = strchr(&saveptr[1], '/'); count++; } - *topics = mosquitto__calloc((size_t)(count+3) /* 3=$shared,sharename,NULL */, sizeof(char *)); + *topics = mosquitto_calloc((size_t)(count+3) /* 3=$shared,sharename,NULL */, sizeof(char *)); if((*topics) == NULL){ - mosquitto__FREE(*local_sub); + mosquitto_FREE(*local_sub); return MOSQ_ERR_NOMEM; } @@ -97,8 +96,8 @@ int sub__topic_tokenise(const char *subtopic, char **local_sub, char ***topics, if(!strcmp((*topics)[0], "$share")){ if(count < 2){ - mosquitto__FREE(*local_sub); - mosquitto__FREE(*topics); + mosquitto_FREE(*local_sub); + mosquitto_FREE(*topics); return MOSQ_ERR_PROTOCOL; } diff --git a/src/websockets.c b/src/websockets.c index 79efe97f..1c96cc7a 100644 --- a/src/websockets.c +++ b/src/websockets.c @@ -26,7 +26,6 @@ Contributors: #include "mosquitto_internal.h" #include "mosquitto_broker_internal.h" #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "packet_mosq.h" #include "sys_tree.h" #include "util_mosq.h" @@ -115,7 +114,7 @@ static void easy_address(int sock, struct mosquitto *mosq) char address[1024]; if(!net__socket_get_address(sock, address, 1024, &mosq->remote_port)){ - mosq->address = mosquitto__strdup(address); + mosq->address = mosquitto_strdup(address); } } @@ -145,7 +144,7 @@ static int callback_mqtt( p = lws_get_protocol(wsi); mosq->listener = p->user; if(!mosq->listener){ - mosquitto__FREE(mosq); + mosquitto_FREE(mosq); return -1; } mosq->wsi = wsi; @@ -165,7 +164,7 @@ static int callback_mqtt( easy_address(lws_get_socket_fd(wsi), mosq); if(!mosq->address){ /* getpeername and inet_ntop failed and not a bridge */ - mosquitto__FREE(mosq); + mosquitto_FREE(mosq); u->mosq = NULL; return -1; } @@ -175,8 +174,8 @@ static int callback_mqtt( if(db.config->connection_messages == true){ log__printf(NULL, MOSQ_LOG_NOTICE, "Client connection from %s denied: max_connections exceeded.", mosq->address); } - mosquitto__FREE(mosq->address); - mosquitto__FREE(mosq); + mosquitto_FREE(mosq->address); + mosquitto_FREE(mosq); u->mosq = NULL; return -1; } @@ -254,7 +253,7 @@ static int callback_mqtt( #endif packet__get_next_out(mosq); - mosquitto__FREE(packet); + mosquitto_FREE(packet); mosq->next_msg_out = db.now_s + mosq->keepalive; } @@ -308,7 +307,7 @@ static int callback_mqtt( mosq->in_packet.remaining_count = (int8_t)(mosq->in_packet.remaining_count * -1); if(mosq->in_packet.remaining_length > 0){ - mosq->in_packet.payload = mosquitto__malloc(mosq->in_packet.remaining_length*sizeof(uint8_t)); + mosq->in_packet.payload = mosquitto_malloc(mosq->in_packet.remaining_length*sizeof(uint8_t)); if(!mosq->in_packet.payload){ return -1; } @@ -375,7 +374,7 @@ static char *http__canonical_filename( }else{ slen = strlen(http_dir) + inlen + 2; } - filename = mosquitto__malloc(slen); + filename = mosquitto_malloc(slen); if(!filename){ lws_return_http_status(wsi, HTTP_STATUS_INTERNAL_SERVER_ERROR, NULL); return NULL; @@ -390,14 +389,14 @@ static char *http__canonical_filename( /* Get canonical path and check it is within our http_dir */ #ifdef WIN32 filename_canonical = _fullpath(NULL, filename, 0); - mosquitto__FREE(filename); + mosquitto_FREE(filename); if(!filename_canonical){ lws_return_http_status(wsi, HTTP_STATUS_INTERNAL_SERVER_ERROR, NULL); return NULL; } #else filename_canonical = realpath(filename, NULL); - mosquitto__FREE(filename); + mosquitto_FREE(filename); if(!filename_canonical){ if(errno == EACCES){ lws_return_http_status(wsi, HTTP_STATUS_FORBIDDEN, NULL); @@ -665,7 +664,7 @@ void mosq_websockets_init(struct mosquitto__listener *listener, const struct mos /* Count valid protocols */ for(protocol_count=0; protocols[protocol_count].name; protocol_count++); - p = mosquitto__calloc(protocol_count+1, sizeof(struct lws_protocols)); + p = mosquitto_calloc(protocol_count+1, sizeof(struct lws_protocols)); if(!p){ log__printf(NULL, MOSQ_LOG_ERR, "Out of memory."); return; @@ -705,7 +704,7 @@ void mosq_websockets_init(struct mosquitto__listener *listener, const struct mos user = mosquitto__calloc(1, sizeof(struct libws_mqtt_hack)); if(!user){ - mosquitto__FREE(p); + mosquitto_FREE(p); log__printf(NULL, MOSQ_LOG_ERR, "Out of memory."); return; } @@ -717,8 +716,8 @@ void mosq_websockets_init(struct mosquitto__listener *listener, const struct mos user->http_dir = realpath(listener->http_dir, NULL); #endif if(!user->http_dir){ - mosquitto__FREE(user); - mosquitto__FREE(p); + mosquitto_FREE(user); + mosquitto_FREE(p); log__printf(NULL, MOSQ_LOG_ERR, "Error: Unable to open http dir \"%s\".", listener->http_dir); return; } diff --git a/src/will_delay.c b/src/will_delay.c index 7bdf38f9..cb8434b0 100644 --- a/src/will_delay.c +++ b/src/will_delay.c @@ -23,7 +23,6 @@ Contributors: #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" static struct will_delay_list *delay_list = NULL; static time_t last_check = 0; @@ -43,7 +42,7 @@ int will_delay__add(struct mosquitto *context) return MOSQ_ERR_SUCCESS; } - item = mosquitto__calloc(1, sizeof(struct will_delay_list)); + item = mosquitto_calloc(1, sizeof(struct will_delay_list)); if(!item) return MOSQ_ERR_NOMEM; item->context = context; @@ -69,7 +68,7 @@ void will_delay__send_all(void) item->context->will_delay_interval = 0; item->context->will_delay_entry = NULL; context__send_will(item->context); - mosquitto__FREE(item); + mosquitto_FREE(item); } } @@ -95,7 +94,7 @@ void will_delay__check(void) if(item->context->session_expiry_interval == 0){ context__add_to_disused(item->context); } - mosquitto__FREE(item); + mosquitto_FREE(item); }else{ loop__update_next_event((item->context->will_delay_time - db.now_real_s)*1000); return; @@ -108,7 +107,7 @@ void will_delay__remove(struct mosquitto *mosq) { if(mosq->will_delay_entry != NULL){ DL_DELETE(delay_list, mosq->will_delay_entry); - mosquitto__FREE(mosq->will_delay_entry); + mosquitto_FREE(mosq->will_delay_entry); } } diff --git a/test/unit/broker/CMakeLists.txt b/test/unit/broker/CMakeLists.txt index e2c9dd9a..c4b9d52d 100644 --- a/test/unit/broker/CMakeLists.txt +++ b/test/unit/broker/CMakeLists.txt @@ -2,7 +2,6 @@ add_library(bridge-topic-obj OBJECT ../../../src/bridge_topic.c - ../../../lib/memory_mosq.c ) target_compile_definitions(bridge-topic-obj PRIVATE WITH_BRIDGE WITH_BROKER) target_link_libraries(bridge-topic-obj PUBLIC common-unit-test-header) @@ -16,26 +15,17 @@ target_link_libraries(bridge-topic-test PRIVATE bridge-topic-obj common-unit-tes add_test(NAME unit-bridge-topic-test COMMAND bridge-topic-test) # keepalive-test -add_library(keepalive-obj - OBJECT - ../../../lib/memory_mosq.c -) -target_compile_definitions(keepalive-obj PRIVATE WITH_BROKER) -target_link_libraries(keepalive-obj PUBLIC common-unit-test-header) - add_executable(keepalive-test keepalive_test.c keepalive_stubs.c ) target_compile_definitions(keepalive-test PRIVATE WITH_BROKER) -target_link_libraries(keepalive-test PRIVATE keepalive-obj common-unit-test-header) +target_link_libraries(keepalive-test PRIVATE common-unit-test-header libmosquitto_common) add_test(NAME unit-keepalive-test COMMAND keepalive-test) # persist-read-test add_library(persistence-read-obj OBJECT - ../../../lib/memory_mosq.c - ../../../src/memory_public.c ../../../common/misc_mosq.c ../../../src/persist_read_v234.c ../../../src/persist_read_v5.c @@ -61,8 +51,6 @@ add_test(NAME unit-persist-read-test COMMAND persist-read-test) add_library(persistence-write-obj OBJECT ../../../src/database.c - ../../../lib/memory_mosq.c - ../../../src/memory_public.c ../../../common/misc_mosq.c ../../../src/persist_read_v234.c ../../../src/persist_read_v5.c @@ -91,8 +79,6 @@ add_test(NAME unit-persist-write-test COMMAND persist-write-test) # subs-test add_library(subs-obj OBJECT - ../../../lib/memory_mosq.c - ../../../src/memory_public.c ../../../lib/property_mosq.c ../../../lib/packet_datatypes.c ../../../src/database.c diff --git a/test/unit/broker/Makefile b/test/unit/broker/Makefile index 39c24833..41749905 100644 --- a/test/unit/broker/Makefile +++ b/test/unit/broker/Makefile @@ -19,7 +19,6 @@ BRIDGE_TOPIC_TEST_OBJS = \ BRIDGE_TOPIC_OBJS = \ ${R}/src/bridge_topic.o \ - ${R}/src/memory_mosq.o \ ${R}/src/packet_datatypes.o \ ${R}/src/property_mosq.o @@ -27,16 +26,13 @@ KEEPALIVE_TEST_OBJS = \ keepalive_stubs.o \ keepalive_test.o -KEEPALIVE_OBJS = \ - ${R}/src/memory_mosq.o +KEEPALIVE_OBJS = PERSIST_READ_TEST_OBJS = \ persist_read_test.o \ persist_read_stubs.o PERSIST_READ_OBJS = \ - ${R}/src/memory_mosq.o \ - ${R}/src/memory_public.o \ ${R}/src/misc_mosq.o \ ${R}/src/packet_datatypes.o \ ${R}/src/persist_read.o \ @@ -53,8 +49,6 @@ PERSIST_WRITE_TEST_OBJS = \ PERSIST_WRITE_OBJS = \ ${R}/src/database.o \ - ${R}/src/memory_mosq.o \ - ${R}/src/memory_public.o \ ${R}/src/misc_mosq.o \ ${R}/src/packet_datatypes.o \ ${R}/src/packet_mosq.o \ @@ -75,8 +69,6 @@ SUBS_TEST_OBJS = \ SUBS_OBJS = \ ${R}/src/database.o \ - ${R}/src/memory_mosq.o \ - ${R}/src/memory_public.o \ ${R}/src/packet_datatypes.o \ ${R}/src/property_mosq.o \ ${R}/src/subs.o \ @@ -124,12 +116,6 @@ ${R}/src/bridge_topic.o : ${R}/src/bridge_topic.c ${R}/src/database.o : ${R}/src/database.c $(MAKE) -C ${R}/src/ database.o -${R}/src/memory_mosq.o : ${R}/lib/memory_mosq.c - $(MAKE) -C ${R}/src/ memory_mosq.o - -${R}/src/memory_public.o : ${R}/src/memory_public.c - $(MAKE) -C ${R}/src/ memory_public.o - ${R}/src/misc_mosq.o : ${R}/common/misc_mosq.c $(MAKE) -C ${R}/src/ misc_mosq.o diff --git a/test/unit/broker/keepalive_stubs.c b/test/unit/broker/keepalive_stubs.c index 107e4852..3d0cbc07 100644 --- a/test/unit/broker/keepalive_stubs.c +++ b/test/unit/broker/keepalive_stubs.c @@ -1,7 +1,6 @@ #include #include -#include #include #include #include diff --git a/test/unit/broker/persist_read_stubs.c b/test/unit/broker/persist_read_stubs.c index 59633d9c..68bd32c3 100644 --- a/test/unit/broker/persist_read_stubs.c +++ b/test/unit/broker/persist_read_stubs.c @@ -1,7 +1,6 @@ #include #include -#include #include #include #include @@ -15,7 +14,7 @@ struct mosquitto *context__init(void) { struct mosquitto *m; - m = mosquitto__calloc(1, sizeof(struct mosquitto)); + m = mosquitto_calloc(1, sizeof(struct mosquitto)); if(m){ m->msgs_in.inflight_maximum = 20; m->msgs_out.inflight_maximum = 20; @@ -29,18 +28,18 @@ void db__msg_store_free(struct mosquitto__base_msg *store) { int i; - mosquitto__free(store->data.source_id); - mosquitto__free(store->data.source_username); + mosquitto_free(store->data.source_id); + mosquitto_free(store->data.source_username); if(store->dest_ids){ for(i=0; idest_id_count; i++){ - mosquitto__free(store->dest_ids[i]); + mosquitto_free(store->dest_ids[i]); } - mosquitto__free(store->dest_ids); + mosquitto_free(store->dest_ids); } - mosquitto__free(store->data.topic); + mosquitto_free(store->data.topic); mosquitto_property_free_all(&store->data.properties); - mosquitto__free(store->data.payload); - mosquitto__free(store); + mosquitto_free(store->data.payload); + mosquitto_free(store); } int db__message_store(const struct mosquitto *source, struct mosquitto__base_msg *stored, uint32_t *message_expiry_interval, enum mosquitto_msg_origin origin) @@ -50,9 +49,9 @@ int db__message_store(const struct mosquitto *source, struct mosquitto__base_msg UNUSED(origin); if(source && source->id){ - stored->data.source_id = mosquitto__strdup(source->id); + stored->data.source_id = mosquitto_strdup(source->id); }else{ - stored->data.source_id = mosquitto__strdup(""); + stored->data.source_id = mosquitto_strdup(""); } if(!stored->data.source_id){ rc = MOSQ_ERR_NOMEM; @@ -60,7 +59,7 @@ int db__message_store(const struct mosquitto *source, struct mosquitto__base_msg } if(source && source->username){ - stored->data.source_username = mosquitto__strdup(source->username); + stored->data.source_username = mosquitto_strdup(source->username); if(!stored->data.source_username){ rc = MOSQ_ERR_NOMEM; goto error; diff --git a/test/unit/broker/persist_write_stubs.c b/test/unit/broker/persist_write_stubs.c index 89d17e9e..135867e4 100644 --- a/test/unit/broker/persist_write_stubs.c +++ b/test/unit/broker/persist_write_stubs.c @@ -1,7 +1,6 @@ #include #include -#include #include #include #include @@ -14,7 +13,7 @@ extern int last_qos; struct mosquitto *context__init(void) { - return mosquitto__calloc(1, sizeof(struct mosquitto)); + return mosquitto_calloc(1, sizeof(struct mosquitto)); } int log__printf(struct mosquitto *mosq, unsigned int priority, const char *fmt, ...) diff --git a/test/unit/broker/subs_stubs.c b/test/unit/broker/subs_stubs.c index fb65b8c8..9a612f85 100644 --- a/test/unit/broker/subs_stubs.c +++ b/test/unit/broker/subs_stubs.c @@ -1,7 +1,6 @@ #include #include -#include #include #include #include diff --git a/test/unit/broker/subs_test.c b/test/unit/broker/subs_test.c index f326b347..7d640e9a 100644 --- a/test/unit/broker/subs_test.c +++ b/test/unit/broker/subs_test.c @@ -7,7 +7,6 @@ #include #include "mosquitto_broker_internal.h" -#include "memory_mosq.h" struct mosquitto_db db; @@ -70,7 +69,7 @@ static void TEST_sub_add_single(void) hier_quick_check(&subhier, &context, "e"); CU_ASSERT_PTR_NULL(subhier); } - mosquitto__free(context.subs); + mosquitto_free(context.subs); db__close(); } diff --git a/test/unit/lib/CMakeLists.txt b/test/unit/lib/CMakeLists.txt index a744a876..228396fa 100644 --- a/test/unit/lib/CMakeLists.txt +++ b/test/unit/lib/CMakeLists.txt @@ -10,7 +10,6 @@ add_executable(lib-test stubs.c # main test files test.c - ../../../lib/memory_mosq.c ../../../common/misc_mosq.c ../../../lib/packet_datatypes.c ../../../lib/packet_mosq.c diff --git a/test/unit/lib/Makefile b/test/unit/lib/Makefile index 2a6e9f0b..0fe2880a 100644 --- a/test/unit/lib/Makefile +++ b/test/unit/lib/Makefile @@ -25,7 +25,6 @@ TEST_OBJS = \ stubs.o \ LIB_OBJS = \ - ${R}/lib/memory_mosq.o \ ${R}/lib/misc_mosq.o \ ${R}/lib/packet_datatypes.o \ ${R}/lib/packet_mosq.o \ @@ -46,9 +45,6 @@ ${TEST_OBJS} : %.o: %.c lib_stubs.o : stubs.c ${CROSS_COMPILE}$(CC) $(LIB_LOCAL_CPPFLAGS) $(LIB_LOCAL_CFLAGS) $(CFLAGS) $(CPPFLAGS) -c $< -o $@ -${R}/lib/memory_mosq.o : ${R}/lib/memory_mosq.c - $(MAKE) -C ${R}/lib/ memory_mosq.o - ${R}/lib/misc_mosq.o : ${R}/common/misc_mosq.c $(MAKE) -C ${R}/lib/ misc_mosq.o diff --git a/test/unit/lib/property_user_read.c b/test/unit/lib/property_user_read.c index d04c45b0..69c49b61 100644 --- a/test/unit/lib/property_user_read.c +++ b/test/unit/lib/property_user_read.c @@ -2,7 +2,6 @@ #include #include "mosquitto/mqtt_protocol.h" -#include "memory_mosq.h" #include "property_mosq.h" #include "packet_mosq.h"