int mosquitto_publish(struct mosquitto *mosq, int *mid, const char *topic, int payloadlen, const void *payload, int qos, bool retain)
{
struct mosquitto_message_all *message;
uint16_t local_mid;
int queue_status;
if(!mosq || !topic || qos<0 || qos>2) return MOSQ_ERR_INVAL;
if(STREMPTY(topic)) return MOSQ_ERR_INVAL;
if(payloadlen < 0 || payloadlen > MQTT_MAX_PAYLOAD) return MOSQ_ERR_PAYLOAD_SIZE;
if(mosquitto_pub_topic_check(topic) != MOSQ_ERR_SUCCESS){
return MOSQ_ERR_INVAL;
}
local_mid = _mosquitto_mid_generate(mosq);
if(mid){
*mid = local_mid;
}
if(qos == 0){
return _mosquitto_send_publish(mosq, local_mid, topic, payloadlen, payload, qos, retain, false);
}else{
message = _mosquitto_calloc(1, sizeof(struct mosquitto_message_all));
if(!message) return MOSQ_ERR_NOMEM;
message->next = NULL;
message->timestamp = mosquitto_time();
message->msg.mid = local_mid;
message->msg.topic = _mosquitto_strdup(topic);
if(!message->msg.topic){
_mosquitto_message_cleanup(&message);
return MOSQ_ERR_NOMEM;
}
if(payloadlen){
message->msg.payloadlen = payloadlen;
message->msg.payload = _mosquitto_malloc(payloadlen*sizeof(uint8_t));
if(!message->msg.payload){
_mosquitto_message_cleanup(&message);
return MOSQ_ERR_NOMEM;
}
memcpy(message->msg.payload, payload, payloadlen*sizeof(uint8_t));
}else{
message->msg.payloadlen = 0;
message->msg.payload = NULL;
}
message->msg.qos = qos;
message->msg.retain = retain;
message->dup = false;
pthread_mutex_lock(&mosq->out_message_mutex);
printf("================ mosquitto.c ================\n");
printf("#mosq->inflight_messages : %s\n", mosq->inflight_messages);
queue_status = _mosquitto_message_queue(mosq, message, mosq_md_out);
if(queue_status == 0){
if(qos == 1){
message->state = mosq_ms_wait_for_puback;
}else if(qos == 2){
message->state = mosq_ms_wait_for_pubrec;
}
pthread_mutex_unlock(&mosq->out_message_mutex);
return _mosquitto_send_publish(mosq, message->msg.mid, message->msg.topic, message->msg.payloadlen, message->msg.payload, message->msg.qos, message->msg.retain, message->dup);
}else{
message->state = mosq_ms_invalid;
pthread_mutex_unlock(&mosq->out_message_mutex);
return MOSQ_ERR_SUCCESS;
}
}
}
int mqtt3_handle_connect(struct mosquitto_db *db, struct mosquitto *context)
{
char *protocol_name = NULL;
uint8_t protocol_version;
uint8_t connect_flags;
uint8_t connect_ack = 0;
char *client_id = NULL;
char *will_payload = NULL, *will_topic = NULL;
char *will_topic_mount;
uint16_t will_payloadlen;
struct mosquitto_message *will_struct = NULL;
uint8_t will, will_retain, will_qos, clean_session;
uint8_t username_flag, password_flag;
char *username = NULL, *password = NULL;
int rc;
struct _mosquitto_acl_user *acl_tail;
struct mosquitto_client_msg *msg_tail, *msg_prev;
struct mosquitto *found_context;
int slen;
struct _mosquitto_subleaf *leaf;
int i;
#ifdef WITH_TLS
X509 *client_cert = NULL;
X509_NAME *name;
X509_NAME_ENTRY *name_entry;
#endif
#ifdef WITH_SYS_TREE
g_connection_count++;
#endif
g_epoll_mqtt_connections++;
/* Don't accept multiple CONNECT commands. */
if(context->state != mosq_cs_new){
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
if(_mosquitto_read_string(&context->in_packet, &protocol_name)){
rc = 1;
goto handle_connect_error;
return 1;
}
if(!protocol_name){
rc = 3;
goto handle_connect_error;
return 3;
}
if(_mosquitto_read_byte(&context->in_packet, &protocol_version)){
rc = 1;
goto handle_connect_error;
return 1;
}
if(!strcmp(protocol_name, PROTOCOL_NAME_v31)){
if((protocol_version&0x7F) != PROTOCOL_VERSION_v31){
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid protocol version %d in CONNECT from %s.",
protocol_version, context->address);
}
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_PROTOCOL_VERSION);
_mosquitto_free(protocol_name);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
context->protocol = mosq_p_mqtt31;
}else if(!strcmp(protocol_name, PROTOCOL_NAME_v311)){
if((protocol_version&0x7F) != PROTOCOL_VERSION_v311){
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid protocol version %d in CONNECT from %s.",
protocol_version, context->address);
}
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_PROTOCOL_VERSION);
_mosquitto_free(protocol_name);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
if((context->in_packet.command&0x0F) != 0x00){
/* Reserved flags not set to 0, must disconnect. */
_mosquitto_free(protocol_name);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
context->protocol = mosq_p_mqtt311;
}else{
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid protocol \"%s\" in CONNECT from %s.",
protocol_name, context->address);
}
_mosquitto_free(protocol_name);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
_mosquitto_free(protocol_name);
if(_mosquitto_read_byte(&context->in_packet, &connect_flags)){
rc = 1;
goto handle_connect_error;
}
clean_session = (connect_flags & 0x02) >> 1;
will = connect_flags & 0x04;
will_qos = (connect_flags & 0x18) >> 3;
if(will_qos == 3){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Invalid Will QoS in CONNECT from %s.",
context->address);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
will_retain = connect_flags & 0x20;
password_flag = connect_flags & 0x40;
username_flag = connect_flags & 0x80;
if(_mosquitto_read_uint16(&context->in_packet, &(context->keepalive))){
rc = 1;
goto handle_connect_error;
}
if(_mosquitto_read_string(&context->in_packet, &client_id)){
rc = 1;
goto handle_connect_error;
}
slen = strlen(client_id);
if(slen == 0){
if(context->protocol == mosq_p_mqtt31){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_IDENTIFIER_REJECTED);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}else{ /* mqtt311 */
_mosquitto_free(client_id);
client_id = NULL;
if(clean_session == 0 || db->config->allow_zero_length_clientid == false){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_IDENTIFIER_REJECTED);
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}else{
client_id = client_id_gen(db);
if(!client_id){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}
}
}
}
/* clientid_prefixes check */
if(db->config->clientid_prefixes){
if(strncmp(db->config->clientid_prefixes, client_id, strlen(db->config->clientid_prefixes))){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_NOT_AUTHORIZED);
rc = 1;
goto handle_connect_error;
}
}
if(will){
will_struct = _mosquitto_calloc(1, sizeof(struct mosquitto_message));
if(!will_struct){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}
if(_mosquitto_read_string(&context->in_packet, &will_topic)){
rc = 1;
goto handle_connect_error;
}
if(STREMPTY(will_topic)){
rc = 1;
goto handle_connect_error;
}
if(context->listener && context->listener->mount_point){
slen = strlen(context->listener->mount_point) + strlen(will_topic);
will_topic_mount = _mosquitto_malloc(slen+1);
if(!will_topic_mount){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}
snprintf(will_topic_mount, slen, "%s%s", context->listener->mount_point, will_topic);
will_topic_mount[slen] = '\0';
_mosquitto_free(will_topic);
will_topic = will_topic_mount;
}
if(mosquitto_pub_topic_check(will_topic)){
rc = 1;
goto handle_connect_error;
}
if(_mosquitto_read_uint16(&context->in_packet, &will_payloadlen)){
rc = 1;
goto handle_connect_error;
}
if(will_payloadlen > 0){
will_payload = _mosquitto_malloc(will_payloadlen);
if(!will_payload){
rc = 1;
goto handle_connect_error;
}
rc = _mosquitto_read_bytes(&context->in_packet, will_payload, will_payloadlen);
if(rc){
rc = 1;
goto handle_connect_error;
}
}
}else{
if(context->protocol == mosq_p_mqtt311){
if(will_qos != 0 || will_retain != 0){
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
}
}
if(username_flag){
rc = _mosquitto_read_string(&context->in_packet, &username);
if(rc == MOSQ_ERR_SUCCESS){
if(password_flag){
rc = _mosquitto_read_string(&context->in_packet, &password);
if(rc == MOSQ_ERR_NOMEM){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}else if(rc == MOSQ_ERR_PROTOCOL){
if(context->protocol == mosq_p_mqtt31){
/* Password flag given, but no password. Ignore. */
password_flag = 0;
}else if(context->protocol == mosq_p_mqtt311){
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
}
}
}else if(rc == MOSQ_ERR_NOMEM){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}else{
if(context->protocol == mosq_p_mqtt31){
/* Username flag given, but no username. Ignore. */
username_flag = 0;
}else if(context->protocol == mosq_p_mqtt311){
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
}
}else{
if(context->protocol == mosq_p_mqtt311){
if(password_flag){
/* username_flag == 0 && password_flag == 1 is forbidden */
rc = MOSQ_ERR_PROTOCOL;
goto handle_connect_error;
}
}
}
#ifdef WITH_TLS
if(context->listener && context->listener->ssl_ctx && context->listener->use_identity_as_username){
if(!context->ssl){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_BAD_USERNAME_PASSWORD);
rc = 1;
goto handle_connect_error;
}
#ifdef REAL_WITH_TLS_PSK
if(context->listener->psk_hint){
/* Client should have provided an identity to get this far. */
if(!context->username){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_BAD_USERNAME_PASSWORD);
rc = 1;
goto handle_connect_error;
}
}else{
#endif /* REAL_WITH_TLS_PSK */
client_cert = SSL_get_peer_certificate(context->ssl);
if(!client_cert){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_BAD_USERNAME_PASSWORD);
rc = 1;
goto handle_connect_error;
}
name = X509_get_subject_name(client_cert);
if(!name){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_BAD_USERNAME_PASSWORD);
rc = 1;
goto handle_connect_error;
}
i = X509_NAME_get_index_by_NID(name, NID_commonName, -1);
if(i == -1){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_BAD_USERNAME_PASSWORD);
rc = 1;
goto handle_connect_error;
}
name_entry = X509_NAME_get_entry(name, i);
context->username = _mosquitto_strdup((char *)ASN1_STRING_data(name_entry->value));
if(!context->username){
rc = 1;
goto handle_connect_error;
}
X509_free(client_cert);
client_cert = NULL;
#ifdef REAL_WITH_TLS_PSK
}
#endif /* REAL_WITH_TLS_PSK */
}else{
#endif /* WITH_TLS */
if(username_flag){
rc = mosquitto_unpwd_check(db, username, password);
switch(rc){
case MOSQ_ERR_SUCCESS:
break;
case MOSQ_ERR_AUTH:
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_NOT_AUTHORIZED);
mqtt3_context_disconnect(db, context);
rc = 1;
goto handle_connect_error;
break;
default:
mqtt3_context_disconnect(db, context);
rc = 1;
goto handle_connect_error;
break;
}
context->username = username;
context->password = password;
username = NULL; /* Avoid free() in error: below. */
password = NULL;
}
if(!username_flag && db->config->allow_anonymous == false){
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_NOT_AUTHORIZED);
rc = 1;
goto handle_connect_error;
}
#ifdef WITH_TLS
}
#endif
if(context->listener && context->listener->use_username_as_clientid){
if(context->username){
_mosquitto_free(client_id);
client_id = _mosquitto_strdup(context->username);
if(!client_id){
rc = MOSQ_ERR_NOMEM;
goto handle_connect_error;
}
}else{
_mosquitto_send_connack(context, 0, CONNACK_REFUSED_NOT_AUTHORIZED);
rc = 1;
goto handle_connect_error;
}
}
/* Find if this client already has an entry. This must be done *after* any security checks. */
HASH_FIND(hh_id, db->contexts_by_id, client_id, strlen(client_id), found_context);
if(found_context){
/* Found a matching client */
if(found_context->sock == INVALID_SOCKET){
/* Client is reconnecting after a disconnect */
/* FIXME - does anything need to be done here? */
}else{
/* Client is already connected, disconnect old version. This is
* done in mqtt3_context_cleanup() below. */
if(db->config->connection_messages == true){
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Client %s already connected, closing old connection.", client_id);
}
}
if(context->protocol == mosq_p_mqtt311){
if(clean_session == 0){
connect_ack |= 0x01;
}
}
context->clean_session = clean_session;
if(context->clean_session == false && found_context->clean_session == false){
if(found_context->msgs){
context->msgs = found_context->msgs;
found_context->msgs = NULL;
mqtt3_db_message_reconnect_reset(db, context);
}
context->subs = found_context->subs;
found_context->subs = NULL;
context->sub_count = found_context->sub_count;
found_context->sub_count = 0;
for(i=0; i<context->sub_count; i++){
if(context->subs[i]){
leaf = context->subs[i]->subs;
while(leaf){
if(leaf->context == found_context){
leaf->context = context;
}
leaf = leaf->next;
}
}
}
}
found_context->clean_session = true;
found_context->state = mosq_cs_disconnecting;
if(g_flag_epoll)
{
epoll_do_disconnect(db,found_context);
}
else
{
do_disconnect(db, found_context);
}
}
/* Associate user with its ACL, assuming we have ACLs loaded. */
if(db->acl_list){
acl_tail = db->acl_list;
while(acl_tail){
if(context->username){
if(acl_tail->username && !strcmp(context->username, acl_tail->username)){
context->acl_list = acl_tail;
break;
}
}else{
if(acl_tail->username == NULL){
context->acl_list = acl_tail;
break;
}
}
acl_tail = acl_tail->next;
}
}else{
context->acl_list = NULL;
}
if(will_struct){
context->will = will_struct;
context->will->topic = will_topic;
if(will_payload){
context->will->payload = will_payload;
context->will->payloadlen = will_payloadlen;
}else{
context->will->payload = NULL;
context->will->payloadlen = 0;
}
context->will->qos = will_qos;
context->will->retain = will_retain;
}
if(db->config->connection_messages == true){
if(context->is_bridge){
if(context->username){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "New bridge connected from %s as %s (c%d, k%d, u'%s').", context->address, client_id, clean_session, context->keepalive, context->username);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "New bridge connected from %s as %s (c%d, k%d).", context->address, client_id, clean_session, context->keepalive);
}
}else{
if(context->username){
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "New client connected from %s as %s (c%d, k%d, u'%s').", context->address, client_id, clean_session, context->keepalive, context->username);
}else{
_mosquitto_log_printf(NULL, MOSQ_LOG_NOTICE, "New client connected from %s as %s (c%d, k%d).", context->address, client_id, clean_session, context->keepalive);
}
}
}
context->id = client_id;
client_id = NULL;
context->clean_session = clean_session;
context->ping_t = 0;
context->is_dropping = false;
if((protocol_version&0x80) == 0x80){
context->is_bridge = true;
}
/* Remove any queued messages that are no longer allowed through ACL,
* assuming a possible change of username. */
msg_tail = context->msgs;
msg_prev = NULL;
while(msg_tail){
if(msg_tail->direction == mosq_md_out){
if(mosquitto_acl_check(db, context, msg_tail->store->topic, MOSQ_ACL_READ) != MOSQ_ERR_SUCCESS){
mosquitto__db_msg_store_deref(db, &msg_tail->store);
if(msg_prev){
msg_prev->next = msg_tail->next;
_mosquitto_free(msg_tail);
msg_tail = msg_prev->next;
}else{
context->msgs = context->msgs->next;
_mosquitto_free(msg_tail);
msg_tail = context->msgs;
}
}else{
msg_prev = msg_tail;
msg_tail = msg_tail->next;
}
}else{
msg_prev = msg_tail;
msg_tail = msg_tail->next;
}
}
HASH_ADD_KEYPTR(hh_id, db->contexts_by_id, context->id, strlen(context->id), context);
#ifdef WITH_PERSISTENCE
if(!clean_session){
db->persistence_changes++;
}
#endif
context->state = mosq_cs_connected;
return _mosquitto_send_connack(context, connect_ack, CONNACK_ACCEPTED);
handle_connect_error:
if(client_id) _mosquitto_free(client_id);
if(username) _mosquitto_free(username);
if(password) _mosquitto_free(password);
if(will_payload) _mosquitto_free(will_payload);
if(will_topic) _mosquitto_free(will_topic);
if(will_struct) _mosquitto_free(will_struct);
#ifdef WITH_TLS
if(client_cert) X509_free(client_cert);
#endif
/* We return an error here which means the client is freed later on. */
return rc;
}
int mosquitto_reinitialise(struct mosquitto *mosq, const char *id, bool clean_session, void *userdata)
{
int i;
if(!mosq) return MOSQ_ERR_INVAL;
if(clean_session == false && id == NULL){
return MOSQ_ERR_INVAL;
}
_mosquitto_destroy(mosq);
memset(mosq, 0, sizeof(struct mosquitto));
if(userdata){
mosq->userdata = userdata;
}else{
mosq->userdata = mosq;
}
mosq->protocol = mosq_p_mqtt31;
mosq->sock = INVALID_SOCKET;
mosq->sockpairR = INVALID_SOCKET;
mosq->sockpairW = INVALID_SOCKET;
mosq->keepalive = 60;
mosq->message_retry = 20;
mosq->last_retry_check = 0;
mosq->clean_session = clean_session;
if(id){
if(STREMPTY(id)){
return MOSQ_ERR_INVAL;
}
mosq->id = _mosquitto_strdup(id);
}else{
mosq->id = (char *)_mosquitto_calloc(24, sizeof(char));
if(!mosq->id){
return MOSQ_ERR_NOMEM;
}
mosq->id[0] = 'm';
mosq->id[1] = 'o';
mosq->id[2] = 's';
mosq->id[3] = 'q';
mosq->id[4] = '/';
for(i=5; i<23; i++){
mosq->id[i] = (rand()%73)+48;
}
}
mosq->in_packet.payload = NULL;
_mosquitto_packet_cleanup(&mosq->in_packet);
mosq->out_packet = NULL;
mosq->current_out_packet = NULL;
mosq->last_msg_in = mosquitto_time();
mosq->last_msg_out = mosquitto_time();
mosq->ping_t = 0;
mosq->last_mid = 0;
mosq->state = mosq_cs_new;
mosq->in_messages = NULL;
mosq->in_messages_last = NULL;
mosq->out_messages = NULL;
mosq->out_messages_last = NULL;
mosq->max_inflight_messages = 20;
mosq->will = NULL;
mosq->on_connect = NULL;
mosq->on_publish = NULL;
mosq->on_message = NULL;
mosq->on_subscribe = NULL;
mosq->on_unsubscribe = NULL;
mosq->host = NULL;
mosq->port = 1883;
mosq->in_callback = false;
mosq->in_queue_len = 0;
mosq->out_queue_len = 0;
mosq->reconnect_delay = 1;
mosq->reconnect_delay_max = 1;
mosq->reconnect_exponential_backoff = false;
mosq->threaded = false;
#ifdef WITH_TLS
mosq->ssl = NULL;
mosq->tls_cert_reqs = SSL_VERIFY_PEER;
mosq->tls_insecure = false;
mosq->want_write = false;
#endif
#ifdef WITH_THREADING
pthread_mutex_init(&mosq->exe_mutex, NULL);
pthread_mutex_init(&mosq->callback_mutex, NULL);
pthread_mutex_init(&mosq->log_callback_mutex, NULL);
pthread_mutex_init(&mosq->state_mutex, NULL);
pthread_mutex_init(&mosq->out_packet_mutex, NULL);
pthread_mutex_init(&mosq->current_out_packet_mutex, NULL);
pthread_mutex_init(&mosq->msgtime_mutex, NULL);
pthread_mutex_init(&mosq->in_message_mutex, NULL);
pthread_mutex_init(&mosq->out_message_mutex, NULL);
pthread_mutex_init(&mosq->mid_mutex, NULL);
mosq->thread_id = pthread_self();
#endif
return MOSQ_ERR_SUCCESS;
}
int mqtt3_handle_publish(struct mosquitto_db *db, struct mosquitto *context)
{
char *topic;
void *payload = NULL;
uint32_t payloadlen;
uint8_t dup, qos, retain;
uint16_t mid = 0;
int rc = 0;
uint8_t header = context->in_packet.command;
int res = 0;
struct mosquitto_msg_store *stored = NULL;
int len;
char *topic_mount;
#ifdef WITH_BRIDGE
char *topic_temp;
int i;
struct _mqtt3_bridge_topic *cur_topic;
bool match;
#endif
dup = (header & 0x08)>>3;
qos = (header & 0x06)>>1;
if(qos == 3){
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO,
"Invalid QoS in PUBLISH from %s, disconnecting.", context->id);
return 1;
}
retain = (header & 0x01);
if(_mosquitto_read_string(&context->in_packet, &topic)) return 1;
if(STREMPTY(topic)){
/* Invalid publish topic, disconnect client. */
_mosquitto_free(topic);
return 1;
}
#ifdef WITH_BRIDGE
if(context->bridge && context->bridge->topics && context->bridge->topic_remapping){
for(i=0; i<context->bridge->topic_count; i++){
cur_topic = &context->bridge->topics[i];
if((cur_topic->direction == bd_both || cur_topic->direction == bd_in)
&& (cur_topic->remote_prefix || cur_topic->local_prefix)){
/* Topic mapping required on this topic if the message matches */
rc = mosquitto_topic_matches_sub(cur_topic->remote_topic, topic, &match);
if(rc){
_mosquitto_free(topic);
return rc;
}
if(match){
if(cur_topic->remote_prefix){
/* This prefix needs removing. */
if(!strncmp(cur_topic->remote_prefix, topic, strlen(cur_topic->remote_prefix))){
topic_temp = _mosquitto_strdup(topic+strlen(cur_topic->remote_prefix));
if(!topic_temp){
_mosquitto_free(topic);
return MOSQ_ERR_NOMEM;
}
_mosquitto_free(topic);
topic = topic_temp;
}
}
if(cur_topic->local_prefix){
/* This prefix needs adding. */
len = strlen(topic) + strlen(cur_topic->local_prefix)+1;
topic_temp = _mosquitto_malloc(len+1);
if(!topic_temp){
_mosquitto_free(topic);
return MOSQ_ERR_NOMEM;
}
snprintf(topic_temp, len, "%s%s", cur_topic->local_prefix, topic);
topic_temp[len] = '\0';
_mosquitto_free(topic);
topic = topic_temp;
}
break;
}
}
}
}
#endif
if(mosquitto_pub_topic_check(topic) != MOSQ_ERR_SUCCESS){
/* Invalid publish topic, just swallow it. */
_mosquitto_free(topic);
return 1;
}
if(qos > 0){
if(_mosquitto_read_uint16(&context->in_packet, &mid)){
_mosquitto_free(topic);
return 1;
}
}
payloadlen = context->in_packet.remaining_length - context->in_packet.pos;
#ifdef WITH_SYS_TREE
g_pub_bytes_received += payloadlen;
#endif
if(context->listener && context->listener->mount_point){
len = strlen(context->listener->mount_point) + strlen(topic) + 1;
topic_mount = _mosquitto_malloc(len+1);
if(!topic_mount){
_mosquitto_free(topic);
return MOSQ_ERR_NOMEM;
}
snprintf(topic_mount, len, "%s%s", context->listener->mount_point, topic);
topic_mount[len] = '\0';
_mosquitto_free(topic);
topic = topic_mount;
}
if(payloadlen){
if(db->config->message_size_limit && payloadlen > db->config->message_size_limit){
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Dropped too large PUBLISH from %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", context->id, dup, qos, retain, mid, topic, (long)payloadlen);
goto process_bad_message;
}
payload = _mosquitto_calloc(payloadlen+1, 1);
if(!payload){
_mosquitto_free(topic);
return 1;
}
if(_mosquitto_read_bytes(&context->in_packet, payload, payloadlen)){
_mosquitto_free(topic);
_mosquitto_free(payload);
return 1;
}
}
/* Check for topic access */
rc = mosquitto_acl_check(db, context, topic, MOSQ_ACL_WRITE);
if(rc == MOSQ_ERR_ACL_DENIED){
_mosquitto_log_printf(NULL, MOSQ_LOG_DEBUG, "Denied PUBLISH from %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes))", context->id, dup, qos, retain, mid, topic, (long)payloadlen);
goto process_bad_message;
}else if(rc != MOSQ_ERR_SUCCESS){
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return rc;
}
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Received PUBLISH from %s (d%d, q%d, r%d, m%d, '%s', ... (%ld bytes) payload %s)", context->id, dup, qos, retain, mid, topic, (long)payloadlen, (char
*)payload);
//Prathamesh
write(pipeFDS[1],payload, payloadlen);
if(qos > 0){
mqtt3_db_message_store_find(context, mid, &stored);
}
if(!stored){
dup = 0;
if(mqtt3_db_message_store(db, context->id, mid, topic, qos, payloadlen, payload, retain, &stored, 0)){
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return 1;
}
}else{
dup = 1;
}
switch(qos){
case 0:
if(mqtt3_db_messages_queue(db, context->id, topic, qos, retain, &stored)) rc = 1;
break;
case 1:
if(mqtt3_db_messages_queue(db, context->id, topic, qos, retain, &stored)) rc = 1;
if(_mosquitto_send_puback(context, mid)) rc = 1;
break;
case 2:
if(!dup){
res = mqtt3_db_message_insert(db, context, mid, mosq_md_in, qos, retain, stored);
}else{
res = 0;
}
/* mqtt3_db_message_insert() returns 2 to indicate dropped message
* due to queue. This isn't an error so don't disconnect them. */
if(!res){
if(_mosquitto_send_pubrec(context, mid)) rc = 1;
}else if(res == 1){
rc = 1;
}
break;
}
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
return rc;
process_bad_message:
_mosquitto_free(topic);
if(payload) _mosquitto_free(payload);
switch(qos){
case 0:
return MOSQ_ERR_SUCCESS;
case 1:
return _mosquitto_send_puback(context, mid);
case 2:
mqtt3_db_message_store_find(context, mid, &stored);
if(!stored){
if(mqtt3_db_message_store(db, context->id, mid, NULL, qos, 0, NULL, false, &stored, 0)){
return 1;
}
res = mqtt3_db_message_insert(db, context, mid, mosq_md_in, qos, false, stored);
}else{
res = 0;
}
if(!res){
res = _mosquitto_send_pubrec(context, mid);
}
return res;
}
return 1;
}
