static int mqtt3_db_client_write(mosquitto_db *db, FILE *db_fptr)
{
int i;
struct mosquitto *context;
uint16_t i16temp, slen;
uint32_t length;
assert(db);
assert(db_fptr);
for(i=0; i<db->context_count; i++){
context = db->contexts[i];
if(context && context->clean_session == false){
length = htonl(2+strlen(context->id) + sizeof(uint16_t));
i16temp = htons(DB_CHUNK_CLIENT);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
slen = strlen(context->id);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, context->id, slen);
i16temp = htons(context->last_mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
if(mqtt3_db_client_messages_write(db, db_fptr, context)) return 1;
}
}
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
int persist__chunk_cfg_write_v5(FILE *db_fptr, struct PF_cfg *chunk)
{
struct PF_header header;
header.chunk = htonl(DB_CHUNK_CFG);
header.length = htonl(sizeof(struct PF_cfg));
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, chunk, sizeof(struct PF_cfg));
return MOSQ_ERR_SUCCESS;
error:
log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
int persist__chunk_retain_write_v5(FILE *db_fptr, struct P_retain *chunk)
{
struct PF_header header;
header.chunk = htonl(DB_CHUNK_RETAIN);
header.length = htonl(sizeof(struct PF_retain));
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_retain));
return MOSQ_ERR_SUCCESS;
error:
log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
int main(int argc, char* argv[])
{
if (argc > 1) {
int i, n = atoi(argv[1]);
if (argc == 2) {
for (i = 0; i < n; ++i) {
write(i);
}
}
else if (argv[2][1] == 'e') {
for (i = 0; i < n; ++i) {
write_e(i);
}
}
else if (argv[2][1] == 'c') {
for (i = 0; i < n; ++i) {
write_c(i);
}
}
else if (argv[2][1] == 'n') {
for (i = 0; i < n; ++i) {
write_n(i);
}
}
}
return 0;
}
int mqtt3_db_backup(mosquitto_db *db, bool cleanup, bool shutdown)
{
int rc = 0;
FILE *db_fptr = NULL;
uint32_t db_version = htonl(MOSQ_DB_VERSION);
uint32_t crc = htonl(0);
dbid_t i64temp;
uint32_t i32temp;
uint16_t i16temp;
uint8_t i8temp;
if(!db || !db->config || !db->config->persistence_filepath) return MOSQ_ERR_INVAL;
_mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Saving in-memory database to %s.", db->config->persistence_filepath);
if(cleanup){
mqtt3_db_store_clean(db);
}
db_fptr = fopen(db->config->persistence_filepath, "wb");
if(db_fptr == NULL){
goto error;
}
/* Header */
write_e(db_fptr, magic, 15);
write_e(db_fptr, &crc, sizeof(uint32_t));
write_e(db_fptr, &db_version, sizeof(uint32_t));
/* DB config */
i16temp = htons(DB_CHUNK_CFG);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
/* chunk length */
i32temp = htonl(sizeof(dbid_t) + sizeof(uint8_t) + sizeof(uint8_t));
write_e(db_fptr, &i32temp, sizeof(uint32_t));
/* db written at broker shutdown or not */
i8temp = shutdown;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = sizeof(dbid_t);
write_e(db_fptr, &i8temp, sizeof(uint8_t));
/* last db mid */
i64temp = db->last_db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
if(mqtt3_db_message_store_write(db, db_fptr)){
goto error;
}
mqtt3_db_client_write(db, db_fptr);
mqtt3_db_subs_retain_write(db, db_fptr);
fclose(db_fptr);
return rc;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
if(db_fptr) fclose(db_fptr);
return 1;
}
int persist__chunk_client_msg_write_v5(FILE *db_fptr, struct P_client_msg *chunk)
{
struct PF_header header;
struct mosquitto__packet prop_packet;
uint16_t id_len = chunk->F.id_len;
uint32_t proplen = 0;
int rc;
memset(&prop_packet, 0, sizeof(struct mosquitto__packet));
if(chunk->properties){
proplen = property__get_length_all(chunk->properties);
proplen += packet__varint_bytes(proplen);
}
chunk->F.mid = htons(chunk->F.mid);
chunk->F.id_len = htons(chunk->F.id_len);
header.chunk = htonl(DB_CHUNK_CLIENT_MSG);
header.length = htonl(sizeof(struct PF_client_msg) + id_len + proplen);
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_client_msg));
write_e(db_fptr, chunk->client_id, id_len);
if(chunk->properties){
if(proplen > 0){
prop_packet.remaining_length = proplen;
prop_packet.packet_length = proplen;
prop_packet.payload = mosquitto__malloc(proplen);
if(!prop_packet.payload){
return MOSQ_ERR_NOMEM;
}
rc = property__write_all(&prop_packet, chunk->properties, true);
if(rc) return rc;
write_e(db_fptr, prop_packet.payload, proplen);
mosquitto__free(prop_packet.payload);
}
}
return MOSQ_ERR_SUCCESS;
error:
log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
int persist__chunk_client_write_v5(FILE *db_fptr, struct P_client *chunk)
{
struct PF_header header;
uint16_t id_len = chunk->F.id_len;
chunk->F.session_expiry_interval = htonl(chunk->F.session_expiry_interval);
chunk->F.last_mid = htons(chunk->F.last_mid);
chunk->F.id_len = htons(chunk->F.id_len);
header.chunk = htonl(DB_CHUNK_CLIENT);
header.length = htonl(sizeof(struct PF_client)+id_len);
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_client));
write_e(db_fptr, chunk->client_id, id_len);
return MOSQ_ERR_SUCCESS;
error:
log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
int persist__chunk_sub_write_v5(FILE *db_fptr, struct P_sub *chunk)
{
struct PF_header header;
uint16_t id_len = chunk->F.id_len;
uint16_t topic_len = chunk->F.topic_len;
chunk->F.identifier = htonl(chunk->F.identifier);
chunk->F.id_len = htons(chunk->F.id_len);
chunk->F.topic_len = htons(chunk->F.topic_len);
header.chunk = htonl(DB_CHUNK_SUB);
header.length = htonl(sizeof(struct PF_sub) +
id_len + topic_len);
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_sub));
write_e(db_fptr, chunk->client_id, id_len);
write_e(db_fptr, chunk->topic, topic_len);
return MOSQ_ERR_SUCCESS;
error:
log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int mqtt3_db_client_messages_write(mosquitto_db *db, FILE *db_fptr, struct mosquitto *context)
{
uint32_t length;
dbid_t i64temp;
uint16_t i16temp, slen;
uint8_t i8temp;
mosquitto_client_msg *cmsg;
assert(db);
assert(db_fptr);
assert(context);
cmsg = context->msgs;
while(cmsg){
slen = strlen(context->id);
length = htonl(sizeof(dbid_t) + sizeof(uint16_t) + sizeof(uint8_t) +
sizeof(uint8_t) + sizeof(uint8_t) + sizeof(uint8_t) +
sizeof(uint8_t) + 2+slen);
i16temp = htons(DB_CHUNK_CLIENT_MSG);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, context->id, slen);
i64temp = cmsg->store->db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
i16temp = htons(cmsg->mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
i8temp = (uint8_t )cmsg->qos;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->retain;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->direction;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->state;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )cmsg->dup;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
cmsg = cmsg->next;
}
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int _db_subs_retain_write(mosquitto_db *db, FILE *db_fptr, struct _mosquitto_subhier *node, const char *topic)
{
struct _mosquitto_subhier *subhier;
struct _mosquitto_subleaf *sub;
char *thistopic;
uint32_t length;
uint16_t i16temp;
dbid_t i64temp;
int slen;
slen = strlen(topic) + strlen(node->topic) + 2;
thistopic = _mosquitto_malloc(sizeof(char)*slen);
if(!thistopic) return MOSQ_ERR_NOMEM;
if(strlen(topic)){
snprintf(thistopic, slen, "%s/%s", topic, node->topic);
}else{
snprintf(thistopic, slen, "%s", node->topic);
}
sub = node->subs;
while(sub){
if(sub->context->clean_session == false){
length = htonl(2+strlen(sub->context->id) + 2+strlen(thistopic) + sizeof(uint8_t));
i16temp = htons(DB_CHUNK_SUB);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
slen = strlen(sub->context->id);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, sub->context->id, slen);
slen = strlen(thistopic);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, thistopic, slen);
write_e(db_fptr, &sub->qos, sizeof(uint8_t));
}
sub = sub->next;
}
if(node->retained){
length = htonl(sizeof(dbid_t));
i16temp = htons(DB_CHUNK_RETAIN);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
i64temp = node->retained->db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
}
subhier = node->children;
while(subhier){
_db_subs_retain_write(db, db_fptr, subhier, thistopic);
subhier = subhier->next;
}
_mosquitto_free(thistopic);
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
static int mqtt3_db_message_store_write(mosquitto_db *db, FILE *db_fptr)
{
uint32_t length;
dbid_t i64temp;
uint32_t i32temp;
uint16_t i16temp, slen;
uint8_t i8temp;
struct mosquitto_msg_store *stored;
assert(db);
assert(db_fptr);
stored = db->msg_store;
while(stored){
length = htonl(sizeof(dbid_t) + 2+strlen(stored->source_id) +
sizeof(uint16_t) + sizeof(uint16_t) +
2+strlen(stored->msg.topic) + sizeof(uint32_t) +
stored->msg.payloadlen + sizeof(uint8_t) + sizeof(uint8_t));
i16temp = htons(DB_CHUNK_MSG_STORE);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, &length, sizeof(uint32_t));
i64temp = stored->db_id;
write_e(db_fptr, &i64temp, sizeof(dbid_t));
slen = strlen(stored->source_id);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
if(slen){
write_e(db_fptr, stored->source_id, slen);
}
i16temp = htons(stored->source_mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
i16temp = htons(stored->msg.mid);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
slen = strlen(stored->msg.topic);
i16temp = htons(slen);
write_e(db_fptr, &i16temp, sizeof(uint16_t));
write_e(db_fptr, stored->msg.topic, slen);
i8temp = (uint8_t )stored->msg.qos;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i8temp = (uint8_t )stored->msg.retain;
write_e(db_fptr, &i8temp, sizeof(uint8_t));
i32temp = htonl(stored->msg.payloadlen);
write_e(db_fptr, &i32temp, sizeof(uint32_t));
if(stored->msg.payloadlen){
write_e(db_fptr, stored->msg.payload, stored->msg.payloadlen);
}
stored = stored->next;
}
return MOSQ_ERR_SUCCESS;
error:
_mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
return 1;
}
int persist__chunk_message_store_write_v5(FILE *db_fptr, struct P_msg_store *chunk)
{
struct PF_header header;
uint32_t payloadlen = chunk->F.payloadlen;
uint16_t source_id_len = chunk->F.source_id_len;
uint16_t source_username_len = chunk->F.source_username_len;
uint16_t topic_len = chunk->F.topic_len;
uint32_t proplen = 0;
struct mosquitto__packet prop_packet;
int rc;
memset(&prop_packet, 0, sizeof(struct mosquitto__packet));
if(chunk->properties){
proplen = property__get_length_all(chunk->properties);
proplen += packet__varint_bytes(proplen);
}
chunk->F.payloadlen = htonl(chunk->F.payloadlen);
chunk->F.source_mid = htons(chunk->F.source_mid);
chunk->F.source_id_len = htons(chunk->F.source_id_len);
chunk->F.source_username_len = htons(chunk->F.source_username_len);
chunk->F.topic_len = htons(chunk->F.topic_len);
chunk->F.source_port = htons(chunk->F.source_port);
header.chunk = htonl(DB_CHUNK_MSG_STORE);
header.length = htonl(sizeof(struct PF_msg_store) +
topic_len + payloadlen +
source_id_len + source_username_len + proplen);
write_e(db_fptr, &header, sizeof(struct PF_header));
write_e(db_fptr, &chunk->F, sizeof(struct PF_msg_store));
if(source_id_len){
write_e(db_fptr, chunk->source.id, source_id_len);
}
if(source_username_len){
write_e(db_fptr, chunk->source.username, source_username_len);
}
write_e(db_fptr, chunk->topic, topic_len);
if(payloadlen){
write_e(db_fptr, UHPA_ACCESS(chunk->payload, payloadlen), (unsigned int)payloadlen);
}
if(chunk->properties){
if(proplen > 0){
prop_packet.remaining_length = proplen;
prop_packet.packet_length = proplen;
prop_packet.payload = mosquitto__malloc(proplen);
if(!prop_packet.payload){
return MOSQ_ERR_NOMEM;
}
rc = property__write_all(&prop_packet, chunk->properties, true);
if(rc) return rc;
write_e(db_fptr, prop_packet.payload, proplen);
mosquitto__free(prop_packet.payload);
}
}
return MOSQ_ERR_SUCCESS;
error:
log__printf(NULL, MOSQ_LOG_ERR, "Error: %s.", strerror(errno));
mosquitto__free(prop_packet.payload);
return 1;
}
