github
/
mosquitto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

client_id -> clientid rename.

Browse Source
pull/2735/head
Roger A. Light 3 years ago
parent 0dc1fa5a49
commit fd330de080
31 changed files with 213 additions and 213 deletions
Show Stats Download Patch File Download Diff File

14
apps/db_dump/db_dump.c
Unescape Escape View File

@ -80,20 +80,20 @@ struct base_msg_chunk *msgs_by_id = NULL;
static void free__sub(struct P_sub *chunk)
{
free(chunk->client_id);
free(chunk->clientid);
free(chunk->topic);
}
static void free__client(struct P_client *chunk)
{
free(chunk->username);
free(chunk->client_id);
free(chunk->clientid);
}
static void free__client_msg(struct P_client_msg *chunk)
{
free(chunk->client_id);
free(chunk->clientid);
}
@ -166,10 +166,10 @@ static int dump__client_chunk_process(FILE *db_fd, uint32_t length)
if(!cc){
fprintf(stderr, "Error: Out of memory.\n");
fclose(db_fd);
free(chunk.client_id);
free(chunk.clientid);
return 1;
}
cc->id = strdup(chunk.client_id);
cc->id = strdup(chunk.clientid);
HASH_ADD_KEYPTR(hh_id, clients_by_id, cc->id, strlen(cc->id), cc);
}
@ -204,7 +204,7 @@ static int dump__client_msg_chunk_process(FILE *db_fd, uint32_t length)
}
if(client_stats){
HASH_FIND(hh_id, clients_by_id, chunk.client_id, strlen(chunk.client_id), cc);
HASH_FIND(hh_id, clients_by_id, chunk.clientid, strlen(chunk.clientid), cc);
if(cc){
cc->messages++;
cc->message_size += length;
@ -360,7 +360,7 @@ static int dump__sub_chunk_process(FILE *db_fd, uint32_t length)
}
if(client_stats){
HASH_FIND(hh_id, clients_by_id, chunk.client_id, strlen(chunk.client_id), cc);
HASH_FIND(hh_id, clients_by_id, chunk.clientid, strlen(chunk.clientid), cc);
if(cc){
cc->subscriptions++;
cc->subscription_size += length;

6
apps/db_dump/print.c
Unescape Escape View File

@ -76,7 +76,7 @@ void print__client(struct P_client *chunk, uint32_t length)
{
printf("DB_CHUNK_CLIENT:\n");
printf("\tLength: %d\n", length);
printf("\tClient ID: %s\n", chunk->client_id);
printf("\tClient ID: %s\n", chunk->clientid);
if(chunk->username){
printf("\tUsername: %s\n", chunk->username);
}
@ -93,7 +93,7 @@ void print__client_msg(struct P_client_msg *chunk, uint32_t length)
{
printf("DB_CHUNK_CLIENT_MSG:\n");
printf("\tLength: %d\n", length);
printf("\tClient ID: %s\n", chunk->client_id);
printf("\tClient ID: %s\n", chunk->clientid);
printf("\tStore ID: %" PRIu64 "\n", chunk->F.store_id);
printf("\tMID: %d\n", chunk->F.mid);
printf("\tQoS: %d\n", chunk->F.qos);
@ -139,7 +139,7 @@ void print__sub(struct P_sub *chunk, uint32_t length)
{
printf("DB_CHUNK_SUB:\n");
printf("\tLength: %u\n", length);
printf("\tClient ID: %s\n", chunk->client_id);
printf("\tClient ID: %s\n", chunk->clientid);
printf("\tTopic: %s\n", chunk->topic);
printf("\tQoS: %d\n", chunk->F.qos);
printf("\tSubscription ID: %d\n", chunk->F.identifier);

2
client/client_shared.c
Unescape Escape View File

@ -1426,7 +1426,7 @@ int client_opts_set(struct mosquitto *mosq, struct mosq_config *cfg)
return MOSQ_ERR_SUCCESS;
}
int client_id_generate(struct mosq_config *cfg)
int clientid_generate(struct mosq_config *cfg)
{
if(cfg->id_prefix){
cfg->id = malloc(strlen(cfg->id_prefix)+10);

2
client/client_shared.h
Unescape Escape View File

@ -141,7 +141,7 @@ struct mosq_config {
int client_config_load(struct mosq_config *config, int pub_or_sub, int argc, char *argv[]);
void client_config_cleanup(struct mosq_config *cfg);
int client_opts_set(struct mosquitto *mosq, struct mosq_config *cfg);
int client_id_generate(struct mosq_config *cfg);
int clientid_generate(struct mosq_config *cfg);
int client_connect(struct mosquitto *mosq, struct mosq_config *cfg);
int cfg_parse_property(struct mosq_config *cfg, int argc, char *argv[], int *idx);

2
client/pub_client.c
Unescape Escape View File

@ -569,7 +569,7 @@ int main(int argc, char *argv[])
}
if(client_id_generate(&cfg)){
if(clientid_generate(&cfg)){
goto cleanup;
}

2
client/rr_client.c
Unescape Escape View File

@ -356,7 +356,7 @@ int main(int argc, char *argv[])
}
output_init(&cfg);
if(client_id_generate(&cfg)){
if(clientid_generate(&cfg)){
goto cleanup;
}

2
client/sub_client.c
Unescape Escape View File

@ -373,7 +373,7 @@ int main(int argc, char *argv[])
goto cleanup;
}
if(client_id_generate(&cfg)){
if(clientid_generate(&cfg)){
goto cleanup;
}

8
include/mosquitto.h
Unescape Escape View File

@ -2839,7 +2839,7 @@ struct libmosquitto_tls {
* qos - the qos to use for the subscription.
* host - the broker to connect to.
* port - the network port the broker is listening on.
* client_id - the client id to use, or NULL if a random client id should be
* clientid - the client id to use, or NULL if a random client id should be
* generated.
* keepalive - the MQTT keepalive value.
* clean_session - the MQTT clean session flag.
@ -2863,7 +2863,7 @@ libmosq_EXPORT int mosquitto_subscribe_simple(
int qos,
const char *host,
int port,
const char *client_id,
const char *clientid,
int keepalive,
bool clean_session,
const char *username,
@ -2892,7 +2892,7 @@ libmosq_EXPORT int mosquitto_subscribe_simple(
* qos - the qos to use for the subscription.
* host - the broker to connect to.
* port - the network port the broker is listening on.
* client_id - the client id to use, or NULL if a random client id should be
* clientid - the client id to use, or NULL if a random client id should be
* generated.
* keepalive - the MQTT keepalive value.
* clean_session - the MQTT clean session flag.
@ -2915,7 +2915,7 @@ libmosq_EXPORT int mosquitto_subscribe_callback(
int qos,
const char *host,
int port,
const char *client_id,
const char *clientid,
int keepalive,
bool clean_session,
const char *username,

50
include/mosquitto_broker.h
Unescape Escape View File

@ -66,7 +66,7 @@ enum mosquitto_broker_msg_direction {
* ========================================================================= */
struct mosquitto_client {
char *client_id;
char *clientid;
char *username;
char *auth_method;
struct mosquitto_message_v5 *will;
@ -83,7 +83,7 @@ struct mosquitto_client {
};
struct mosquitto_subscription {
char *client_id;
char *clientid;
char *topic_filter;
mosquitto_property *properties;
uint32_t identifier;
@ -110,7 +110,7 @@ struct mosquitto_base_msg {
};
struct mosquitto_client_msg {
const char *client_id;
const char *clientid;
uint64_t cmsg_id;
uint64_t store_id;
uint32_t subscription_identifier;
@ -547,7 +547,7 @@ mosq_EXPORT void mosquitto_log_printf(int level, const char *fmt, ...);
*
* Retrieve the struct mosquitto for a client id, or NULL if the client is not connected.
*/
mosq_EXPORT struct mosquitto *mosquitto_client(const char *client_id);
mosq_EXPORT struct mosquitto *mosquitto_client(const char *clientid);
/*
@ -843,7 +843,7 @@ mosq_EXPORT int mosquitto_broker_publish_copy(
* the call to `mosquitto_complete_basic_auth()` must happen in the main
* mosquitto thread. Using the MOSQ_EVT_TICK event for this is suggested.
*/
mosq_EXPORT void mosquitto_complete_basic_auth(const char* client_id, int result);
mosq_EXPORT void mosquitto_complete_basic_auth(const char* clientid, int result);
/* Function: mosquitto_broker_node_id_set
@ -876,7 +876,7 @@ mosq_EXPORT int mosquitto_broker_node_id_set(uint16_t id);
* the broker.
*
* Parameters:
* client->plugin_client_id - the client id of the client to add
* client->plugin_clientid - the client id of the client to add
* This must be allocated on the heap and becomes the property of the
* broker immediately this call is made. Must not be NULL.
* client->plugin_username - the username for the client session, or NULL. Must
@ -902,7 +902,7 @@ mosq_EXPORT int mosquitto_broker_node_id_set(uint16_t id);
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client or client->plugin_client_id is NULL, or if a
* MOSQ_ERR_INVAL - if client or client->plugin_clientid is NULL, or if a
* client with the same ID already exists.
* MOSQ_ERR_NOMEM - on out of memory
*/
@ -914,7 +914,7 @@ mosq_EXPORT int mosquitto_persist_client_add(struct mosquitto_client *client);
* Use to update client session parameters
*
* Parameters:
* client->plugin_client_id - the client id of the client to update
* client->plugin_clientid - the client id of the client to update
* The broker will *not* modify this string and it remains the
* property of the plugin.
* client->username - the new username for the client session, or NULL. Must
@ -937,7 +937,7 @@ mosq_EXPORT int mosquitto_persist_client_add(struct mosquitto_client *client);
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client or client->plugin_client_id is NULL
* MOSQ_ERR_INVAL - if client or client->plugin_clientid is NULL
* MOSQ_ERR_NOT_FOUND - the client is not found
*/
mosq_EXPORT int mosquitto_persist_client_update(struct mosquitto_client *client);
@ -948,14 +948,14 @@ mosq_EXPORT int mosquitto_persist_client_update(struct mosquitto_client *client)
* Use to delete client session for a client from the broker
*
* Parameters:
* client_id - the client id of the client to delete
* clientid - the client id of the client to delete
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client_id is NULL
* MOSQ_ERR_INVAL - if clientid is NULL
* MOSQ_ERR_NOT_FOUND - the referenced client is not found
*/
mosq_EXPORT int mosquitto_persist_client_delete(const char *client_id);
mosq_EXPORT int mosquitto_persist_client_delete(const char *clientid);
/* Function: mosquitto_persist_client_msg_add
@ -963,7 +963,7 @@ mosq_EXPORT int mosquitto_persist_client_delete(const char *client_id);
* Use to add a client message for a particular client.
*
* Parameters:
* client_msg->client_id - the client id of the client that the
* client_msg->clientid - the client id of the client that the
* message belongs to.
* client_msg->store_id - the ID of the base message that this client
* message references.
@ -980,7 +980,7 @@ mosq_EXPORT int mosquitto_persist_client_delete(const char *client_id);
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_client_id is NULL
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_clientid is NULL
* MOSQ_ERR_NOT_FOUND - the client or base message is not found
*/
mosq_EXPORT int mosquitto_persist_client_msg_add(struct mosquitto_client_msg *client_msg);
@ -991,7 +991,7 @@ mosq_EXPORT int mosquitto_persist_client_msg_add(struct mosquitto_client_msg *cl
* Use to delete a client message for a particular client.
*
* Parameters:
* client_msg->client_id - the client id of the client that the
* client_msg->clientid - the client id of the client that the
* message belongs to.
* client_msg->cmsg_id - the client message id of the affected message
* client_msg->mid - the MQTT message id of the affected message
@ -1003,7 +1003,7 @@ mosq_EXPORT int mosquitto_persist_client_msg_add(struct mosquitto_client_msg *cl
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_client_id is NULL
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_clientid is NULL
* MOSQ_ERR_NOT_FOUND - the client is not found
*/
mosq_EXPORT int mosquitto_persist_client_msg_delete(struct mosquitto_client_msg *client_msg);
@ -1014,7 +1014,7 @@ mosq_EXPORT int mosquitto_persist_client_msg_delete(struct mosquitto_client_msg
* Use to update the state of a client message for a particular client.
*
* Parameters:
* client_msg->client_id - the client id of the client that the
* client_msg->clientid - the client id of the client that the
* message belongs to.
* client_msg->cmsg_id - the client message id of the affected message
* client_msg->mid - the MQTT message id of the affected message
@ -1027,7 +1027,7 @@ mosq_EXPORT int mosquitto_persist_client_msg_delete(struct mosquitto_client_msg
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_client_id is NULL
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_clientid is NULL
* MOSQ_ERR_NOT_FOUND - the client is not found
*/
mosq_EXPORT int mosquitto_persist_client_msg_update(struct mosquitto_client_msg *client_msg);
@ -1038,7 +1038,7 @@ mosq_EXPORT int mosquitto_persist_client_msg_update(struct mosquitto_client_msg
* Clear all messages for the listed client and direction.
*
* Parameters:
* client_msg->client_id - the client id of the client that the
* client_msg->clientid - the client id of the client that the
* message belongs to.
* client_msg->direction - the direction of the messages to be cleared, from
* the perspective of the broker (mosq_bmd_in / mosq_bmd_out / mosq_bmd_all)
@ -1048,7 +1048,7 @@ mosq_EXPORT int mosquitto_persist_client_msg_update(struct mosquitto_client_msg
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_client_id is NULL
* MOSQ_ERR_INVAL - if client_msg or client_msg->plugin_clientid is NULL
* MOSQ_ERR_NOT_FOUND - the client is not found
*/
mosq_EXPORT int mosquitto_persist_client_msg_clear(struct mosquitto_client_msg *client_msg);
@ -1109,14 +1109,14 @@ mosq_EXPORT int mosquitto_persist_base_msg_delete(uint64_t store_id);
* Use to add a new subscription for a client
*
* Parameters:
* sub->client_id - the client id of the client the new subscription is for
* sub->clientid - the client id of the client the new subscription is for
* sub->topic - the topic filter for the subscription
* sub->subscription_options - the QoS and other flags for this subscription
* sub->subscription_identifier - the MQTT v5 subscription id, or 0
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if sub, client_id, or topic are NULL, or are zero length
* MOSQ_ERR_INVAL - if sub, clientid, or topic are NULL, or are zero length
* MOSQ_ERR_NOT_FOUND - the referenced client was not found
* MOSQ_ERR_NOMEM - on out of memory
*/
@ -1128,16 +1128,16 @@ mosq_EXPORT int mosquitto_subscription_add(const struct mosquitto_subscription *
* Use to delete a subscription for a client
*
* Parameters:
* client_id - the client id of the client the new subscription is for
* clientid - the client id of the client the new subscription is for
* topic - the topic filter for the subscription
*
* Returns:
* MOSQ_ERR_SUCCESS - on success
* MOSQ_ERR_INVAL - if client_id or topic are NULL, or are zero length
* MOSQ_ERR_INVAL - if clientid or topic are NULL, or are zero length
* MOSQ_ERR_NOT_FOUND - the referenced client was not found
* MOSQ_ERR_NOMEM - on out of memory
*/
mosq_EXPORT int mosquitto_subscription_delete(const char *client_id, const char *topic);
mosq_EXPORT int mosquitto_subscription_delete(const char *clientid, const char *topic);
/* Function: mosquitto_persist_retain_msg_set

4
include/mosquittopp.h
Unescape Escape View File

@ -55,7 +55,7 @@ mosqpp_EXPORT int subscribe_simple(
int qos=0,
const char *host="localhost",
int port=1883,
const char *client_id=NULL,
const char *clientid=NULL,
int keepalive=60,
bool clean_session=true,
const char *username=NULL,
@ -70,7 +70,7 @@ mosqpp_EXPORT int subscribe_callback(
int qos=0,
const char *host="localhost",
int port=1883,
const char *client_id=NULL,
const char *clientid=NULL,
int keepalive=60,
bool clean_session=true,
const char *username=NULL,

8
lib/cpp/mosquittopp.cpp
Unescape Escape View File

@ -218,7 +218,7 @@ int subscribe_simple(
int qos,
const char *host,
int port,
const char *client_id,
const char *clientid,
int keepalive,
bool clean_session,
const char *username,
@ -229,7 +229,7 @@ int subscribe_simple(
return mosquitto_subscribe_simple(
messages, msg_count, retained,
topic, qos,
host, port, client_id, keepalive, clean_session,
host, port, clientid, keepalive, clean_session,
username, password,
will, tls);
}
@ -241,7 +241,7 @@ mosqpp_EXPORT int subscribe_callback(
int qos,
const char *host,
int port,
const char *client_id,
const char *clientid,
int keepalive,
bool clean_session,
const char *username,
@ -252,7 +252,7 @@ mosqpp_EXPORT int subscribe_callback(
return mosquitto_subscribe_callback(
callback, userdata,
topic, qos,
host, port, client_id, keepalive, clean_session,
host, port, clientid, keepalive, clean_session,
username, password,
will, tls);
}

8
lib/helpers.c
Unescape Escape View File

@ -97,7 +97,7 @@ libmosq_EXPORT int mosquitto_subscribe_simple(
int qos,
const char *host,
int port,
const char *client_id,
const char *clientid,
int keepalive,
bool clean_session,
const char *username,
@ -127,7 +127,7 @@ libmosq_EXPORT int mosquitto_subscribe_simple(
on_message_simple, &userdata,
topic, qos,
host, port,
client_id, keepalive, clean_session,
clientid, keepalive, clean_session,
username, password,
will, tls);
@ -151,7 +151,7 @@ libmosq_EXPORT int mosquitto_subscribe_callback(
int qos,
const char *host,
int port,
const char *client_id,
const char *clientid,
int keepalive,
bool clean_session,
const char *username,
@ -172,7 +172,7 @@ libmosq_EXPORT int mosquitto_subscribe_callback(
cb_userdata.userdata = userdata;
cb_userdata.callback = callback;
mosq = mosquitto_new(client_id, clean_session, &cb_userdata);
mosq = mosquitto_new(clientid, clean_session, &cb_userdata);
if(!mosq){
return MOSQ_ERR_NOMEM;
}

4
plugins/examples/add-properties/mosquitto_add_properties.c
Unescape Escape View File

@ -20,7 +20,7 @@ Contributors:
/*
* Adds MQTT v5 user-properties to incoming messages:
* - $timestamp: unix epoch in milliseconds
* - $client_id: client id of the publishing client
* - $clientid: client id of the publishing client
* - $client_username: username that the publishing client used to authenticate
*
* Compile with:
@ -75,7 +75,7 @@ static int callback_message_in(int event, void *event_data, void *userdata)
result = mosquitto_property_add_string_pair(
&ed->properties,
MQTT_PROP_USER_PROPERTY,
"$client_id",
"$clientid",
mosquitto_client_id(ed->client));
if (result != MOSQ_ERR_SUCCESS) return result;

12
plugins/examples/connection-state/mosquitto_connection_state.c
Unescape Escape View File

@ -52,15 +52,15 @@ static mosquitto_plugin_id_t *mosq_pid = NULL;
static int connect_callback(int event, void *event_data, void *userdata)
{
struct mosquitto_evt_connect *ed = event_data;
const char *client_id;
const char *clientid;
char topic[1024];
int len;
UNUSED(event);
UNUSED(userdata);
client_id = mosquitto_client_id(ed->client);
len = snprintf(topic, sizeof(topic), "$SYS/broker/connection/client/%s/state", client_id);
clientid = mosquitto_client_id(ed->client);
len = snprintf(topic, sizeof(topic), "$SYS/broker/connection/client/%s/state", clientid);
if(len < (int)sizeof(topic)){
mosquitto_broker_publish_copy(NULL, topic, 1, "1", 0, true, NULL);
}else{
@ -73,7 +73,7 @@ static int connect_callback(int event, void *event_data, void *userdata)
static int disconnect_callback(int event, void *event_data, void *userdata)
{
struct mosquitto_evt_disconnect *ed = event_data;
const char *client_id;
const char *clientid;
char topic[1024];
int len;
mosquitto_property *proplist = NULL;
@ -82,8 +82,8 @@ static int disconnect_callback(int event, void *event_data, void *userdata)
UNUSED(event);
UNUSED(userdata);
client_id = mosquitto_client_id(ed->client);
len = snprintf(topic, sizeof(topic), "$SYS/broker/connection/client/%s/state", client_id);
clientid = mosquitto_client_id(ed->client);
len = snprintf(topic, sizeof(topic), "$SYS/broker/connection/client/%s/state", clientid);
if(len < (int)sizeof(topic)){
/* Expire our "disconnected" message after a day. */
rc = mosquitto_property_add_int32(&proplist, MQTT_PROP_MESSAGE_EXPIRY_INTERVAL, 86400);

56
plugins/examples/topic-jail/mosquitto_topic_jail.c
Unescape Escape View File

@ -78,17 +78,17 @@ static int callback_message_in(int event, void *event_data, void *userdata)
UNUSED(event);
UNUSED(userdata);
const char *client_id = mosquitto_client_id(ed->client);
const char *clientid = mosquitto_client_id(ed->client);
if(!is_jailed(client_id)){
if(!is_jailed(clientid)){
/* will only modify the topic of jailed clients */
return MOSQ_ERR_SUCCESS;
}
/* put the client_id on front of the topic */
/* put the clientid on front of the topic */
/* calculate the length of the new payload */
new_topic_len = strlen(client_id) + sizeof('/') + strlen(ed->topic) + 1;
new_topic_len = strlen(clientid) + sizeof('/') + strlen(ed->topic) + 1;
/* Allocate some memory - use
* mosquitto_calloc/mosquitto_malloc/mosquitto_strdup when allocating, to
@ -98,8 +98,8 @@ static int callback_message_in(int event, void *event_data, void *userdata)
return MOSQ_ERR_NOMEM;
}
/* prepend the client_id to the topic */
snprintf(new_topic, new_topic_len, "%s/%s", client_id, ed->topic);
/* prepend the clientid to the topic */
snprintf(new_topic, new_topic_len, "%s/%s", clientid, ed->topic);
/* Assign the new topic to the event data structure. You
* must *not* free the original topic, it will be handled by the
@ -112,34 +112,34 @@ static int callback_message_in(int event, void *event_data, void *userdata)
static int callback_message_out(int event, void *event_data, void *userdata)
{
struct mosquitto_evt_message *ed = event_data;
size_t client_id_len;
size_t clientid_len;
UNUSED(event);
UNUSED(userdata);
const char *client_id = mosquitto_client_id(ed->client);
const char *clientid = mosquitto_client_id(ed->client);
if(!is_jailed(client_id)){
if(!is_jailed(clientid)){
/* will only modify the topic of jailed clients */
return MOSQ_ERR_SUCCESS;
}
/* remove the client_id from the front of the topic */
client_id_len = strlen(client_id);
/* remove the clientid from the front of the topic */
clientid_len = strlen(clientid);
if(strlen(ed->topic) <= client_id_len + 1){
if(strlen(ed->topic) <= clientid_len + 1){
/* the topic is not long enough to contain the
* client_id + '/' */
* clientid + '/' */
return MOSQ_ERR_SUCCESS;
}
if(!strncmp(client_id, ed->topic, client_id_len) && ed->topic[client_id_len] == '/'){
if(!strncmp(clientid, ed->topic, clientid_len) && ed->topic[clientid_len] == '/'){
/* Allocate some memory - use
* mosquitto_calloc/mosquitto_malloc/mosquitto_strdup when allocating, to
* allow the broker to track memory usage */
/* skip the client_id + '/' */
char *new_topic = mosquitto_strdup(ed->topic + client_id_len + 1);
/* skip the clientid + '/' */
char *new_topic = mosquitto_strdup(ed->topic + clientid_len + 1);
if(new_topic == NULL){
return MOSQ_ERR_NOMEM;
@ -163,17 +163,17 @@ static int callback_subscribe(int event, void *event_data, void *userdata)
UNUSED(event);
UNUSED(userdata);
const char *client_id = mosquitto_client_id(ed->client);
const char *clientid = mosquitto_client_id(ed->client);
if(!is_jailed(client_id)){
if(!is_jailed(clientid)){
/* will only modify the topic of jailed clients */
return MOSQ_ERR_SUCCESS;
}
/* put the client_id on front of the topic */
/* put the clientid on front of the topic */
/* calculate the length of the new payload */
new_sub_len = strlen(client_id) + sizeof('/') + strlen(ed->data.topic_filter) + 1;
new_sub_len = strlen(clientid) + sizeof('/') + strlen(ed->data.topic_filter) + 1;
/* Allocate some memory - use
* mosquitto_calloc/mosquitto_malloc/mosquitto_strdup when allocating, to
@ -183,8 +183,8 @@ static int callback_subscribe(int event, void *event_data, void *userdata)
return MOSQ_ERR_NOMEM;
}
/* prepend the client_id to the subscription */
snprintf(new_sub, new_sub_len, "%s/%s", client_id, ed->data.topic_filter);
/* prepend the clientid to the subscription */
snprintf(new_sub, new_sub_len, "%s/%s", clientid, ed->data.topic_filter);
/* Assign the new topic to the event data structure. You
* must *not* free the original topic, it will be handled by the
@ -203,17 +203,17 @@ static int callback_unsubscribe(int event, void *event_data, void *userdata)
UNUSED(event);
UNUSED(userdata);
const char *client_id = mosquitto_client_id(ed->client);
const char *clientid = mosquitto_client_id(ed->client);
if(!is_jailed(client_id)){
if(!is_jailed(clientid)){
/* will only modify the topic of jailed clients */
return MOSQ_ERR_SUCCESS;
}
/* put the client_id on front of the topic */
/* put the clientid on front of the topic */
/* calculate the length of the new payload */
new_sub_len = strlen(client_id) + sizeof('/') + strlen(ed->data.topic_filter) + 1;
new_sub_len = strlen(clientid) + sizeof('/') + strlen(ed->data.topic_filter) + 1;
/* Allocate some memory - use
* mosquitto_calloc/mosquitto_malloc/mosquitto_strdup when allocating, to
@ -223,8 +223,8 @@ static int callback_unsubscribe(int event, void *event_data, void *userdata)
return MOSQ_ERR_NOMEM;
}
/* prepend the client_id to the subscription */
snprintf(new_sub, new_sub_len, "%s/%s", client_id, ed->data.topic_filter);
/* prepend the clientid to the subscription */
snprintf(new_sub, new_sub_len, "%s/%s", clientid, ed->data.topic_filter);
/* Assign the new topic to the event data structure. You
* must *not* free the original topic, it will be handled by the

10
plugins/persist-sqlite/client_msgs.c
Unescape Escape View File

@ -32,7 +32,7 @@ int persist_sqlite__client_msg_add_cb(int event, void *event_data, void *userdat
UNUSED(event);
if(sqlite3_bind_text(ms->client_msg_add_stmt, 1, ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK
if(sqlite3_bind_text(ms->client_msg_add_stmt, 1, ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK
&& sqlite3_bind_int64(ms->client_msg_add_stmt, 2, (int64_t)ed->data.cmsg_id) == SQLITE_OK
&& sqlite3_bind_int64(ms->client_msg_add_stmt, 3, (int64_t)ed->data.store_id) == SQLITE_OK
&& sqlite3_bind_int(ms->client_msg_add_stmt, 4, ed->data.dup) == SQLITE_OK
@ -67,7 +67,7 @@ int persist_sqlite__client_msg_remove_cb(int event, void *event_data, void *user
UNUSED(event);
if(sqlite3_bind_text(ms->client_msg_remove_stmt, 1, ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK
if(sqlite3_bind_text(ms->client_msg_remove_stmt, 1, ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK
&& sqlite3_bind_int64(ms->client_msg_remove_stmt, 2, (int64_t)ed->data.store_id) == SQLITE_OK
&& sqlite3_bind_int(ms->client_msg_remove_stmt, 3, ed->data.direction) == SQLITE_OK
){
@ -96,7 +96,7 @@ int persist_sqlite__client_msg_update_cb(int event, void *event_data, void *user
if(sqlite3_bind_int(ms->client_msg_update_stmt, 1, ed->data.state) == SQLITE_OK
&& sqlite3_bind_int(ms->client_msg_update_stmt, 2, ed->data.dup) == SQLITE_OK
&& sqlite3_bind_text(ms->client_msg_update_stmt, 3, ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK
&& sqlite3_bind_text(ms->client_msg_update_stmt, 3, ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK
&& sqlite3_bind_int64(ms->client_msg_update_stmt, 4, (int64_t)ed->data.store_id) == SQLITE_OK
){
@ -114,11 +114,11 @@ int persist_sqlite__client_msg_update_cb(int event, void *event_data, void *user
}
int persist_sqlite__client_msg_clear(struct mosquitto_sqlite *ms, const char *client_id)
int persist_sqlite__client_msg_clear(struct mosquitto_sqlite *ms, const char *clientid)
{
int rc = MOSQ_ERR_UNKNOWN;
if(sqlite3_bind_text(ms->client_msg_clear_all_stmt, 1, client_id, (int)strlen(client_id), SQLITE_STATIC) == SQLITE_OK){
if(sqlite3_bind_text(ms->client_msg_clear_all_stmt, 1, clientid, (int)strlen(clientid), SQLITE_STATIC) == SQLITE_OK){
ms->event_count++;
rc = sqlite3_step(ms->client_msg_clear_all_stmt);
if(rc == SQLITE_DONE){

12
plugins/persist-sqlite/clients.c
Unescape Escape View File

@ -33,7 +33,7 @@ int persist_sqlite__client_add_cb(int event, void *event_data, void *userdata)
UNUSED(event);
if(sqlite3_bind_text(ms->client_add_stmt, 1,
ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK){
ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK){
if(ed->data.username){
sqlite3_bind_text(ms->client_add_stmt, 2,
@ -78,7 +78,7 @@ int persist_sqlite__client_remove_cb(int event, void *event_data, void *userdata
UNUSED(event);
if(sqlite3_bind_text(ms->subscription_clear_stmt, 1,
ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK){
ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK){
ms->event_count++;
rc = sqlite3_step(ms->subscription_clear_stmt);
@ -90,7 +90,7 @@ int persist_sqlite__client_remove_cb(int event, void *event_data, void *userdata
}
}
if(sqlite3_bind_text(ms->client_remove_stmt, 1,
ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK){
ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK){
ms->event_count++;
rc = sqlite3_step(ms->client_remove_stmt);
@ -101,7 +101,7 @@ int persist_sqlite__client_remove_cb(int event, void *event_data, void *userdata
rc = MOSQ_ERR_UNKNOWN;
}
}
persist_sqlite__client_msg_clear(ms, ed->data.client_id);
persist_sqlite__client_msg_clear(ms, ed->data.clientid);
return rc;
}
@ -117,8 +117,8 @@ int persist_sqlite__client_update_cb(int event, void *event_data, void *userdata
if(sqlite3_bind_int64(ms->client_update_stmt, 1, ed->data.session_expiry_time) == SQLITE_OK
&& sqlite3_bind_int64(ms->client_update_stmt, 2, ed->data.will_delay_time) == SQLITE_OK
&& sqlite3_bind_text(ms->client_update_stmt, 3, ed->data.client_id,
(int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK
&& sqlite3_bind_text(ms->client_update_stmt, 3, ed->data.clientid,
(int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK
){
ms->event_count++;

2
plugins/persist-sqlite/persist_sqlite.h
Unescape Escape View File

@ -61,7 +61,7 @@ int persist_sqlite__client_add_cb(int event, void *event_data, void *userdata);
int persist_sqlite__client_update_cb(int event, void *event_data, void *userdata);
int persist_sqlite__client_remove_cb(int event, void *event_data, void *userdata);
int persist_sqlite__client_msg_add_cb(int event, void *event_data, void *userdata);
int persist_sqlite__client_msg_clear(struct mosquitto_sqlite *ms, const char *client_id);
int persist_sqlite__client_msg_clear(struct mosquitto_sqlite *ms, const char *clientid);
int persist_sqlite__client_msg_remove_cb(int event, void *event_data, void *userdata);
int persist_sqlite__client_msg_update_cb(int event, void *event_data, void *userdata);
int persist_sqlite__base_msg_add_cb(int event, void *event_data, void *userdata);

6
plugins/persist-sqlite/restore.c
Unescape Escape View File

@ -201,7 +201,7 @@ static int client_restore(struct mosquitto_sqlite *ms)
while(sqlite3_step(stmt) == SQLITE_ROW){
str = (const char *)sqlite3_column_text(stmt, 0);
if(str){
client.client_id = strdup(str);
client.clientid = strdup(str);
}
str = (const char *)sqlite3_column_text(stmt, 1);
if(str){
@ -250,7 +250,7 @@ static int subscription_restore(struct mosquitto_sqlite *ms)
while(sqlite3_step(stmt) == SQLITE_ROW){
memset(&sub, 0, sizeof(sub));
sub.client_id = (char *)sqlite3_column_text(stmt, 0);
sub.clientid = (char *)sqlite3_column_text(stmt, 0);
sub.topic_filter = (char *)sqlite3_column_text(stmt, 1);
sub.options = (uint8_t)sqlite3_column_int(stmt, 2);
sub.identifier = (uint32_t)sqlite3_column_int(stmt, 3);
@ -355,7 +355,7 @@ static int client_msg_restore(struct mosquitto_sqlite *ms)
memset(&client_msg, 0, sizeof(client_msg));
while(sqlite3_step(stmt) == SQLITE_ROW){
client_msg.client_id = (const char *)sqlite3_column_text(stmt, 0);
client_msg.clientid = (const char *)sqlite3_column_text(stmt, 0);
client_msg.cmsg_id = (uint64_t)sqlite3_column_int64(stmt, 1);
client_msg.store_id = (uint64_t)sqlite3_column_int64(stmt, 2);
client_msg.dup = sqlite3_column_int(stmt, 3);

4
plugins/persist-sqlite/subscriptions.c
Unescape Escape View File

@ -32,7 +32,7 @@ int persist_sqlite__subscription_add_cb(int event, void *event_data, void *userd
UNUSED(event);
if(sqlite3_bind_text(ms->subscription_add_stmt, 1,
ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK){
ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK){
if(sqlite3_bind_text(ms->subscription_add_stmt, 2,
ed->data.topic_filter, (int)strlen(ed->data.topic_filter), SQLITE_STATIC) == SQLITE_OK){
@ -68,7 +68,7 @@ int persist_sqlite__subscription_remove_cb(int event, void *event_data, void *us
UNUSED(event);
if(sqlite3_bind_text(ms->subscription_remove_stmt, 1,
ed->data.client_id, (int)strlen(ed->data.client_id), SQLITE_STATIC) == SQLITE_OK){
ed->data.clientid, (int)strlen(ed->data.clientid), SQLITE_STATIC) == SQLITE_OK){
if(sqlite3_bind_text(ms->subscription_remove_stmt, 2,
ed->data.topic_filter, (int)strlen(ed->data.topic_filter), SQLITE_STATIC) == SQLITE_OK){

50
src/handle_connect.c
Unescape Escape View File

@ -48,9 +48,9 @@ static char nibble_to_hex(uint8_t value)
}
}
static char *client_id_gen(uint16_t *idlen, const char *auto_id_prefix, uint16_t auto_id_prefix_len)
static char *clientid_gen(uint16_t *idlen, const char *auto_id_prefix, uint16_t auto_id_prefix_len)
{
char *client_id;
char *clientid;
uint8_t rnd[16];
int i;
int pos;
@ -59,26 +59,26 @@ static char *client_id_gen(uint16_t *idlen, const char *auto_id_prefix, uint16_t
*idlen = (uint16_t)(auto_id_prefix_len + 36);
client_id = (char *)mosquitto__calloc((size_t)(*idlen) + 1, sizeof(char));
if(!client_id){
clientid = (char *)mosquitto__calloc((size_t)(*idlen) + 1, sizeof(char));
if(!clientid){
return NULL;
}
if(auto_id_prefix){
memcpy(client_id, auto_id_prefix, auto_id_prefix_len);
memcpy(clientid, auto_id_prefix, auto_id_prefix_len);
}
pos = 0;
for(i=0; i<16; i++){
client_id[auto_id_prefix_len + pos + 0] = nibble_to_hex(rnd[i] & 0x0F);
client_id[auto_id_prefix_len + pos + 1] = nibble_to_hex((rnd[i] >> 4) & 0x0F);
clientid[auto_id_prefix_len + pos + 0] = nibble_to_hex(rnd[i] & 0x0F);
clientid[auto_id_prefix_len + pos + 1] = nibble_to_hex((rnd[i] >> 4) & 0x0F);
pos += 2;
if(pos == 8 || pos == 13 || pos == 18 || pos == 23){
client_id[auto_id_prefix_len + pos] = '-';
clientid[auto_id_prefix_len + pos] = '-';
pos++;
}
}
return client_id;
return clientid;
}
/* Remove any queued messages that are no longer allowed through ACL,
@ -358,7 +358,7 @@ error:
}
static int will__read(struct mosquitto *context, const char *client_id, struct mosquitto_message_all **will, uint8_t will_qos, int will_retain)
static int will__read(struct mosquitto *context, const char *clientid, struct mosquitto_message_all **will, uint8_t will_qos, int will_retain)
{
int rc = MOSQ_ERR_SUCCESS;
size_t slen;
@ -412,7 +412,7 @@ static int will__read(struct mosquitto *context, const char *client_id, struct m
will_struct->msg.payloadlen = payloadlen;
if(will_struct->msg.payloadlen > 0){
if(db.config->message_size_limit && will_struct->msg.payloadlen > (int)db.config->message_size_limit){
log__printf(NULL, MOSQ_LOG_DEBUG, "Client %s connected with too large Will payload", client_id);
log__printf(NULL, MOSQ_LOG_DEBUG, "Client %s connected with too large Will payload", clientid);
if(context->protocol == mosq_p_mqtt5){
send__connack(context, 0, MQTT_RC_PACKET_TOO_LARGE, NULL);
}else{
@ -578,7 +578,7 @@ int handle__connect(struct mosquitto *context)
char protocol_name[7];
uint8_t protocol_version;
uint8_t connect_flags;
char *client_id = NULL;
char *clientid = NULL;
struct mosquitto *found_context;
struct mosquitto_message_all *will_struct = NULL;
uint8_t will, will_retain, will_qos, clean_start;
@ -770,7 +770,7 @@ int handle__connect(struct mosquitto *context)
}
if(packet__read_string(&context->in_packet, &client_id, &slen)){
if(packet__read_string(&context->in_packet, &clientid, &slen)){
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
@ -781,7 +781,7 @@ int handle__connect(struct mosquitto *context)
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}else{ /* mqtt311/mqtt5 */
mosquitto__FREE(client_id);
mosquitto__FREE(clientid);
if(db.config->per_listener_settings){
allow_zero_length_clientid = context->listener->security_options->allow_zero_length_clientid;
@ -798,11 +798,11 @@ int handle__connect(struct mosquitto *context)
goto handle_connect_error;
}else{
if(db.config->per_listener_settings){
client_id = client_id_gen(&slen, context->listener->security_options->auto_id_prefix, context->listener->security_options->auto_id_prefix_len);
clientid = clientid_gen(&slen, context->listener->security_options->auto_id_prefix, context->listener->security_options->auto_id_prefix_len);
}else{
client_id = client_id_gen(&slen, db.config->security_options.auto_id_prefix, db.config->security_options.auto_id_prefix_len);
clientid = clientid_gen(&slen, db.config->security_options.auto_id_prefix, db.config->security_options.auto_id_prefix_len);
}
if(!client_id){
if(!clientid){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}
@ -813,7 +813,7 @@ int handle__connect(struct mosquitto *context)
/* clientid_prefixes check */
if(db.config->clientid_prefixes){
if(strncmp(db.config->clientid_prefixes, client_id, strlen(db.config->clientid_prefixes))){
if(strncmp(db.config->clientid_prefixes, clientid, strlen(db.config->clientid_prefixes))){
if(context->protocol == mosq_p_mqtt5){
send__connack(context, 0, MQTT_RC_NOT_AUTHORIZED, NULL);
}else{
@ -825,14 +825,14 @@ int handle__connect(struct mosquitto *context)
}
/* Check for an existing delayed auth check, reject if present */
HASH_FIND(hh_id, db.contexts_by_id_delayed_auth, client_id, strlen(client_id), found_context);
HASH_FIND(hh_id, db.contexts_by_id_delayed_auth, clientid, strlen(clientid), found_context);
if(found_context){
rc = MOSQ_ERR_UNKNOWN;
goto handle_connect_error;
}
if(will){
rc = will__read(context, client_id, &will_struct, will_qos, will_retain);
rc = will__read(context, clientid, &will_struct, will_qos, will_retain);
if(rc){
if(context->protocol == mosq_p_mqtt5){
if(rc == MOSQ_ERR_DUPLICATE_PROPERTY || rc == MOSQ_ERR_PROTOCOL){
@ -870,7 +870,7 @@ int handle__connect(struct mosquitto *context)
if(context->protocol == mosq_p_mqtt311 || context->protocol == mosq_p_mqtt31){
if(password_flag){
/* username_flag == 0 && password_flag == 1 is forbidden */
log__printf(NULL, MOSQ_LOG_ERR, "Protocol error from %s: password without username, closing connection.", client_id);
log__printf(NULL, MOSQ_LOG_ERR, "Protocol error from %s: password without username, closing connection.", clientid);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
@ -903,8 +903,8 @@ int handle__connect(struct mosquitto *context)
/* Once context->id is set, if we return from this function with an error
* we must make sure that context->id is freed and set to NULL, so that the
* client isn't erroneously removed from the by_id hash table. */
context->id = client_id;
client_id = NULL;
context->id = clientid;
clientid = NULL;
#ifdef WITH_TLS
if(context->listener->ssl_ctx && (context->listener->use_identity_as_username || context->listener->use_subject_as_username)){
@ -943,7 +943,7 @@ int handle__connect(struct mosquitto *context)
}else
#endif /* WITH_TLS */
{
/* FIXME - these ensure the mosquitto_client_id() and
/* FIXME - these ensure the mosquitto_clientid() and
* mosquitto_client_username() functions work, but is hacky */
context->username = username;
context->password = password;
@ -1052,7 +1052,7 @@ int handle__connect(struct mosquitto *context)
handle_connect_error:
mosquitto__FREE(auth_data);
mosquitto__FREE(client_id);
mosquitto__FREE(clientid);
mosquitto__FREE(username);
mosquitto__FREE(password);
if(will_struct){

6
src/persist.h
Unescape Escape View File

@ -81,7 +81,7 @@ struct PF_client{
};
struct P_client{
struct PF_client F;
char *client_id;
char *clientid;
char *username;
};
@ -97,7 +97,7 @@ struct PF_client_msg{
};
struct P_client_msg{
struct PF_client_msg F;
char *client_id;
char *clientid;
uint32_t subscription_identifier;
};
@ -132,7 +132,7 @@ struct PF_sub{
};
struct P_sub{
struct PF_sub F;
char *client_id;
char *clientid;
char *topic;
};

24
src/persist_read.c
Unescape Escape View File

@ -50,18 +50,18 @@ static long client_msg_count = 0;
static int persist__restore_sub(const struct mosquitto_subscription *sub);
static struct mosquitto *persist__find_or_add_context(const char *client_id, uint16_t last_mid)
static struct mosquitto *persist__find_or_add_context(const char *clientid, uint16_t last_mid)
{
struct mosquitto *context;
if(!client_id) return NULL;
if(!clientid) return NULL;
context = NULL;
HASH_FIND(hh_id, db.contexts_by_id, client_id, strlen(client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, clientid, strlen(clientid), context);
if(!context){
context = context__init();
if(!context) return NULL;
context->id = mosquitto__strdup(client_id);
context->id = mosquitto__strdup(clientid);
if(!context->id){
mosquitto__FREE(context);
return NULL;
@ -127,7 +127,7 @@ static int persist__client_msg_restore(struct P_client_msg *chunk)
return MOSQ_ERR_SUCCESS;
}
context = persist__find_or_add_context(chunk->client_id, 0);
context = persist__find_or_add_context(chunk->clientid, 0);
if(!context){
log__printf(NULL, MOSQ_LOG_WARNING, "Warning: Persistence file contains client message with no matching client. File may be corrupt.");
return 0;
@ -195,7 +195,7 @@ static int persist__client_chunk_restore(FILE *db_fptr)
return MOSQ_ERR_SUCCESS;
}
context = persist__find_or_add_context(chunk.client_id, chunk.F.last_mid);
context = persist__find_or_add_context(chunk.clientid, chunk.F.last_mid);
if(context){
context->session_expiry_time = chunk.F.session_expiry_time;
context->session_expiry_interval = chunk.F.session_expiry_interval;
@ -218,7 +218,7 @@ static int persist__client_chunk_restore(FILE *db_fptr)
rc = 1;
}
mosquitto__FREE(chunk.client_id);
mosquitto__FREE(chunk.clientid);
mosquitto__FREE(chunk.username);
if(rc == 0) client_count++;
return rc;
@ -242,7 +242,7 @@ static int persist__client_msg_chunk_restore(FILE *db_fptr, uint32_t length)
}
rc = persist__client_msg_restore(&chunk);
mosquitto__FREE(chunk.client_id);
mosquitto__FREE(chunk.clientid);
if(rc == 0) client_msg_count++;
return rc;
@ -375,13 +375,13 @@ static int persist__sub_chunk_restore(FILE *db_fptr)
return rc;
}
sub.client_id = chunk.client_id;
sub.clientid = chunk.clientid;
sub.topic_filter = chunk.topic;
sub.options = chunk.F.qos | chunk.F.options;
sub.identifier = chunk.F.identifier;
rc = persist__restore_sub(&sub);
mosquitto__FREE(chunk.client_id);
mosquitto__FREE(chunk.clientid);
mosquitto__FREE(chunk.topic);
if(rc == 0) subscription_count++;
@ -547,10 +547,10 @@ static int persist__restore_sub(const struct mosquitto_subscription *sub)
struct mosquitto *context;
assert(sub);
assert(sub->client_id);
assert(sub->clientid);
assert(sub->topic_filter);
context = persist__find_or_add_context(sub->client_id, 0);
context = persist__find_or_add_context(sub->clientid, 0);
if(!context) return 1;
return sub__add(context, sub);
}

12
src/persist_read_v234.c
Unescape Escape View File

@ -76,7 +76,7 @@ int persist__chunk_client_read_v234(FILE *db_fptr, struct P_client *chunk, uint3
int rc;
time_t temp;
rc = persist__read_string(db_fptr, &chunk->client_id);
rc = persist__read_string(db_fptr, &chunk->clientid);
if(rc){
return rc;
}
@ -90,7 +90,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->client_id);
mosquitto__FREE(chunk->clientid);
return 1;
}
@ -101,7 +101,7 @@ int persist__chunk_client_msg_read_v234(FILE *db_fptr, struct P_client_msg *chun
int rc;
uint8_t retain, dup;
rc = persist__read_string(db_fptr, &chunk->client_id);
rc = persist__read_string(db_fptr, &chunk->clientid);
if(rc){
return rc;
}
@ -122,7 +122,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->client_id);
mosquitto__FREE(chunk->clientid);
return 1;
}
@ -198,7 +198,7 @@ int persist__chunk_sub_read_v234(FILE *db_fptr, struct P_sub *chunk)
{
int rc;
rc = persist__read_string(db_fptr, &chunk->client_id);
rc = persist__read_string(db_fptr, &chunk->clientid);
if(rc) goto error;
rc = persist__read_string(db_fptr, &chunk->topic);
@ -208,7 +208,7 @@ int persist__chunk_sub_read_v234(FILE *db_fptr, struct P_sub *chunk)
return MOSQ_ERR_SUCCESS;
error:
mosquitto__FREE(chunk->client_id);
mosquitto__FREE(chunk->clientid);
mosquitto__FREE(chunk->topic);
return rc;
}

12
src/persist_read_v5.c
Unescape Escape View File

@ -85,17 +85,17 @@ int persist__chunk_client_read_v56(FILE *db_fptr, struct P_client *chunk, uint32
chunk->F.id_len = ntohs(chunk->F.id_len);
rc = persist__read_string_len(db_fptr, &chunk->client_id, chunk->F.id_len);
rc = persist__read_string_len(db_fptr, &chunk->clientid, chunk->F.id_len);
if(rc){
return 1;
}else if(chunk->client_id == NULL){
}else if(chunk->clientid == NULL){
return -1;
}
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->client_id);
mosquitto__FREE(chunk->clientid);
return 1;
}
}
@ -119,7 +119,7 @@ int persist__chunk_client_msg_read_v56(FILE *db_fptr, struct P_client_msg *chunk
length -= (uint32_t)(sizeof(struct PF_client_msg) + chunk->F.id_len);
rc = persist__read_string_len(db_fptr, &chunk->client_id, chunk->F.id_len);
rc = persist__read_string_len(db_fptr, &chunk->clientid, chunk->F.id_len);
if(rc) return rc;
if(length > 0){
@ -241,7 +241,7 @@ int persist__chunk_sub_read_v56(FILE *db_fptr, struct P_sub *chunk)
chunk->F.id_len = ntohs(chunk->F.id_len);
chunk->F.topic_len = ntohs(chunk->F.topic_len);
rc = persist__read_string_len(db_fptr, &chunk->client_id, chunk->F.id_len);
rc = persist__read_string_len(db_fptr, &chunk->clientid, chunk->F.id_len);
if(rc) goto error;
rc = persist__read_string_len(db_fptr, &chunk->topic, chunk->F.topic_len);
@ -249,7 +249,7 @@ int persist__chunk_sub_read_v56(FILE *db_fptr, struct P_sub *chunk)
return MOSQ_ERR_SUCCESS;
error:
mosquitto__FREE(chunk->client_id);
mosquitto__FREE(chunk->clientid);
return rc;
}

6
src/persist_write.c
Unescape Escape View File

@ -68,7 +68,7 @@ static int persist__client_messages_save(FILE *db_fptr, struct mosquitto *contex
chunk.F.retain_dup = (uint8_t)((cmsg->data.retain&0x0F)<<4 | (cmsg->data.dup&0x0F));
chunk.F.direction = (uint8_t)cmsg->data.direction;
chunk.F.state = (uint8_t)cmsg->data.state;
chunk.client_id = context->id;
chunk.clientid = context->id;
chunk.subscription_identifier = cmsg->data.subscription_identifier;
rc = persist__chunk_client_msg_write_v6(db_fptr, &chunk);
@ -178,7 +178,7 @@ static int persist__client_save(FILE *db_fptr)
chunk.F.session_expiry_interval = context->session_expiry_interval;
chunk.F.last_mid = context->last_mid;
chunk.F.id_len = (uint16_t)strlen(context->id);
chunk.client_id = context->id;
chunk.clientid = context->id;
if(context->username){
chunk.F.username_len = (uint16_t)strlen(context->username);
chunk.username = context->username;
@ -237,7 +237,7 @@ static int persist__subs_save(FILE *db_fptr, struct mosquitto__subhier *node, co
sub_chunk.F.topic_len = (uint16_t)strlen(thistopic);
sub_chunk.F.qos = MQTT_SUB_OPT_GET_QOS(sub->subscription_options);
sub_chunk.F.options = sub->subscription_options & 0xFC;
sub_chunk.client_id = sub->context->id;
sub_chunk.clientid = sub->context->id;
sub_chunk.topic = thistopic;
rc = persist__chunk_sub_write_v6(db_fptr, &sub_chunk);

6
src/persist_write_v5.c
Unescape Escape View File

@ -74,7 +74,7 @@ int persist__chunk_client_write_v6(FILE *db_fptr, struct P_client *chunk)
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_client));
write_e(db_fptr, chunk->client_id, id_len);
write_e(db_fptr, chunk->clientid, id_len);
if(username_len > 0){
write_e(db_fptr, chunk->username, username_len);
}
@ -113,7 +113,7 @@ int persist__chunk_client_msg_write_v6(FILE *db_fptr, struct P_client_msg *chunk
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_client_msg));
write_e(db_fptr, chunk->client_id, id_len);
write_e(db_fptr, chunk->clientid, id_len);
if(chunk->subscription_identifier){
if(proplen > 0){
prop_packet = calloc(1, sizeof(struct mosquitto__packet)+proplen);
@ -241,7 +241,7 @@ int persist__chunk_sub_write_v6(FILE *db_fptr, struct P_sub *chunk)
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_sub));
write_e(db_fptr, chunk->client_id, id_len);
write_e(db_fptr, chunk->clientid, id_len);
write_e(db_fptr, chunk->topic, topic_len);
return MOSQ_ERR_SUCCESS;

16
src/plugin_persist.c
Unescape Escape View File

@ -59,7 +59,7 @@ void plugin_persist__handle_client_add(struct mosquitto *context)
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.username = context->username;
event_data.data.auth_method = context->auth_method;
event_data.data.will_delay_time = context->will_delay_time;
@ -95,7 +95,7 @@ void plugin_persist__handle_client_update(struct mosquitto *context)
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.username = context->username;
event_data.data.auth_method = context->auth_method;
event_data.data.will_delay_time = context->will_delay_time;
@ -133,7 +133,7 @@ void plugin_persist__handle_client_delete(struct mosquitto *context)
}
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
DL_FOREACH(opts->plugin_callbacks.persist_client_delete, cb_base){
cb_base->cb(MOSQ_EVT_PERSIST_CLIENT_DELETE, &event_data, cb_base->userdata);
@ -152,7 +152,7 @@ void plugin_persist__handle_subscription_add(struct mosquitto *context, const st
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.topic_filter = sub->topic_filter;
event_data.data.identifier = sub->identifier;
event_data.data.options = sub->options;
@ -174,7 +174,7 @@ void plugin_persist__handle_subscription_delete(struct mosquitto *context, char
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.topic_filter = sub;
DL_FOREACH(opts->plugin_callbacks.persist_subscription_delete, cb_base){
@ -199,7 +199,7 @@ void plugin_persist__handle_client_msg_add(struct mosquitto *context, const stru
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.cmsg_id = client_msg->data.cmsg_id;
event_data.data.store_id = client_msg->base_msg->data.store_id;
event_data.data.mid = client_msg->data.mid;
@ -231,7 +231,7 @@ void plugin_persist__handle_client_msg_delete(struct mosquitto *context, const s
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.cmsg_id = client_msg->data.cmsg_id;
event_data.data.mid = client_msg->data.mid;
event_data.data.state = (uint8_t)client_msg->data.state;
@ -261,7 +261,7 @@ void plugin_persist__handle_client_msg_update(struct mosquitto *context, const s
opts = &db.config->security_options;
memset(&event_data, 0, sizeof(event_data));
event_data.data.client_id = context->id;
event_data.data.clientid = context->id;
event_data.data.cmsg_id = client_msg->data.cmsg_id;
event_data.data.mid = client_msg->data.mid;
event_data.data.store_id = client_msg->base_msg->data.store_id;

60
src/plugin_public.c
Unescape Escape View File

@ -60,16 +60,16 @@ BROKER_EXPORT const char *mosquitto_client_address(const struct mosquitto *clien
}
BROKER_EXPORT struct mosquitto *mosquitto_client(const char *client_id)
BROKER_EXPORT struct mosquitto *mosquitto_client(const char *clientid)
{
size_t len;
struct mosquitto *context;
if(!client_id) return NULL;
len = strlen(client_id);
if(!clientid) return NULL;
len = strlen(clientid);
if(len == 0) return NULL;
HASH_FIND(hh_id, db.contexts_by_id, client_id, strlen(client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, clientid, strlen(clientid), context);
return context;
}
@ -470,13 +470,13 @@ BROKER_EXPORT int mosquitto_persist_client_add(struct mosquitto_client *client)
if(client == NULL){
return MOSQ_ERR_INVAL;
}
if(client->client_id == NULL){
if(client->clientid == NULL){
rc = MOSQ_ERR_INVAL;
goto error;
}
context = NULL;
HASH_FIND(hh_id, db.contexts_by_id, client->client_id, strlen(client->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, client->clientid, strlen(client->clientid), context);
if(context){
rc = MOSQ_ERR_INVAL;
goto error;
@ -488,8 +488,8 @@ BROKER_EXPORT int mosquitto_persist_client_add(struct mosquitto_client *client)
goto error;
}
context->id = client->client_id;
client->client_id = NULL;
context->id = client->clientid;
client->clientid = NULL;
context->username = client->username;
client->username = NULL;
context->auth_method = client->auth_method;
@ -519,7 +519,7 @@ BROKER_EXPORT int mosquitto_persist_client_add(struct mosquitto_client *client)
return MOSQ_ERR_SUCCESS;
error:
SAFE_FREE(client->client_id);
SAFE_FREE(client->clientid);
SAFE_FREE(client->username);
SAFE_FREE(client->auth_method);
return rc;
@ -535,13 +535,13 @@ BROKER_EXPORT int mosquitto_persist_client_update(struct mosquitto_client *clien
if(client == NULL){
return MOSQ_ERR_INVAL;
}
if(client->client_id == NULL){
if(client->clientid == NULL){
rc = MOSQ_ERR_INVAL;
goto error;
}
context = NULL;
HASH_FIND(hh_id, db.contexts_by_id, client->client_id, strlen(client->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, client->clientid, strlen(client->clientid), context);
if(context == NULL){
rc = MOSQ_ERR_NOT_FOUND;
goto error;
@ -577,14 +577,14 @@ error:
}
BROKER_EXPORT int mosquitto_persist_client_delete(const char *client_id)
BROKER_EXPORT int mosquitto_persist_client_delete(const char *clientid)
{
struct mosquitto *context;
if(client_id == NULL) return MOSQ_ERR_INVAL;
if(clientid == NULL) return MOSQ_ERR_INVAL;
context = NULL;
HASH_FIND(hh_id, db.contexts_by_id, client_id, strlen(client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, clientid, strlen(clientid), context);
if(context == NULL){
return MOSQ_ERR_SUCCESS;
}
@ -616,11 +616,11 @@ BROKER_EXPORT int mosquitto_persist_client_msg_add(struct mosquitto_client_msg *
struct mosquitto *context;
struct mosquitto__base_msg *base_msg;
if(client_msg == NULL || client_msg->client_id == NULL){
if(client_msg == NULL || client_msg->clientid == NULL){
return MOSQ_ERR_INVAL;
}
HASH_FIND(hh_id, db.contexts_by_id, client_msg->client_id, strlen(client_msg->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, client_msg->clientid, strlen(client_msg->clientid), context);
if(context == NULL){
return MOSQ_ERR_NOT_FOUND;
}
@ -649,9 +649,9 @@ BROKER_EXPORT int mosquitto_persist_client_msg_delete(struct mosquitto_client_ms
{
struct mosquitto *context;
if(client_msg == NULL || client_msg->client_id == NULL) return MOSQ_ERR_INVAL;
if(client_msg == NULL || client_msg->clientid == NULL) return MOSQ_ERR_INVAL;
HASH_FIND(hh_id, db.contexts_by_id, client_msg->client_id, strlen(client_msg->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, client_msg->clientid, strlen(client_msg->clientid), context);
if(context == NULL){
return MOSQ_ERR_NOT_FOUND;
}
@ -671,9 +671,9 @@ BROKER_EXPORT int mosquitto_persist_client_msg_update(struct mosquitto_client_ms
{
struct mosquitto *context;
if(client_msg == NULL || client_msg->client_id == NULL) return MOSQ_ERR_INVAL;
if(client_msg == NULL || client_msg->clientid == NULL) return MOSQ_ERR_INVAL;
HASH_FIND(hh_id, db.contexts_by_id, client_msg->client_id, strlen(client_msg->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, client_msg->clientid, strlen(client_msg->clientid), context);
if(context == NULL){
return MOSQ_ERR_NOT_FOUND;
}
@ -693,9 +693,9 @@ BROKER_EXPORT int mosquitto_persist_client_msg_clear(struct mosquitto_client_msg
{
struct mosquitto *context;
if(client_msg == NULL || client_msg->client_id == NULL) return MOSQ_ERR_INVAL;
if(client_msg == NULL || client_msg->clientid == NULL) return MOSQ_ERR_INVAL;
HASH_FIND(hh_id, db.contexts_by_id, client_msg->client_id, strlen(client_msg->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, client_msg->clientid, strlen(client_msg->clientid), context);
if(context == NULL){
return MOSQ_ERR_NOT_FOUND;
}
@ -713,11 +713,11 @@ BROKER_EXPORT int mosquitto_subscription_add(const struct mosquitto_subscription
{
struct mosquitto *context;
if(sub == NULL || sub->client_id == NULL || sub->topic_filter == NULL || sub->client_id[0] == '\0' || sub->topic_filter[0] == '\0'){
if(sub == NULL || sub->clientid == NULL || sub->topic_filter == NULL || sub->clientid[0] == '\0' || sub->topic_filter[0] == '\0'){
return MOSQ_ERR_INVAL;
}
HASH_FIND(hh_id, db.contexts_by_id, sub->client_id, strlen(sub->client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, sub->clientid, strlen(sub->clientid), context);
if(context){
return sub__add(context, sub);
@ -727,16 +727,16 @@ BROKER_EXPORT int mosquitto_subscription_add(const struct mosquitto_subscription
}
BROKER_EXPORT int mosquitto_subscription_delete(const char *client_id, const char *topic)
BROKER_EXPORT int mosquitto_subscription_delete(const char *clientid, const char *topic)
{
struct mosquitto *context;
uint8_t reason;
if(client_id == NULL || topic == NULL || client_id[0] == '\0' || topic[0] == '\0'){
if(clientid == NULL || topic == NULL || clientid[0] == '\0' || topic[0] == '\0'){
return MOSQ_ERR_INVAL;
}
HASH_FIND(hh_id, db.contexts_by_id, client_id, strlen(client_id), context);
HASH_FIND(hh_id, db.contexts_by_id, clientid, strlen(clientid), context);
if(context){
return sub__remove(context, topic, &reason);
@ -836,13 +836,13 @@ BROKER_EXPORT int mosquitto_persist_base_msg_delete(uint64_t store_id)
}
BROKER_EXPORT void mosquitto_complete_basic_auth(const char *client_id, int result)
BROKER_EXPORT void mosquitto_complete_basic_auth(const char *clientid, int result)
{
struct mosquitto *context;
if(client_id == NULL) return;
if(clientid == NULL) return;
HASH_FIND(hh_id, db.contexts_by_id_delayed_auth, client_id, strlen(client_id), context);
HASH_FIND(hh_id, db.contexts_by_id_delayed_auth, clientid, strlen(clientid), context);
if(context){
HASH_DELETE(hh_id, db.contexts_by_id_delayed_auth, context);
if(result == MOSQ_ERR_SUCCESS){

2
test/broker/c/auth_plugin_context_params.c
Unescape Escape View File

@ -78,7 +78,7 @@ int mosquitto_auth_unpwd_check(void *user_data, struct mosquitto *client, const
tmp = mosquitto_client_id(client);
if(!tmp || strcmp(tmp, "client-params-test")){
fprintf(stderr, "mosquitto_auth_unpwd_check client_id error: %s\n", tmp);
fprintf(stderr, "mosquitto_auth_unpwd_check clientid error: %s\n", tmp);
return MOSQ_ERR_AUTH;
}

18
test/broker/c/auth_plugin_delayed.c
Unescape Escape View File

@ -12,7 +12,7 @@ static mosquitto_plugin_id_t *plg_id;
static char *username = NULL;
static char *password = NULL;
static char *client_id = NULL;
static char *clientid = NULL;
static int auth_delay = -1;
MOSQUITTO_PLUGIN_DECLARE_VERSION(5);
@ -39,7 +39,7 @@ int mosquitto_plugin_cleanup(void *user_data, struct mosquitto_opt *auth_opts, i
free(username);
free(password);
free(client_id);
free(clientid);
mosquitto_callback_unregister(plg_id, MOSQ_EVT_BASIC_AUTH, unpwd_check_callback, NULL);
mosquitto_callback_unregister(plg_id, MOSQ_EVT_TICK, tick_callback, NULL);
@ -58,19 +58,19 @@ static int tick_callback(int event, void *event_data, void *user_data)
}
if(auth_delay == 0){
if(client_id && username && password
if(clientid && username && password
&& !strcmp(username, "delayed-username") && !strcmp(password, "good")){
mosquitto_complete_basic_auth(client_id, MOSQ_ERR_SUCCESS);
mosquitto_complete_basic_auth(clientid, MOSQ_ERR_SUCCESS);
}else{
mosquitto_complete_basic_auth(client_id, MOSQ_ERR_AUTH);
mosquitto_complete_basic_auth(clientid, MOSQ_ERR_AUTH);
}
free(username);
free(password);
free(client_id);
free(clientid);
username = NULL;
password = NULL;
client_id = NULL;
clientid = NULL;
}else if(auth_delay > 0){
auth_delay--;
}
@ -90,7 +90,7 @@ static int unpwd_check_callback(int event, void *event_data, void *user_data)
free(username);
free(password);
free(client_id);
free(clientid);
if(ed->username){
username = strdup(ed->username);
@ -98,7 +98,7 @@ static int unpwd_check_callback(int event, void *event_data, void *user_data)
if(ed->password){
password = strdup(ed->password);
}
client_id = strdup(mosquitto_client_id(ed->client));
clientid = strdup(mosquitto_client_id(ed->client));
/* Delay for arbitrary 10 ticks */
auth_delay = 10;

Write Preview
Loading…
Cancel
Save