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

Move control common helper functions to broker.

Browse Source
pull/2756/merge
Roger A. Light 3 years ago
parent 53dc3006a2
commit 2940d9cc4c
16 changed files with 345 additions and 341 deletions
Show Stats Download Patch File Download Diff File

19
common/control_common.h
Unescape Escape View File

@ -1,19 +0,0 @@
#ifndef CONTROLLUGIN_COMMON_H
#define CONTROLLUGIN_COMMON_H
#include <cjson/cJSON.h>
#include "mosquitto_broker.h"
struct control_cmd{
cJSON *j_responses;
cJSON *j_command;
char *correlation_data;
const char *command_name;
};
void control__command_reply(struct control_cmd *cmd, const char *error);
void control__send_response(cJSON *tree, const char* topic);
int control__generic_control_callback(struct mosquitto_evt_control *event_data, const char *response_topic, void *userdata,
int (*cmd_cb)(struct control_cmd *cmd, struct mosquitto *context, void *userdata));
#endif

19
include/mosquitto_broker.h
Unescape Escape View File

@ -38,6 +38,7 @@ extern "C" {
#include <stddef.h>
#include <stdint.h>
#include <time.h>
#include <cjson/cJSON.h>
#include <mosquitto.h>
#include <mqtt_protocol.h>
@ -1245,6 +1246,24 @@ mosq_EXPORT int mosquitto_persist_retain_msg_delete(const char *topic);
*/
mosq_EXPORT const char *mosquitto_persistence_location(void);
/* =========================================================================
*
* Section: $CONTROL event helpers
*
* ========================================================================= */
struct mosquitto_control_cmd{
cJSON *j_responses;
cJSON *j_command;
char *correlation_data;
const char *command_name;
};
mosq_EXPORT void mosquitto_control_command_reply(struct mosquitto_control_cmd *cmd, const char *error);
mosq_EXPORT void mosquitto_control_send_response(cJSON *tree, const char* topic);
mosq_EXPORT int mosquitto_control_generic_callback(struct mosquitto_evt_control *event_data, const char *response_topic, void *userdata,
int (*cmd_cb)(struct mosquitto_control_cmd *cmd, struct mosquitto *context, void *userdata));
#ifdef __cplusplus
}
#endif

1
plugins/dynamic-security/CMakeLists.txt
Unescape Escape View File

@ -21,7 +21,6 @@ if(CJSON_FOUND AND WITH_TLS)
config.c
config_init.c
control.c
../../common/control_common.c ../../common/control_common.h
default_acl.c
dynamic_security.h
groups.c

4
plugins/dynamic-security/Makefile
Unescape Escape View File

@ -18,7 +18,6 @@ OBJS= \
config.o \
config_init.o \
control.o \
control_common.o \
default_acl.o \
groups.o \
grouplist.o \
@ -95,9 +94,6 @@ password_mosq.o : ${R}/common/password_mosq.c ${R}/common/password_mosq.h
plugin.o : plugin.c dynamic_security.h
${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(PLUGIN_CPPFLAGS) $(PLUGIN_CFLAGS) -c $< -o $@
control_common.o : ${R}/common/control_common.c ${R}/common/control_common.h
${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(PLUGIN_CPPFLAGS) $(PLUGIN_CFLAGS) -c $< -o $@
roles.o : roles.c dynamic_security.h
${CROSS_COMPILE}${CC} $(LOCAL_CPPFLAGS) $(PLUGIN_CPPFLAGS) $(PLUGIN_CFLAGS) -c $< -o $@

186
plugins/dynamic-security/clients.c
Unescape Escape View File

@ -316,7 +316,7 @@ int dynsec_clients__config_save(struct dynsec__data *data, cJSON *tree)
}
int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_create(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *password, *clientid = NULL;
char *text_name, *text_description;
@ -328,53 +328,53 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
size_t username_len;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
username_len = strlen(username);
if(username_len == 0){
control__command_reply(cmd, "Empty username");
mosquitto_control_command_reply(cmd, "Empty username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)username_len) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "password", &password, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing password");
mosquitto_control_command_reply(cmd, "Invalid/missing password");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "clientid", &clientid, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing client id");
mosquitto_control_command_reply(cmd, "Invalid/missing client id");
return MOSQ_ERR_INVAL;
}
if(clientid && mosquitto_validate_utf8(clientid, (int)strlen(clientid)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Client ID not valid UTF-8");
mosquitto_control_command_reply(cmd, "Client ID not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textname", &text_name, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing textname");
mosquitto_control_command_reply(cmd, "Invalid/missing textname");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textdescription", &text_description, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing textdescription");
mosquitto_control_command_reply(cmd, "Invalid/missing textdescription");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client){
control__command_reply(cmd, "Client already exists");
mosquitto_control_command_reply(cmd, "Client already exists");
return MOSQ_ERR_SUCCESS;
}
client = mosquitto_calloc(1, sizeof(struct dynsec__client) + username_len + 1);
if(client == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
strncpy(client->username, username, username_len);
@ -382,7 +382,7 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
if(text_name){
client->text_name = mosquitto_strdup(text_name);
if(client->text_name == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
client__free_item(data, client);
return MOSQ_ERR_NOMEM;
}
@ -390,7 +390,7 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
if(text_description){
client->text_description = mosquitto_strdup(text_description);
if(client->text_description == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
client__free_item(data, client);
return MOSQ_ERR_NOMEM;
}
@ -398,7 +398,7 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
if(password){
if(dynsec_auth__pw_hash(client, password, client->pw.password_hash, sizeof(client->pw.password_hash), true)){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
client__free_item(data, client);
return MOSQ_ERR_NOMEM;
}
@ -407,7 +407,7 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
if(clientid && strlen(clientid) > 0){
client->clientid = mosquitto_strdup(clientid);
if(client->clientid == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
client__free_item(data, client);
return MOSQ_ERR_NOMEM;
}
@ -416,14 +416,14 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
rc = dynsec_rolelist__load_from_json(data, cmd->j_command, &client->rolelist);
if(rc == MOSQ_ERR_SUCCESS || rc == ERR_LIST_NOT_FOUND){
}else if(rc == MOSQ_ERR_NOT_FOUND){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
client__free_item(data, client);
return MOSQ_ERR_INVAL;
}else{
if(rc == MOSQ_ERR_INVAL){
control__command_reply(cmd, "'roles' not an array or missing/invalid rolename");
mosquitto_control_command_reply(cmd, "'roles' not an array or missing/invalid rolename");
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
}
client__free_item(data, client);
return MOSQ_ERR_INVAL;
@ -441,11 +441,11 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
json_get_int(j_group, "priority", &priority, true, -1);
rc = dynsec_groups__add_client(data, username, jtmp->valuestring, priority, false);
if(rc == ERR_GROUP_NOT_FOUND){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
client__free_item(data, client);
return MOSQ_ERR_INVAL;
}else if(rc != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
client__free_item(data, client);
return MOSQ_ERR_INVAL;
}
@ -456,7 +456,7 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);
@ -467,14 +467,14 @@ int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd
}
int dynsec_clients__process_delete(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_delete(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username;
struct dynsec__client *client;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
@ -484,7 +484,7 @@ int dynsec_clients__process_delete(struct dynsec__data *data, struct control_cmd
client__remove_all_roles(client);
client__free_item(data, client);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, username);
@ -496,29 +496,29 @@ int dynsec_clients__process_delete(struct dynsec__data *data, struct control_cmd
return MOSQ_ERR_SUCCESS;
}else{
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
}
int dynsec_clients__process_disable(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_disable(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username;
struct dynsec__client *client;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
@ -527,7 +527,7 @@ int dynsec_clients__process_disable(struct dynsec__data *data, struct control_cm
dynsec_kicklist__add(data, username);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);
@ -538,31 +538,31 @@ int dynsec_clients__process_disable(struct dynsec__data *data, struct control_cm
}
int dynsec_clients__process_enable(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_enable(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username;
struct dynsec__client *client;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
client->disabled = false;
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);
@ -573,7 +573,7 @@ int dynsec_clients__process_enable(struct dynsec__data *data, struct control_cmd
}
int dynsec_clients__process_set_id(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_set_id(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *clientid, *clientid_heap = NULL;
struct dynsec__client *client;
@ -581,28 +581,28 @@ int dynsec_clients__process_set_id(struct dynsec__data *data, struct control_cmd
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "clientid", &clientid, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing client ID");
mosquitto_control_command_reply(cmd, "Invalid/missing client ID");
return MOSQ_ERR_INVAL;
}
if(clientid){
slen = strlen(clientid);
if(mosquitto_validate_utf8(clientid, (int)slen) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Client ID not valid UTF-8");
mosquitto_control_command_reply(cmd, "Client ID not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(slen > 0){
clientid_heap = mosquitto_strdup(clientid);
if(clientid_heap == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
}else{
@ -613,7 +613,7 @@ int dynsec_clients__process_set_id(struct dynsec__data *data, struct control_cmd
client = dynsec_clients__find(data, username);
if(client == NULL){
mosquitto_free(clientid_heap);
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
@ -621,7 +621,7 @@ int dynsec_clients__process_set_id(struct dynsec__data *data, struct control_cmd
client->clientid = clientid_heap;
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, username);
@ -648,7 +648,7 @@ static int client__set_password(struct dynsec__client *client, const char *passw
}
}
int dynsec_clients__process_set_password(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_set_password(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *password;
struct dynsec__client *client;
@ -656,32 +656,32 @@ int dynsec_clients__process_set_password(struct dynsec__data *data, struct contr
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "password", &password, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing password");
mosquitto_control_command_reply(cmd, "Invalid/missing password");
return MOSQ_ERR_INVAL;
}
if(strlen(password) == 0){
control__command_reply(cmd, "Empty password is not allowed");
mosquitto_control_command_reply(cmd, "Empty password is not allowed");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
rc = client__set_password(client, password);
if(rc == MOSQ_ERR_SUCCESS){
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, username);
@ -691,7 +691,7 @@ int dynsec_clients__process_set_password(struct dynsec__data *data, struct contr
mosquitto_log_printf(MOSQ_LOG_INFO, "dynsec: %s/%s | setClientPassword | username=%s | password=******",
admin_clientid, admin_username, username);
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
}
return rc;
}
@ -715,7 +715,7 @@ static void client__remove_all_roles(struct dynsec__client *client)
}
}
int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_modify(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username;
char *clientid = NULL;
@ -732,17 +732,17 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_INVAL;
}
@ -751,7 +751,7 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
if(str && strlen(str) > 0){
clientid = mosquitto_strdup(str);
if(clientid == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -770,7 +770,7 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
have_text_name = true;
text_name = mosquitto_strdup(str);
if(text_name == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -780,7 +780,7 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
have_text_description = true;
text_description = mosquitto_strdup(str);
if(text_description == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -792,14 +792,14 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
}else if(rc == ERR_LIST_NOT_FOUND){
/* There was no list in the JSON, so no modification */
}else if(rc == MOSQ_ERR_NOT_FOUND){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
rc = MOSQ_ERR_INVAL;
goto error;
}else{
if(rc == MOSQ_ERR_INVAL){
control__command_reply(cmd, "'roles' not an array or missing/invalid rolename");
mosquitto_control_command_reply(cmd, "'roles' not an array or missing/invalid rolename");
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
}
rc = MOSQ_ERR_INVAL;
goto error;
@ -814,12 +814,12 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
if(jtmp && cJSON_IsString(jtmp)){
group = dynsec_groups__find(data, jtmp->valuestring);
if(group == NULL){
control__command_reply(cmd, "'groups' contains an object with a 'groupname' that does not exist");
mosquitto_control_command_reply(cmd, "'groups' contains an object with a 'groupname' that does not exist");
rc = MOSQ_ERR_INVAL;
goto error;
}
}else{
control__command_reply(cmd, "'groups' contains an object with an invalid 'groupname'");
mosquitto_control_command_reply(cmd, "'groups' contains an object with an invalid 'groupname'");
rc = MOSQ_ERR_INVAL;
goto error;
}
@ -842,7 +842,7 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
/* FIXME - This is the one call that will result in modification on internal error - note that groups have already been modified */
rc = client__set_password(client, password);
if(rc != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
mosquitto_kick_client_by_username(username, false);
/* If this fails we have the situation that the password is set as
* invalid, but the config isn't saved, so restarting the broker
@ -877,7 +877,7 @@ int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd
}
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, username);
@ -1012,7 +1012,7 @@ static cJSON *add_client_to_json(struct dynsec__client *client, bool verbose)
}
int dynsec_clients__process_get(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_get(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username;
struct dynsec__client *client;
@ -1020,23 +1020,23 @@ int dynsec_clients__process_get(struct dynsec__data *data, struct control_cmd *c
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -1046,14 +1046,14 @@ int dynsec_clients__process_get(struct dynsec__data *data, struct control_cmd *c
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
j_client = add_client_to_json(client, true);
if(j_client == NULL){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
cJSON_AddItemToObject(j_data, "client", j_client);
@ -1068,7 +1068,7 @@ int dynsec_clients__process_get(struct dynsec__data *data, struct control_cmd *c
}
int dynsec_clients__process_list(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_list(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
bool verbose;
struct dynsec__client *client, *client_tmp;
@ -1082,7 +1082,7 @@ int dynsec_clients__process_list(struct dynsec__data *data, struct control_cmd *
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -1094,7 +1094,7 @@ int dynsec_clients__process_list(struct dynsec__data *data, struct control_cmd *
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -1104,7 +1104,7 @@ int dynsec_clients__process_list(struct dynsec__data *data, struct control_cmd *
j_client = add_client_to_json(client, verbose);
if(j_client == NULL){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
cJSON_AddItemToArray(j_clients, j_client);
@ -1129,7 +1129,7 @@ int dynsec_clients__process_list(struct dynsec__data *data, struct control_cmd *
}
int dynsec_clients__process_add_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_add_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *rolename;
struct dynsec__client *client;
@ -1138,42 +1138,42 @@ int dynsec_clients__process_add_role(struct dynsec__data *data, struct control_c
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
json_get_int(cmd->j_command, "priority", &priority, true, -1);
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
if(dynsec_rolelist__client_add(client, role, priority) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_UNKNOWN;
}
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, username);
@ -1187,7 +1187,7 @@ int dynsec_clients__process_add_role(struct dynsec__data *data, struct control_c
}
int dynsec_clients__process_remove_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_clients__process_remove_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *rolename;
struct dynsec__client *client;
@ -1195,39 +1195,39 @@ int dynsec_clients__process_remove_role(struct dynsec__data *data, struct contro
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
client = dynsec_clients__find(data, username);
if(client == NULL){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
return MOSQ_ERR_SUCCESS;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
dynsec_rolelist__client_remove(client, role);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, username);

6
plugins/dynamic-security/control.c
Unescape Escape View File

@ -35,7 +35,7 @@ Contributors:
#define RESPONSE_TOPIC "$CONTROL/dynamic-security/v1/response"
static int dynsec__handle_command(struct control_cmd *cmd, struct mosquitto *context, void *userdata)
static int dynsec__handle_command(struct mosquitto_control_cmd *cmd, struct mosquitto *context, void *userdata)
{
struct dynsec__data *data = userdata;
int rc = MOSQ_ERR_SUCCESS;
@ -112,7 +112,7 @@ static int dynsec__handle_command(struct control_cmd *cmd, struct mosquitto *con
/* Unknown */
}else{
control__command_reply(cmd, "Unknown command");
mosquitto_control_command_reply(cmd, "Unknown command");
rc = MOSQ_ERR_INVAL;
}
@ -129,7 +129,7 @@ int dynsec_control_callback(int event, void *event_data, void *userdata)
UNUSED(event);
data->need_save = false;
rc = control__generic_control_callback(ed, RESPONSE_TOPIC, userdata, dynsec__handle_command);
rc = mosquitto_control_generic_callback(ed, RESPONSE_TOPIC, userdata, dynsec__handle_command);
if(rc == MOSQ_ERR_SUCCESS && data->need_save){
dynsec__config_save(data);
}

13
plugins/dynamic-security/default_acl.c
Unescape Escape View File

@ -30,11 +30,10 @@ Contributors:
#include "mosquitto_broker.h"
#include "mosquitto_plugin.h"
#include "mqtt_protocol.h"
#include "control_common.h"
#include "dynamic_security.h"
int dynsec__process_set_default_acl_access(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec__process_set_default_acl_access(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
cJSON *j_actions, *j_action, *j_acltype, *j_allow;
bool allow;
@ -42,7 +41,7 @@ int dynsec__process_set_default_acl_access(struct dynsec__data *data, struct con
j_actions = cJSON_GetObjectItem(cmd->j_command, "acls");
if(j_actions == NULL || !cJSON_IsArray(j_actions)){
control__command_reply(cmd, "Missing/invalid actions array");
mosquitto_control_command_reply(cmd, "Missing/invalid actions array");
return MOSQ_ERR_INVAL;
}
@ -72,19 +71,19 @@ int dynsec__process_set_default_acl_access(struct dynsec__data *data, struct con
}
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
return MOSQ_ERR_SUCCESS;
}
int dynsec__process_get_default_acl_access(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec__process_get_default_acl_access(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
cJSON *tree, *jtmp, *j_data, *j_acls, *j_acl;
const char *admin_clientid, *admin_username;
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -170,6 +169,6 @@ int dynsec__process_get_default_acl_access(struct dynsec__data *data, struct con
internal_error:
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}

64
plugins/dynamic-security/dynamic_security.h
Unescape Escape View File

@ -21,9 +21,9 @@ Contributors:
#include <cjson/cJSON.h>
#include <uthash.h>
#include "mosquitto.h"
#include "mosquitto_broker.h"
#include "password_mosq.h"
#include "base64_mosq.h"
#include "control_common.h"
/* ################################################################
* #
@ -178,8 +178,8 @@ int dynsec_control_callback(int event, void *event_data, void *userdata);
* ################################################################ */
int dynsec__acl_check_callback(int event, void *event_data, void *userdata);
int dynsec__process_set_default_acl_access(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec__process_get_default_acl_access(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec__process_set_default_acl_access(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec__process_get_default_acl_access(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
/* ################################################################
@ -201,17 +201,17 @@ int dynsec_auth__basic_auth_callback(int event, void *event_data, void *userdata
void dynsec_clients__cleanup(struct dynsec__data *data);
int dynsec_clients__config_load(struct dynsec__data *data, cJSON *tree);
int dynsec_clients__config_save(struct dynsec__data *data, cJSON *tree);
int dynsec_clients__process_add_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_create(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_delete(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_disable(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_enable(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_get(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_list(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_modify(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_remove_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_set_id(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_set_password(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_add_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_create(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_delete(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_disable(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_enable(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_get(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_list(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_modify(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_remove_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_set_id(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_clients__process_set_password(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
struct dynsec__client *dynsec_clients__find(struct dynsec__data *data, const char *username);
@ -238,17 +238,17 @@ void dynsec_groups__cleanup(struct dynsec__data *data);
int dynsec_groups__config_load(struct dynsec__data *data, cJSON *tree);
int dynsec_groups__add_client(struct dynsec__data *data, const char *username, const char *groupname, int priority, bool update_config);
int dynsec_groups__config_save(struct dynsec__data *data, cJSON *tree);
int dynsec_groups__process_add_client(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_add_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_create(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_delete(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_get(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_remove_client(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_remove_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_get_anonymous_group(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_set_anonymous_group(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_add_client(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_add_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_create(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_delete(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_get(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_list(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_modify(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_remove_client(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_remove_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_get_anonymous_group(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__process_set_anonymous_group(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_groups__remove_client(struct dynsec__data *data, const char *username, const char *groupname, bool update_config);
struct dynsec__group *dynsec_groups__find(struct dynsec__data *data, const char *groupname);
@ -274,13 +274,13 @@ void dynsec_grouplist__remove(struct dynsec__grouplist **base_grouplist, struct
void dynsec_roles__cleanup(struct dynsec__data *data);
int dynsec_roles__config_load(struct dynsec__data *data, cJSON *tree);
int dynsec_roles__config_save(struct dynsec__data *data, cJSON *tree);
int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_create(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_delete(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_get(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_list(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_modify(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_add_acl(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_create(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_delete(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_get(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_list(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_modify(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context);
struct dynsec__role *dynsec_roles__find(struct dynsec__data *data, const char *rolename);

176
plugins/dynamic-security/groups.c
Unescape Escape View File

@ -102,7 +102,7 @@ static void group__free_item(struct dynsec__data *data, struct dynsec__group *gr
mosquitto_free(group);
}
int dynsec_groups__process_add_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_add_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname, *rolename;
struct dynsec__group *group;
@ -112,33 +112,33 @@ int dynsec_groups__process_add_role(struct dynsec__data *data, struct control_cm
int rc;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
json_get_int(cmd->j_command, "priority", &priority, true, -1);
group = dynsec_groups__find(data, groupname);
if(group == NULL){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
return MOSQ_ERR_SUCCESS;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
@ -149,10 +149,10 @@ int dynsec_groups__process_add_role(struct dynsec__data *data, struct control_cm
if(rc == MOSQ_ERR_SUCCESS){
/* Continue */
}else if(rc == MOSQ_ERR_ALREADY_EXISTS){
control__command_reply(cmd, "Group is already in this role");
mosquitto_control_command_reply(cmd, "Group is already in this role");
return MOSQ_ERR_ALREADY_EXISTS;
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_UNKNOWN;
}
@ -160,7 +160,7 @@ int dynsec_groups__process_add_role(struct dynsec__data *data, struct control_cm
admin_clientid, admin_username, groupname, rolename, priority);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
group__kick_all(data, group);
@ -356,7 +356,7 @@ int dynsec_groups__config_save(struct dynsec__data *data, cJSON *tree)
}
int dynsec_groups__process_create(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_create(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname, *text_name, *text_description;
struct dynsec__group *group = NULL;
@ -365,45 +365,45 @@ int dynsec_groups__process_create(struct dynsec__data *data, struct control_cmd
size_t groupname_len;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
groupname_len = strlen(groupname);
if(groupname_len == 0){
control__command_reply(cmd, "Empty groupname");
mosquitto_control_command_reply(cmd, "Empty groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)groupname_len) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textname", &text_name, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing textname");
mosquitto_control_command_reply(cmd, "Invalid/missing textname");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textdescription", &text_description, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing textdescription");
mosquitto_control_command_reply(cmd, "Invalid/missing textdescription");
return MOSQ_ERR_INVAL;
}
group = dynsec_groups__find(data, groupname);
if(group){
control__command_reply(cmd, "Group already exists");
mosquitto_control_command_reply(cmd, "Group already exists");
return MOSQ_ERR_SUCCESS;
}
group = mosquitto_calloc(1, sizeof(struct dynsec__group) + groupname_len + 1);
if(group == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
strncpy(group->groupname, groupname, groupname_len+1);
if(text_name){
group->text_name = strdup(text_name);
if(group->text_name == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
group__free_item(data, group);
return MOSQ_ERR_NOMEM;
}
@ -411,7 +411,7 @@ int dynsec_groups__process_create(struct dynsec__data *data, struct control_cmd
if(text_description){
group->text_description = strdup(text_description);
if(group->text_description == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
group__free_item(data, group);
return MOSQ_ERR_NOMEM;
}
@ -420,11 +420,11 @@ int dynsec_groups__process_create(struct dynsec__data *data, struct control_cmd
rc = dynsec_rolelist__load_from_json(data, cmd->j_command, &group->rolelist);
if(rc == MOSQ_ERR_SUCCESS || rc == ERR_LIST_NOT_FOUND){
}else if(rc == MOSQ_ERR_NOT_FOUND){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
group__free_item(data, group);
return MOSQ_ERR_INVAL;
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
group__free_item(data, group);
return MOSQ_ERR_INVAL;
}
@ -437,30 +437,30 @@ int dynsec_groups__process_create(struct dynsec__data *data, struct control_cmd
admin_clientid, admin_username, groupname);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
return MOSQ_ERR_SUCCESS;
}
int dynsec_groups__process_delete(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_delete(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname;
struct dynsec__group *group;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
group = dynsec_groups__find(data, groupname);
if(group){
if(group == data->anonymous_group){
control__command_reply(cmd, "Deleting the anonymous group is forbidden");
mosquitto_control_command_reply(cmd, "Deleting the anonymous group is forbidden");
return MOSQ_ERR_INVAL;
}
@ -470,7 +470,7 @@ int dynsec_groups__process_delete(struct dynsec__data *data, struct control_cmd
dynsec__remove_all_roles_from_group(group);
group__free_item(data, group);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);
@ -479,7 +479,7 @@ int dynsec_groups__process_delete(struct dynsec__data *data, struct control_cmd
return MOSQ_ERR_SUCCESS;
}else{
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
return MOSQ_ERR_SUCCESS;
}
}
@ -526,7 +526,7 @@ int dynsec_groups__add_client(struct dynsec__data *data, const char *username, c
}
int dynsec_groups__process_add_client(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_add_client(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *groupname;
int rc;
@ -534,20 +534,20 @@ int dynsec_groups__process_add_client(struct dynsec__data *data, struct control_
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
@ -560,15 +560,15 @@ int dynsec_groups__process_add_client(struct dynsec__data *data, struct control_
mosquitto_log_printf(MOSQ_LOG_INFO, "dynsec: %s/%s | addGroupClient | groupname=%s | username=%s | priority=%d",
admin_clientid, admin_username, groupname, username, priority);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
}else if(rc == ERR_USER_NOT_FOUND){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
}else if(rc == ERR_GROUP_NOT_FOUND){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
}else if(rc == MOSQ_ERR_ALREADY_EXISTS){
control__command_reply(cmd, "Client is already in this group");
mosquitto_control_command_reply(cmd, "Client is already in this group");
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
}
/* Enforce any changes */
@ -628,27 +628,27 @@ int dynsec_groups__remove_client(struct dynsec__data *data, const char *username
return MOSQ_ERR_SUCCESS;
}
int dynsec_groups__process_remove_client(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_remove_client(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *username, *groupname;
int rc;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "username", &username, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing username");
mosquitto_control_command_reply(cmd, "Invalid/missing username");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(username, (int)strlen(username)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Username not valid UTF-8");
mosquitto_control_command_reply(cmd, "Username not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
@ -659,13 +659,13 @@ int dynsec_groups__process_remove_client(struct dynsec__data *data, struct contr
mosquitto_log_printf(MOSQ_LOG_INFO, "dynsec: %s/%s | removeGroupClient | groupname=%s | username=%s",
admin_clientid, admin_username, groupname, username);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
}else if(rc == ERR_USER_NOT_FOUND){
control__command_reply(cmd, "Client not found");
mosquitto_control_command_reply(cmd, "Client not found");
}else if(rc == ERR_GROUP_NOT_FOUND){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
}
/* Enforce any changes */
@ -722,7 +722,7 @@ static cJSON *add_group_to_json(struct dynsec__group *group)
}
int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_list(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
bool verbose;
cJSON *tree, *j_groups, *j_group, *j_data;
@ -736,7 +736,7 @@ int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *c
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -748,7 +748,7 @@ int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *c
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -759,7 +759,7 @@ int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *c
j_group = add_group_to_json(group);
if(j_group == NULL){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
cJSON_AddItemToArray(j_groups, j_group);
@ -770,7 +770,7 @@ int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *c
cJSON_AddItemToArray(j_groups, j_group);
}else{
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
}
@ -796,7 +796,7 @@ int dynsec_groups__process_list(struct dynsec__data *data, struct control_cmd *c
}
int dynsec_groups__process_get(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_get(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname;
cJSON *tree, *j_group, *j_data;
@ -804,17 +804,17 @@ int dynsec_groups__process_get(struct dynsec__data *data, struct control_cmd *cm
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -824,7 +824,7 @@ int dynsec_groups__process_get(struct dynsec__data *data, struct control_cmd *cm
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -833,13 +833,13 @@ int dynsec_groups__process_get(struct dynsec__data *data, struct control_cmd *cm
j_group = add_group_to_json(group);
if(j_group == NULL){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
cJSON_AddItemToObject(j_data, "group", j_group);
}else{
cJSON_Delete(tree);
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
return MOSQ_ERR_NOMEM;
}
@ -854,7 +854,7 @@ int dynsec_groups__process_get(struct dynsec__data *data, struct control_cmd *cm
}
int dynsec_groups__process_remove_role(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_remove_role(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname, *rolename;
struct dynsec__group *group;
@ -862,38 +862,38 @@ int dynsec_groups__process_remove_role(struct dynsec__data *data, struct control
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
group = dynsec_groups__find(data, groupname);
if(group == NULL){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
return MOSQ_ERR_SUCCESS;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
dynsec_rolelist__group_remove(group, role);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
group__kick_all(data, group);
@ -907,7 +907,7 @@ int dynsec_groups__process_remove_role(struct dynsec__data *data, struct control
}
int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_modify(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname = NULL;
char *text_name = NULL, *text_description = NULL;
@ -922,17 +922,17 @@ int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
group = dynsec_groups__find(data, groupname);
if(group == NULL){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
return MOSQ_ERR_INVAL;
}
@ -940,7 +940,7 @@ int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd
have_text_name = true;
text_name = mosquitto_strdup(str);
if(text_name == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -950,7 +950,7 @@ int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd
have_text_description = true;
text_description = mosquitto_strdup(str);
if(text_description == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -964,14 +964,14 @@ int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd
/* There was no list in the JSON, so no modification */
rolelist = NULL;
}else if(rc == MOSQ_ERR_NOT_FOUND){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
rc = MOSQ_ERR_INVAL;
goto error;
}else{
if(rc == MOSQ_ERR_INVAL){
control__command_reply(cmd, "'roles' not an array or missing/invalid rolename");
mosquitto_control_command_reply(cmd, "'roles' not an array or missing/invalid rolename");
}else{
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
}
rc = MOSQ_ERR_INVAL;
goto error;
@ -986,12 +986,12 @@ int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd
if(jtmp && cJSON_IsString(jtmp)){
client = dynsec_clients__find(data, jtmp->valuestring);
if(client == NULL){
control__command_reply(cmd, "'clients' contains an object with a 'username' that does not exist");
mosquitto_control_command_reply(cmd, "'clients' contains an object with a 'username' that does not exist");
rc = MOSQ_ERR_INVAL;
goto error;
}
}else{
control__command_reply(cmd, "'clients' contains an object with an invalid 'username'");
mosquitto_control_command_reply(cmd, "'clients' contains an object with an invalid 'username'");
rc = MOSQ_ERR_INVAL;
goto error;
}
@ -1033,7 +1033,7 @@ int dynsec_groups__process_modify(struct dynsec__data *data, struct control_cmd
/* And save */
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes - kick any clients in the *new* group */
group__kick_all(data, group);
@ -1058,31 +1058,31 @@ error:
}
int dynsec_groups__process_set_anonymous_group(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_set_anonymous_group(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *groupname;
struct dynsec__group *group = NULL;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "groupname", &groupname, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing groupname");
mosquitto_control_command_reply(cmd, "Invalid/missing groupname");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(groupname, (int)strlen(groupname)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Group name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Group name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
group = dynsec_groups__find(data, groupname);
if(group == NULL){
control__command_reply(cmd, "Group not found");
mosquitto_control_command_reply(cmd, "Group not found");
return MOSQ_ERR_SUCCESS;
}
data->anonymous_group = group;
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
/* Enforce any changes */
dynsec_kicklist__add(data, NULL);
@ -1095,7 +1095,7 @@ int dynsec_groups__process_set_anonymous_group(struct dynsec__data *data, struct
return MOSQ_ERR_SUCCESS;
}
int dynsec_groups__process_get_anonymous_group(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_groups__process_get_anonymous_group(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
cJSON *tree, *j_data, *j_group;
const char *groupname;
@ -1103,7 +1103,7 @@ int dynsec_groups__process_get_anonymous_group(struct dynsec__data *data, struct
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -1121,7 +1121,7 @@ int dynsec_groups__process_get_anonymous_group(struct dynsec__data *data, struct
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}

120
plugins/dynamic-security/roles.c
Unescape Escape View File

@ -331,7 +331,7 @@ int dynsec_roles__config_load(struct dynsec__data *data, cJSON *tree)
}
int dynsec_roles__process_create(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_create(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *rolename;
char *text_name, *text_description;
@ -343,50 +343,50 @@ int dynsec_roles__process_create(struct dynsec__data *data, struct control_cmd *
size_t rolename_len;
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
rolename_len = strlen(rolename);
if(rolename_len == 0){
control__command_reply(cmd, "Empty rolename");
mosquitto_control_command_reply(cmd, "Empty rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)rolename_len) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textname", &text_name, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing textname");
mosquitto_control_command_reply(cmd, "Invalid/missing textname");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textdescription", &text_description, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing textdescription");
mosquitto_control_command_reply(cmd, "Invalid/missing textdescription");
return MOSQ_ERR_INVAL;
}
if(json_get_bool(cmd->j_command, "allowwildcardsubs", &allow_wildcard_subs, true, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid allowwildcardsubs");
mosquitto_control_command_reply(cmd, "Invalid allowwildcardsubs");
return MOSQ_ERR_INVAL;
}
role = dynsec_roles__find(data, rolename);
if(role){
control__command_reply(cmd, "Role already exists");
mosquitto_control_command_reply(cmd, "Role already exists");
return MOSQ_ERR_SUCCESS;
}
role = mosquitto_calloc(1, sizeof(struct dynsec__role) + rolename_len + 1);
if(role == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
strncpy(role->rolename, rolename, rolename_len+1);
if(text_name){
role->text_name = mosquitto_strdup(text_name);
if(role->text_name == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -394,7 +394,7 @@ int dynsec_roles__process_create(struct dynsec__data *data, struct control_cmd *
if(text_description){
role->text_description = mosquitto_strdup(text_description);
if(role->text_description == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -412,7 +412,7 @@ int dynsec_roles__process_create(struct dynsec__data *data, struct control_cmd *
|| dynsec_roles__acl_load(j_acls, ACL_TYPE_UNSUB_PATTERN, &role->acls.unsubscribe_pattern) != 0
){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
rc = MOSQ_ERR_NOMEM;
goto error;
}
@ -423,7 +423,7 @@ int dynsec_roles__process_create(struct dynsec__data *data, struct control_cmd *
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);
@ -464,18 +464,18 @@ static void role__remove_all_groups(struct dynsec__data *data, struct dynsec__ro
}
}
int dynsec_roles__process_delete(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_delete(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *rolename;
struct dynsec__role *role;
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
@ -485,7 +485,7 @@ int dynsec_roles__process_delete(struct dynsec__data *data, struct control_cmd *
role__remove_all_groups(data, role);
role__free_item(data, role, true);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);
@ -494,7 +494,7 @@ int dynsec_roles__process_delete(struct dynsec__data *data, struct control_cmd *
return MOSQ_ERR_SUCCESS;
}else{
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
}
@ -532,7 +532,7 @@ static cJSON *add_role_to_json(struct dynsec__role *role, bool verbose)
return j_role;
}
int dynsec_roles__process_list(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_list(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
bool verbose;
struct dynsec__role *role, *role_tmp = NULL;
@ -546,7 +546,7 @@ int dynsec_roles__process_list(struct dynsec__data *data, struct control_cmd *cm
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -558,7 +558,7 @@ int dynsec_roles__process_list(struct dynsec__data *data, struct control_cmd *cm
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -568,7 +568,7 @@ int dynsec_roles__process_list(struct dynsec__data *data, struct control_cmd *cm
j_role = add_role_to_json(role, verbose);
if(j_role == NULL){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
cJSON_AddItemToArray(j_roles, j_role);
@ -594,7 +594,7 @@ int dynsec_roles__process_list(struct dynsec__data *data, struct control_cmd *cm
}
int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_add_acl(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *rolename;
struct dynsec__role *role;
@ -605,23 +605,23 @@ int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd
size_t topic_len;
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
j_acltype = cJSON_GetObjectItem(cmd->j_command, "acltype");
if(j_acltype == NULL || !cJSON_IsString(j_acltype)){
control__command_reply(cmd, "Invalid/missing acltype");
mosquitto_control_command_reply(cmd, "Invalid/missing acltype");
return MOSQ_ERR_SUCCESS;
}
if(!strcasecmp(j_acltype->valuestring, ACL_TYPE_PUB_C_SEND)){
@ -637,7 +637,7 @@ int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd
}else if(!strcasecmp(j_acltype->valuestring, ACL_TYPE_UNSUB_PATTERN)){
acllist = &role->acls.unsubscribe_pattern;
}else{
control__command_reply(cmd, "Unknown acltype");
mosquitto_control_command_reply(cmd, "Unknown acltype");
return MOSQ_ERR_SUCCESS;
}
@ -645,28 +645,28 @@ int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd
if(j_topic && cJSON_IsString(j_topic)){
topic_len = strlen(j_topic->valuestring);
if(mosquitto_validate_utf8(j_topic->valuestring, (int)topic_len) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Topic not valid UTF-8");
mosquitto_control_command_reply(cmd, "Topic not valid UTF-8");
return MOSQ_ERR_INVAL;
}
rc = mosquitto_sub_topic_check(j_topic->valuestring);
if(rc != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid ACL topic");
mosquitto_control_command_reply(cmd, "Invalid ACL topic");
return MOSQ_ERR_INVAL;
}
}else{
control__command_reply(cmd, "Invalid/missing topic");
mosquitto_control_command_reply(cmd, "Invalid/missing topic");
return MOSQ_ERR_SUCCESS;
}
HASH_FIND(hh, *acllist, j_topic->valuestring, topic_len, acl);
if(acl){
control__command_reply(cmd, "ACL with this topic already exists");
mosquitto_control_command_reply(cmd, "ACL with this topic already exists");
return MOSQ_ERR_SUCCESS;
}
acl = mosquitto_calloc(1, sizeof(struct dynsec__acl) + topic_len + 1);
if(acl == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_SUCCESS;
}
strncpy(acl->topic, j_topic->valuestring, topic_len+1);
@ -676,7 +676,7 @@ int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd
HASH_ADD_INORDER(hh, *acllist, topic, topic_len, acl, insert_acl_cmp);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
role__kick_all(data, role);
@ -689,7 +689,7 @@ int dynsec_roles__process_add_acl(struct dynsec__data *data, struct control_cmd
}
int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *rolename;
struct dynsec__role *role;
@ -700,23 +700,23 @@ int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct control_c
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
j_acltype = cJSON_GetObjectItem(cmd->j_command, "acltype");
if(j_acltype == NULL || !cJSON_IsString(j_acltype)){
control__command_reply(cmd, "Invalid/missing acltype");
mosquitto_control_command_reply(cmd, "Invalid/missing acltype");
return MOSQ_ERR_SUCCESS;
}
if(!strcasecmp(j_acltype->valuestring, ACL_TYPE_PUB_C_SEND)){
@ -732,21 +732,21 @@ int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct control_c
}else if(!strcasecmp(j_acltype->valuestring, ACL_TYPE_UNSUB_PATTERN)){
acllist = &role->acls.unsubscribe_pattern;
}else{
control__command_reply(cmd, "Unknown acltype");
mosquitto_control_command_reply(cmd, "Unknown acltype");
return MOSQ_ERR_SUCCESS;
}
if(json_get_string(cmd->j_command, "topic", &topic, false)){
control__command_reply(cmd, "Invalid/missing topic");
mosquitto_control_command_reply(cmd, "Invalid/missing topic");
return MOSQ_ERR_SUCCESS;
}
if(mosquitto_validate_utf8(topic, (int)strlen(topic)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Topic not valid UTF-8");
mosquitto_control_command_reply(cmd, "Topic not valid UTF-8");
return MOSQ_ERR_INVAL;
}
rc = mosquitto_sub_topic_check(topic);
if(rc != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid ACL topic");
mosquitto_control_command_reply(cmd, "Invalid ACL topic");
return MOSQ_ERR_INVAL;
}
@ -754,7 +754,7 @@ int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct control_c
if(acl){
role__free_acl(acllist, acl);
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
role__kick_all(data, role);
@ -764,14 +764,14 @@ int dynsec_roles__process_remove_acl(struct dynsec__data *data, struct control_c
admin_clientid, admin_username, rolename, j_acltype->valuestring, topic);
}else{
control__command_reply(cmd, "ACL not found");
mosquitto_control_command_reply(cmd, "ACL not found");
}
return MOSQ_ERR_SUCCESS;
}
int dynsec_roles__process_get(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_get(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *rolename;
struct dynsec__role *role;
@ -779,23 +779,23 @@ int dynsec_roles__process_get(struct dynsec__data *data, struct control_cmd *cmd
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role not found");
mosquitto_control_command_reply(cmd, "Role not found");
return MOSQ_ERR_SUCCESS;
}
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -805,14 +805,14 @@ int dynsec_roles__process_get(struct dynsec__data *data, struct control_cmd *cmd
){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
j_role = add_role_to_json(role, true);
if(j_role == NULL){
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
cJSON_AddItemToObject(j_data, "role", j_role);
@ -827,7 +827,7 @@ int dynsec_roles__process_get(struct dynsec__data *data, struct control_cmd *cmd
}
int dynsec_roles__process_modify(struct dynsec__data *data, struct control_cmd *cmd, struct mosquitto *context)
int dynsec_roles__process_modify(struct dynsec__data *data, struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
char *rolename;
char *text_name, *text_description;
@ -842,24 +842,24 @@ int dynsec_roles__process_modify(struct dynsec__data *data, struct control_cmd *
const char *admin_clientid, *admin_username;
if(json_get_string(cmd->j_command, "rolename", &rolename, false) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid/missing rolename");
mosquitto_control_command_reply(cmd, "Invalid/missing rolename");
return MOSQ_ERR_INVAL;
}
if(mosquitto_validate_utf8(rolename, (int)strlen(rolename)) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Role name not valid UTF-8");
mosquitto_control_command_reply(cmd, "Role name not valid UTF-8");
return MOSQ_ERR_INVAL;
}
role = dynsec_roles__find(data, rolename);
if(role == NULL){
control__command_reply(cmd, "Role does not exist");
mosquitto_control_command_reply(cmd, "Role does not exist");
return MOSQ_ERR_INVAL;
}
if(json_get_string(cmd->j_command, "textname", &text_name, false) == MOSQ_ERR_SUCCESS){
str = mosquitto_strdup(text_name);
if(str == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
mosquitto_free(role->text_name);
@ -869,7 +869,7 @@ int dynsec_roles__process_modify(struct dynsec__data *data, struct control_cmd *
if(json_get_string(cmd->j_command, "textdescription", &text_description, false) == MOSQ_ERR_SUCCESS){
str = mosquitto_strdup(text_description);
if(str == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
mosquitto_free(role->text_description);
@ -901,7 +901,7 @@ int dynsec_roles__process_modify(struct dynsec__data *data, struct control_cmd *
role__free_all_acls(&tmp_unsubscribe_literal);
role__free_all_acls(&tmp_unsubscribe_pattern);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -926,7 +926,7 @@ int dynsec_roles__process_modify(struct dynsec__data *data, struct control_cmd *
}
dynsec__config_batch_save(data);
control__command_reply(cmd, NULL);
mosquitto_control_command_reply(cmd, NULL);
admin_clientid = mosquitto_client_id(context);
admin_username = mosquitto_client_username(context);

2
src/CMakeLists.txt
Unescape Escape View File

@ -7,7 +7,7 @@ set (MOSQ_SRCS
conf_includedir.c
context.c
control.c
../common/control_common.c
control_common.c
database.c
handle_auth.c
handle_connack.c

2
src/Makefile
Unescape Escape View File

@ -155,7 +155,7 @@ context.o : context.c mosquitto_broker_internal.h
control.o : control.c mosquitto_broker_internal.h
${CROSS_COMPILE}${CC} $(BROKER_CPPFLAGS) $(BROKER_CFLAGS) -c $< -o $@
control_common.o : ${R}/common/control_common.c ${R}/common/control_common.h
control_common.o : control_common.c
${CROSS_COMPILE}${CC} $(BROKER_CPPFLAGS) $(BROKER_CFLAGS) -c $< -o $@
database.o : database.c mosquitto_broker_internal.h

21
src/broker_control.c
Unescape Escape View File

@ -33,11 +33,10 @@ Contributors:
#include "mosquitto_plugin.h"
#include "memory_mosq.h"
#include "mqtt_protocol.h"
#include "control_common.h"
static mosquitto_plugin_id_t plg_id;
static int broker__handle_control(struct control_cmd *cmd, struct mosquitto *context, void *userdata);
static int broker__handle_control(struct mosquitto_control_cmd *cmd, struct mosquitto *context, void *userdata);
static int add_plugin_info(cJSON *j_plugins, mosquitto_plugin_id_t *pid)
{
@ -77,7 +76,7 @@ static int add_plugin_info(cJSON *j_plugins, mosquitto_plugin_id_t *pid)
}
static int broker__process_list_plugins(struct control_cmd *cmd, struct mosquitto *context)
static int broker__process_list_plugins(struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
cJSON *tree, *j_data, *j_plugins;
const char *admin_clientid, *admin_username;
@ -85,7 +84,7 @@ static int broker__process_list_plugins(struct control_cmd *cmd, struct mosquitt
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -119,7 +118,7 @@ static int broker__process_list_plugins(struct control_cmd *cmd, struct mosquitt
internal_error:
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -164,7 +163,7 @@ static int add_listener(cJSON *j_listeners, struct mosquitto__listener *listener
}
static int broker__process_list_listeners(struct control_cmd *cmd, struct mosquitto *context)
static int broker__process_list_listeners(struct mosquitto_control_cmd *cmd, struct mosquitto *context)
{
cJSON *tree, *j_data, *j_listeners;
const char *admin_clientid, *admin_username;
@ -172,7 +171,7 @@ static int broker__process_list_listeners(struct control_cmd *cmd, struct mosqui
tree = cJSON_CreateObject();
if(tree == NULL){
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -206,7 +205,7 @@ static int broker__process_list_listeners(struct control_cmd *cmd, struct mosqui
internal_error:
cJSON_Delete(tree);
control__command_reply(cmd, "Internal error");
mosquitto_control_command_reply(cmd, "Internal error");
return MOSQ_ERR_NOMEM;
}
@ -217,7 +216,7 @@ static int broker_control_callback(int event, void *event_data, void *userdata)
UNUSED(event);
return control__generic_control_callback(ed, "$CONTROL/broker/v1/response", userdata, broker__handle_control);
return mosquitto_control_generic_callback(ed, "$CONTROL/broker/v1/response", userdata, broker__handle_control);
}
@ -250,7 +249,7 @@ void broker_control__reload(void)
* #
* ################################################################ */
static int broker__handle_control(struct control_cmd *cmd, struct mosquitto *context, void *userdata)
static int broker__handle_control(struct mosquitto_control_cmd *cmd, struct mosquitto *context, void *userdata)
{
int rc = MOSQ_ERR_SUCCESS;
@ -263,7 +262,7 @@ static int broker__handle_control(struct control_cmd *cmd, struct mosquitto *con
/* Unknown */
}else{
control__command_reply(cmd, "Unknown command");
mosquitto_control_command_reply(cmd, "Unknown command");
rc = MOSQ_ERR_INVAL;
}
return rc;

45
common/control_common.c → src/control_common.c
Unescape Escape View File

@ -1,14 +1,12 @@
#include "config.h"
#include "control_common.h"
#include "json_help.h"
#include <mqtt_protocol.h>
#include <mosquitto_broker.h>
#include <stdlib.h>
#include <string.h>
void control__command_reply(struct control_cmd *cmd, const char *error)
void mosquitto_control_command_reply(struct mosquitto_control_cmd *cmd, const char *error)
{
cJSON *j_response;
@ -27,7 +25,7 @@ void control__command_reply(struct control_cmd *cmd, const char *error)
cJSON_AddItemToArray(cmd->j_responses, j_response);
}
void control__send_response(cJSON *tree, const char *topic)
void mosquitto_control_send_response(cJSON *tree, const char *topic)
{
char *payload;
size_t payload_len;
@ -45,43 +43,50 @@ void control__send_response(cJSON *tree, const char *topic)
}
static int control__generic_handle_commands(struct control_cmd *cmd, struct mosquitto *context, cJSON *commands, void *userdata, int (*cmd_cb)(struct control_cmd *cmd, struct mosquitto *context, void *userdata))
static int control__generic_handle_commands(struct mosquitto_control_cmd *cmd, struct mosquitto *context, cJSON *commands, void *userdata, int (*cmd_cb)(struct mosquitto_control_cmd *cmd, struct mosquitto *context, void *userdata))
{
cJSON *aiter;
cJSON *aiter, *j_tmp;;
char *command;
cJSON_ArrayForEach(aiter, commands){
cmd->command_name = "Unknown command";
if(cJSON_IsObject(aiter)){
if(json_get_string(aiter, "command", &command, false) == MOSQ_ERR_SUCCESS){
j_tmp = cJSON_GetObjectItem(aiter, "command");
command = cJSON_GetStringValue(j_tmp);
if(command){
cmd->j_command = aiter;
cmd->correlation_data = NULL;
cmd->command_name = command;
if(json_get_string(aiter, "correlationData", &cmd->correlation_data, true) != MOSQ_ERR_SUCCESS){
control__command_reply(cmd, "Invalid correlationData data type.");
return MOSQ_ERR_INVAL;
j_tmp = cJSON_GetObjectItem(aiter, "correlationData");
if(j_tmp){
if(cJSON_IsString(j_tmp)){
cmd->correlation_data = cJSON_GetStringValue(j_tmp);
}else{
mosquitto_control_command_reply(cmd, "Invalid correlationData data type.");
return MOSQ_ERR_INVAL;
}
}
cmd_cb(cmd, context, userdata);
}else{
control__command_reply(cmd, "Missing command");
mosquitto_control_command_reply(cmd, "Missing command");
return MOSQ_ERR_INVAL;
}
}else{
control__command_reply(cmd, "Command not an object");
mosquitto_control_command_reply(cmd, "Command not an object");
return MOSQ_ERR_INVAL;
}
}
return MOSQ_ERR_SUCCESS;
}
int control__generic_control_callback(struct mosquitto_evt_control *event_data, const char *response_topic, void *userdata,
int (*cmd_cb)(struct control_cmd *cmd, struct mosquitto *context, void *userdata))
int mosquitto_control_generic_callback(struct mosquitto_evt_control *event_data, const char *response_topic, void *userdata,
int (*cmd_cb)(struct mosquitto_control_cmd *cmd, struct mosquitto *context, void *userdata))
{
struct mosquitto_evt_control *ed = event_data;
struct control_cmd cmd;
struct mosquitto_control_cmd cmd;
cJSON *tree, *commands;
cJSON *j_response_tree;
@ -113,15 +118,15 @@ int control__generic_control_callback(struct mosquitto_evt_control *event_data,
tree = cJSON_ParseWithLength(ed->payload, ed->payloadlen);
#endif
if(tree == NULL){
control__command_reply(&cmd, "Payload not valid JSON");
control__send_response(j_response_tree, response_topic);
mosquitto_control_command_reply(&cmd, "Payload not valid JSON");
mosquitto_control_send_response(j_response_tree, response_topic);
return MOSQ_ERR_SUCCESS;
}
commands = cJSON_GetObjectItem(tree, "commands");
if(commands == NULL || !cJSON_IsArray(commands)){
cJSON_Delete(tree);
control__command_reply(&cmd, "Invalid/missing commands");
control__send_response(j_response_tree, response_topic);
mosquitto_control_command_reply(&cmd, "Invalid/missing commands");
mosquitto_control_send_response(j_response_tree, response_topic);
return MOSQ_ERR_SUCCESS;
}
@ -129,7 +134,7 @@ int control__generic_control_callback(struct mosquitto_evt_control *event_data,
control__generic_handle_commands(&cmd, ed->client, commands, userdata, cmd_cb);
cJSON_Delete(tree);
control__send_response(j_response_tree, response_topic);
mosquitto_control_send_response(j_response_tree, response_topic);
return MOSQ_ERR_SUCCESS;
}

5
src/linker-macosx.syms
Unescape Escape View File

@ -17,13 +17,15 @@ _mosquitto_client_protocol_version
_mosquitto_client_sub_count
_mosquitto_client_username
_mosquitto_complete_basic_auth
_mosquitto_control_command_reply
_mosquitto_control_generic_callback
_mosquitto_control_send_response
_mosquitto_free
_mosquitto_kick_client_by_clientid
_mosquitto_kick_client_by_username
_mosquitto_log_printf
_mosquitto_log_vprintf
_mosquitto_malloc
_mosquitto_persistence_location
_mosquitto_persist_base_msg_add
_mosquitto_persist_base_msg_delete
_mosquitto_persist_client_add
@ -35,6 +37,7 @@ _mosquitto_persist_client_msg_update
_mosquitto_persist_client_update
_mosquitto_persist_retain_msg_delete
_mosquitto_persist_retain_msg_set
_mosquitto_persistence_location
_mosquitto_plugin_set_info
_mosquitto_property_add_binary
_mosquitto_property_add_byte

3
src/linker.syms
Unescape Escape View File

@ -18,6 +18,9 @@
mosquitto_client_sub_count;
mosquitto_client_username;
mosquitto_complete_basic_auth;
mosquitto_control_command_reply;
mosquitto_control_generic_callback;
mosquitto_control_send_response;
mosquitto_free;
mosquitto_kick_client_by_clientid;
mosquitto_kick_client_by_username;

Write Preview
Loading…
Cancel
Save