diff --git a/src/mosquitto_broker_internal.h b/src/mosquitto_broker_internal.h index 4838bb9b..529db695 100644 --- a/src/mosquitto_broker_internal.h +++ b/src/mosquitto_broker_internal.h @@ -665,7 +665,7 @@ void sub__tree_print(struct mosquitto__subhier *root, int level); int sub__clean_session(struct mosquitto_db *db, struct mosquitto *context); int sub__retain_queue(struct mosquitto_db *db, struct mosquitto *context, const char *sub, int sub_qos, uint32_t subscription_identifier); int sub__messages_queue(struct mosquitto_db *db, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store **stored); -int sub__topic_tokenise(const char *subtopic, struct sub__token **topics); +int sub__topic_tokenise(const char *subtopic, char **local_sub, char ***topics, const char **sharename); void sub__topic_tokens_free(struct sub__token *tokens); /* ============================================================ @@ -724,7 +724,7 @@ int property__process_disconnect(struct mosquitto *context, mosquitto_property * int retain__init(struct mosquitto_db *db); void retain__clean(struct mosquitto_db *db, struct mosquitto__retainhier **retainhier); int retain__queue(struct mosquitto_db *db, struct mosquitto *context, const char *sub, int sub_qos, uint32_t subscription_identifier); -int retain__store(struct mosquitto_db *db, const char *topic, struct mosquitto_msg_store *stored, struct sub__token *tokens); +int retain__store(struct mosquitto_db *db, const char *topic, struct mosquitto_msg_store *stored, char **split_topics); /* ============================================================ * Security related functions diff --git a/src/persist_read.c b/src/persist_read.c index bf99bc73..d16384b5 100644 --- a/src/persist_read.c +++ b/src/persist_read.c @@ -316,6 +316,8 @@ static int persist__retain_chunk_restore(struct mosquitto_db *db, FILE *db_fptr) struct mosquitto_msg_store_load *load; struct P_retain chunk; int rc; + char **split_topics; + char *local_topic; memset(&chunk, 0, sizeof(struct P_retain)); @@ -331,7 +333,10 @@ static int persist__retain_chunk_restore(struct mosquitto_db *db, FILE *db_fptr) HASH_FIND(hh, db->msg_store_load, &chunk.F.store_id, sizeof(dbid_t), load); if(load){ - retain__store(db, load->store->topic, load->store, NULL); + if(sub__topic_tokenise(load->store->topic, &local_topic, &split_topics, NULL)) return 1; + retain__store(db, load->store->topic, load->store, split_topics); + mosquitto__free(local_topic); + mosquitto__free(split_topics); }else{ /* Can't find the message - probably expired */ } diff --git a/src/retain.c b/src/retain.c index 8de189db..238b63b7 100644 --- a/src/retain.c +++ b/src/retain.c @@ -70,35 +70,29 @@ int retain__init(struct mosquitto_db *db) } -int retain__store(struct mosquitto_db *db, const char *topic, struct mosquitto_msg_store *stored, struct sub__token *tokens) +int retain__store(struct mosquitto_db *db, const char *topic, struct mosquitto_msg_store *stored, char **split_topics) { struct mosquitto__retainhier *retainhier; struct mosquitto__retainhier *branch; - struct sub__token *local_tokens = NULL, *token_current; + int i; + int slen; assert(stored); - if(tokens == NULL){ - if(sub__topic_tokenise(topic, &local_tokens)) return 1; - }else{ - local_tokens = tokens; - } - token_current = local_tokens; + assert(split_topics); - HASH_FIND(hh, db->retains, local_tokens->topic, local_tokens->topic_len, retainhier); + HASH_FIND(hh, db->retains, split_topics[0], strlen(split_topics[0]), retainhier); + if(retainhier == NULL) return 1; - while(token_current){ - HASH_FIND(hh, retainhier->children, token_current->topic, token_current->topic_len, branch); + for(i=0; split_topics[i] != NULL; i++){ + slen = strlen(split_topics[i]); + HASH_FIND(hh, retainhier->children, split_topics[i], slen, branch); if(branch == NULL){ - branch = retain__add_hier_entry(retainhier, &retainhier->children, token_current->topic, token_current->topic_len); + branch = retain__add_hier_entry(retainhier, &retainhier->children, split_topics[i], slen); if(branch == NULL){ - if(tokens == NULL){ - sub__topic_tokens_free(local_tokens); - } return MOSQ_ERR_NOMEM; } } retainhier = branch; - token_current = token_current->next; } #ifdef WITH_PERSISTENCE @@ -124,10 +118,6 @@ int retain__store(struct mosquitto_db *db, const char *topic, struct mosquitto_m retainhier->retained = NULL; } - if(tokens == NULL){ - sub__topic_tokens_free(local_tokens); - } - return MOSQ_ERR_SUCCESS; } @@ -198,12 +188,12 @@ static int retain__process(struct mosquitto_db *db, struct mosquitto__retainhier } -static int retain__search(struct mosquitto_db *db, struct mosquitto__retainhier *retainhier, struct sub__token *tokens, struct mosquitto *context, const char *sub, int sub_qos, uint32_t subscription_identifier, time_t now, int level) +static int retain__search(struct mosquitto_db *db, struct mosquitto__retainhier *retainhier, char **split_topics, struct mosquitto *context, const char *sub, int sub_qos, uint32_t subscription_identifier, time_t now, int level) { struct mosquitto__retainhier *branch, *branch_tmp; int flag = 0; - if(!strcmp(tokens->topic, "#") && !tokens->next){ + if(!strcmp(split_topics[0], "#") && split_topics[1] == NULL){ HASH_ITER(hh, retainhier->children, branch, branch_tmp){ /* Set flag to indicate that we should check for retained messages * on "foo" when we are subscribing to e.g. "foo/#" and then exit @@ -214,15 +204,15 @@ static int retain__search(struct mosquitto_db *db, struct mosquitto__retainhier retain__process(db, branch, context, sub_qos, subscription_identifier, now); } if(branch->children){ - retain__search(db, branch, tokens, context, sub, sub_qos, subscription_identifier, now, level+1); + retain__search(db, branch, split_topics, context, sub, sub_qos, subscription_identifier, now, level+1); } } }else{ - if(!strcmp(tokens->topic, "+")){ + if(!strcmp(split_topics[0], "+")){ HASH_ITER(hh, retainhier->children, branch, branch_tmp){ - if(tokens->next){ - if(retain__search(db, branch, tokens->next, context, sub, sub_qos, subscription_identifier, now, level+1) == -1 - || (tokens->next && !strcmp(tokens->next->topic, "#") && level>0)){ + if(split_topics[1] != NULL){ + if(retain__search(db, branch, &(split_topics[1]), context, sub, sub_qos, subscription_identifier, now, level+1) == -1 + || (split_topics[1] != NULL && !strcmp(split_topics[1], "#") && level>0)){ if(branch->retained){ retain__process(db, branch, context, sub_qos, subscription_identifier, now); @@ -235,11 +225,11 @@ static int retain__search(struct mosquitto_db *db, struct mosquitto__retainhier } } }else{ - HASH_FIND(hh, retainhier->children, tokens->topic, tokens->topic_len, branch); + HASH_FIND(hh, retainhier->children, split_topics[0], strlen(split_topics[0]), branch); if(branch){ - if(tokens->next){ - if(retain__search(db, branch, tokens->next, context, sub, sub_qos, subscription_identifier, now, level+1) == -1 - || (tokens->next && !strcmp(tokens->next->topic, "#") && level>0)){ + if(split_topics[1] != NULL){ + if(retain__search(db, branch, &(split_topics[1]), context, sub, sub_qos, subscription_identifier, now, level+1) == -1 + || (split_topics[1] != NULL && !strcmp(split_topics[1], "#") && level>0)){ if(branch->retained){ retain__process(db, branch, context, sub_qos, subscription_identifier, now); @@ -260,22 +250,26 @@ static int retain__search(struct mosquitto_db *db, struct mosquitto__retainhier int retain__queue(struct mosquitto_db *db, struct mosquitto *context, const char *sub, int sub_qos, uint32_t subscription_identifier) { struct mosquitto__retainhier *retainhier; - struct sub__token *tokens = NULL; + char *local_sub; + char **split_topics; time_t now; + int rc; assert(db); assert(context); assert(sub); - if(sub__topic_tokenise(sub, &tokens)) return 1; + rc = sub__topic_tokenise(sub, &local_sub, &split_topics, NULL); + if(rc) return rc; - HASH_FIND(hh, db->retains, tokens->topic, tokens->topic_len, retainhier); + HASH_FIND(hh, db->retains, split_topics[0], strlen(split_topics[0]), retainhier); if(retainhier){ now = time(NULL); - retain__search(db, retainhier, tokens, context, sub, sub_qos, subscription_identifier, now, 0); + retain__search(db, retainhier, split_topics, context, sub, sub_qos, subscription_identifier, now, 0); } - sub__topic_tokens_free(tokens); + mosquitto__free(local_sub); + mosquitto__free(split_topics); return MOSQ_ERR_SUCCESS; } diff --git a/src/subs.c b/src/subs.c index 57014193..23a7d512 100644 --- a/src/subs.c +++ b/src/subs.c @@ -190,14 +190,13 @@ static void sub__remove_shared_leaf(struct mosquitto__subhier *subhier, struct m DL_DELETE(shared->subs, leaf); if(shared->subs == NULL){ HASH_DELETE(hh, subhier->shared, shared); - mosquitto__free(shared->name); mosquitto__free(shared); } mosquitto__free(leaf); } -static int sub__add_shared(struct mosquitto_db *db, struct mosquitto *context, int qos, uint32_t identifier, int options, struct mosquitto__subhier *subhier, char *sharename) +static int sub__add_shared(struct mosquitto_db *db, struct mosquitto *context, int qos, uint32_t identifier, int options, struct mosquitto__subhier *subhier, const char *sharename) { struct mosquitto__subleaf *newleaf; struct mosquitto__subshared *shared = NULL; @@ -210,15 +209,16 @@ static int sub__add_shared(struct mosquitto_db *db, struct mosquitto *context, i slen = strlen(sharename); HASH_FIND(hh, subhier->shared, sharename, slen, shared); - if(shared){ - mosquitto__free(sharename); - }else{ + if(shared == NULL){ shared = mosquitto__calloc(1, sizeof(struct mosquitto__subshared)); if(!shared){ - mosquitto__free(sharename); return MOSQ_ERR_NOMEM; } - shared->name = sharename; + shared->name = mosquitto__strdup(sharename); + if(shared->name == NULL){ + mosquitto__free(shared); + return MOSQ_ERR_NOMEM; + } HASH_ADD_KEYPTR(hh, subhier->shared, shared->name, slen, shared); } @@ -318,20 +318,21 @@ static int sub__add_normal(struct mosquitto_db *db, struct mosquitto *context, i } -static int sub__add_context(struct mosquitto_db *db, struct mosquitto *context, int qos, uint32_t identifier, int options, struct mosquitto__subhier *subhier, struct sub__token *tokens, char *sharename) +static int sub__add_context(struct mosquitto_db *db, struct mosquitto *context, int qos, uint32_t identifier, int options, struct mosquitto__subhier *subhier, char *const *const topics, const char *sharename) { struct mosquitto__subhier *branch; + int topic_index = 0; /* Find leaf node */ - while(tokens){ - HASH_FIND(hh, subhier->children, tokens->topic, tokens->topic_len, branch); + while(topics && topics[topic_index] != NULL){ + HASH_FIND(hh, subhier->children, topics[topic_index], strlen(topics[topic_index]), branch); if(!branch){ /* Not found */ - branch = sub__add_hier_entry(subhier, &subhier->children, tokens->topic, tokens->topic_len); + branch = sub__add_hier_entry(subhier, &subhier->children, topics[topic_index], strlen(topics[topic_index])); if(!branch) return MOSQ_ERR_NOMEM; } subhier = branch; - tokens = tokens ->next; + topic_index++; } /* Add add our context */ @@ -380,14 +381,13 @@ static int sub__remove_normal(struct mosquitto_db *db, struct mosquitto *context } -static int sub__remove_shared(struct mosquitto_db *db, struct mosquitto *context, struct mosquitto__subhier *subhier, uint8_t *reason, char *sharename) +static int sub__remove_shared(struct mosquitto_db *db, struct mosquitto *context, struct mosquitto__subhier *subhier, uint8_t *reason, const char *sharename) { struct mosquitto__subshared *shared; struct mosquitto__subleaf *leaf; int i; HASH_FIND(hh, subhier->shared, sharename, strlen(sharename), shared); - mosquitto__free(sharename); if(shared){ leaf = shared->subs; while(leaf){ @@ -431,11 +431,11 @@ static int sub__remove_shared(struct mosquitto_db *db, struct mosquitto *context } -static int sub__remove_recurse(struct mosquitto_db *db, struct mosquitto *context, struct mosquitto__subhier *subhier, struct sub__token *tokens, uint8_t *reason, char *sharename) +static int sub__remove_recurse(struct mosquitto_db *db, struct mosquitto *context, struct mosquitto__subhier *subhier, char **topics, uint8_t *reason, const char *sharename) { struct mosquitto__subhier *branch; - if(!tokens){ + if(topics == NULL || topics[0] == NULL){ if(sharename){ return sub__remove_shared(db, context, subhier, reason, sharename); }else{ @@ -443,9 +443,9 @@ static int sub__remove_recurse(struct mosquitto_db *db, struct mosquitto *contex } } - HASH_FIND(hh, subhier->children, tokens->topic, tokens->topic_len, branch); + HASH_FIND(hh, subhier->children, topics[0], strlen(topics[0]), branch); if(branch){ - sub__remove_recurse(db, context, branch, tokens->next, reason, sharename); + sub__remove_recurse(db, context, branch, &(topics[1]), reason, sharename); if(!branch->children && !branch->subs && !branch->shared){ HASH_DELETE(hh, subhier->children, branch); mosquitto__free(branch->topic); @@ -455,25 +455,26 @@ static int sub__remove_recurse(struct mosquitto_db *db, struct mosquitto *contex return MOSQ_ERR_SUCCESS; } -static int sub__search(struct mosquitto_db *db, struct mosquitto__subhier *subhier, struct sub__token *tokens, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored) + +static int sub__search(struct mosquitto_db *db, struct mosquitto__subhier *subhier, char **split_topics, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store *stored) { /* FIXME - need to take into account source_id if the client is a bridge */ struct mosquitto__subhier *branch; int rc; bool have_subscribers = false; - if(tokens){ + if(split_topics && split_topics[0]){ /* Check for literal match */ - HASH_FIND(hh, subhier->children, tokens->topic, tokens->topic_len, branch); + HASH_FIND(hh, subhier->children, split_topics[0], strlen(split_topics[0]), branch); if(branch){ - rc = sub__search(db, branch, tokens->next, source_id, topic, qos, retain, stored); + rc = sub__search(db, branch, &(split_topics[1]), source_id, topic, qos, retain, stored); if(rc == MOSQ_ERR_SUCCESS){ have_subscribers = true; }else if(rc != MOSQ_ERR_NO_SUBSCRIBERS){ return rc; } - if(!tokens->next){ + if(split_topics[1] == NULL){ /* End of list */ rc = subs__process(db, branch, source_id, topic, qos, retain, stored); if(rc == MOSQ_ERR_SUCCESS){ have_subscribers = true; @@ -487,13 +488,13 @@ static int sub__search(struct mosquitto_db *db, struct mosquitto__subhier *subhi HASH_FIND(hh, subhier->children, "+", 1, branch); if(branch){ - rc = sub__search(db, branch, tokens->next, source_id, topic, qos, retain, stored); + rc = sub__search(db, branch, &(split_topics[1]), source_id, topic, qos, retain, stored); if(rc == MOSQ_ERR_SUCCESS){ have_subscribers = true; }else if(rc != MOSQ_ERR_NO_SUBSCRIBERS){ return rc; } - if(!tokens->next){ + if(split_topics[1] == NULL){ /* End of list */ rc = subs__process(db, branch, source_id, topic, qos, retain, stored); if(rc == MOSQ_ERR_SUCCESS){ have_subscribers = true; @@ -540,14 +541,12 @@ struct mosquitto__subhier *sub__add_hier_entry(struct mosquitto__subhier *parent } child->parent = parent; child->topic_len = len; - child->topic = mosquitto__malloc(len+1); + child->topic = mosquitto__strdup(topic); if(!child->topic){ child->topic_len = 0; mosquitto__free(child); log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return NULL; - }else{ - strncpy(child->topic, topic, child->topic_len+1); } HASH_ADD_KEYPTR(hh, *sibling, child->topic, child->topic_len, child); @@ -560,49 +559,32 @@ int sub__add(struct mosquitto_db *db, struct mosquitto *context, const char *sub { int rc = 0; struct mosquitto__subhier *subhier; - struct sub__token *tokens = NULL, *t; - char *sharename = NULL; + const char *sharename = NULL; + char *local_sub; + char **topics; assert(root); assert(*root); assert(sub); - if(sub__topic_tokenise(sub, &tokens)) return 1; + rc = sub__topic_tokenise(sub, &local_sub, &topics, &sharename); + if(rc) return rc; - if(!strcmp(tokens->topic, "$share")){ - if(!tokens->next || !tokens->next->next){ - sub__topic_tokens_free(tokens); - return MOSQ_ERR_PROTOCOL; - } - t = tokens->next; - mosquitto__free(tokens->topic); - mosquitto__free(tokens); - tokens = t; - - sharename = tokens->topic; - - tokens->topic = mosquitto__strdup(""); - if(!tokens->topic){ - tokens->topic = sharename; - sub__topic_tokens_free(tokens); - return MOSQ_ERR_PROTOCOL; - } - tokens->topic_len = 0; - } - - HASH_FIND(hh, *root, tokens->topic, tokens->topic_len, subhier); + HASH_FIND(hh, *root, topics[0], strlen(topics[0]), subhier); if(!subhier){ - subhier = sub__add_hier_entry(NULL, root, tokens->topic, tokens->topic_len); + subhier = sub__add_hier_entry(NULL, root, topics[0], strlen(topics[0])); if(!subhier){ - sub__topic_tokens_free(tokens); + mosquitto__free(local_sub); + mosquitto__free(topics); log__printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } } - rc = sub__add_context(db, context, qos, identifier, options, subhier, tokens, sharename); + rc = sub__add_context(db, context, qos, identifier, options, subhier, topics, sharename); - sub__topic_tokens_free(tokens); + mosquitto__free(local_sub); + mosquitto__free(topics); return rc; } @@ -611,56 +593,39 @@ int sub__remove(struct mosquitto_db *db, struct mosquitto *context, const char * { int rc = 0; struct mosquitto__subhier *subhier; - struct sub__token *tokens = NULL, *t; - char *sharename = NULL; + const char *sharename = NULL; + char *local_sub = NULL; + char **topics = NULL; assert(root); assert(sub); - if(sub__topic_tokenise(sub, &tokens)) return 1; + rc = sub__topic_tokenise(sub, &local_sub, &topics, &sharename); + if(rc) return rc; - if(!strcmp(tokens->topic, "$share")){ - if(!tokens->next || !tokens->next->next){ - sub__topic_tokens_free(tokens); - return MOSQ_ERR_PROTOCOL; - } - t = tokens->next; - mosquitto__free(tokens->topic); - mosquitto__free(tokens); - tokens = t; - - sharename = tokens->topic; - - tokens->topic = mosquitto__strdup(""); - if(!tokens->topic){ - tokens->topic = sharename; - sub__topic_tokens_free(tokens); - return MOSQ_ERR_PROTOCOL; - } - tokens->topic_len = 0; - } - - HASH_FIND(hh, root, tokens->topic, tokens->topic_len, subhier); + HASH_FIND(hh, root, topics[0], strlen(topics[0]), subhier); if(subhier){ *reason = MQTT_RC_NO_SUBSCRIPTION_EXISTED; - rc = sub__remove_recurse(db, context, subhier, tokens, reason, sharename); + rc = sub__remove_recurse(db, context, subhier, topics, reason, sharename); } - sub__topic_tokens_free(tokens); + mosquitto__free(local_sub); + mosquitto__free(topics); return rc; } int sub__messages_queue(struct mosquitto_db *db, const char *source_id, const char *topic, int qos, int retain, struct mosquitto_msg_store **stored) { - int rc = 0, rc2; + int rc = MOSQ_ERR_SUCCESS, rc2; struct mosquitto__subhier *subhier; - struct sub__token *tokens = NULL; + char **split_topics = NULL; + char *local_topic = NULL; assert(db); assert(topic); - if(sub__topic_tokenise(topic, &tokens)) return 1; + if(sub__topic_tokenise(topic, &local_topic, &split_topics, NULL)) return 1; /* Protect this message until we have sent it to all clients - this is required because websockets client calls @@ -668,20 +633,18 @@ int sub__messages_queue(struct mosquitto_db *db, const char *source_id, const ch */ db__msg_store_ref_inc(*stored); - HASH_FIND(hh, db->subs, tokens->topic, tokens->topic_len, subhier); + HASH_FIND(hh, db->subs, split_topics[0], strlen(split_topics[0]), subhier); if(subhier){ - rc = sub__search(db, subhier, tokens, source_id, topic, qos, retain, *stored); + rc = sub__search(db, subhier, split_topics, source_id, topic, qos, retain, *stored); } if(retain){ - rc2 = retain__store(db, topic, *stored, tokens); - if(rc2){ - sub__topic_tokens_free(tokens); - db__msg_store_ref_dec(db, stored); - return rc2; - } + rc2 = retain__store(db, topic, *stored, split_topics); + if(rc2) rc = rc2; } - sub__topic_tokens_free(tokens); + + mosquitto__free(split_topics); + mosquitto__free(local_topic); /* Remove our reference and free if needed. */ db__msg_store_ref_dec(db, stored); diff --git a/src/topic_tok.c b/src/topic_tok.c index 4c814bd4..6128c812 100644 --- a/src/topic_tok.c +++ b/src/topic_tok.c @@ -28,117 +28,83 @@ Contributors: #include "utlist.h" -static struct sub__token *sub__topic_append(struct sub__token **tail, struct sub__token **topics, char *topic) +static char *strtok_hier(char *str, char **saveptr) { - struct sub__token *new_topic; + char *c; - if(!topic){ - return NULL; + if(str != NULL){ + *saveptr = str; } - new_topic = mosquitto__malloc(sizeof(struct sub__token)); - if(!new_topic){ - return NULL; - } - new_topic->next = NULL; - new_topic->topic_len = strlen(topic); - new_topic->topic = mosquitto__malloc(new_topic->topic_len+1); - if(!new_topic->topic){ - mosquitto__free(new_topic); - return NULL; - } - strncpy(new_topic->topic, topic, new_topic->topic_len+1); - if(*tail){ - (*tail)->next = new_topic; - *tail = (*tail)->next; - }else{ - *topics = new_topic; - *tail = new_topic; + if(*saveptr == NULL){ + return NULL; } - return new_topic; + + c = strchr(*saveptr, '/'); + if(c){ + str = *saveptr; + *saveptr = c+1; + c[0] = '\0'; + }else if(*saveptr){ + /* No match, but surplus string */ + str = *saveptr; + *saveptr = NULL; + } + return str; } -int sub__topic_tokenise(const char *subtopic, struct sub__token **topics) +int sub__topic_tokenise(const char *subtopic, char **local_sub, char ***topics, const char **sharename) { - struct sub__token *new_topic, *tail = NULL; - int len; - int start, stop, tlen; + char *saveptr = NULL; + char *token; + int count; + int topic_index = 0; int i; - char *topic; - int count = 0; - assert(subtopic); - assert(topics); + *local_sub = mosquitto__strdup(subtopic); + if((*local_sub) == NULL) return MOSQ_ERR_NOMEM; - if(subtopic[0] != '$'){ - new_topic = sub__topic_append(&tail, topics, ""); - if(!new_topic) goto cleanup; + count = 0; + saveptr = *local_sub; + while(saveptr){ + saveptr = strchr(&saveptr[1], '/'); + count++; + } + *topics = mosquitto__calloc(count+3 /* 3=$,shared,sharename */, sizeof(char *)); + if((*topics) == NULL){ + mosquitto__free(*local_sub); + return MOSQ_ERR_NOMEM; } - len = strlen(subtopic); - - if(subtopic[0] == '/'){ - new_topic = sub__topic_append(&tail, topics, ""); - if(!new_topic) goto cleanup; - - start = 1; - }else{ - start = 0; + if((*local_sub)[0] != '$'){ + (*topics)[topic_index] = ""; + topic_index++; } - stop = 0; - for(i=start; i TOPIC_HIERARCHY_LIMIT){ - /* Set limit on hierarchy levels, to restrict stack usage. */ - goto cleanup; - } + if(sharename){ + (*sharename) = (*topics)[1]; + } + for(i=1; itopic); - new_topic = tail->next; - mosquitto__free(tail); - tail = new_topic; - } - return 1; } - - -void sub__topic_tokens_free(struct sub__token *tokens) -{ - struct sub__token *tail; - - while(tokens){ - tail = tokens->next; - mosquitto__free(tokens->topic); - mosquitto__free(tokens); - tokens = tail; - } -} - diff --git a/test/broker/02-subpub-qos0-long-topic.py b/test/broker/02-subpub-qos0-long-topic.py index 7cd144ab..603f504e 100755 --- a/test/broker/02-subpub-qos0-long-topic.py +++ b/test/broker/02-subpub-qos0-long-topic.py @@ -43,7 +43,7 @@ do_test("/"*200, True) # 200 max hierarchy limit do_test("abc/"*199+"d", True) # 200 max hierarchy limit, longer overall string than 200 do_test("/"*201, False) # Exceeds 200 max hierarchy limit -do_test("abc/"*200+"d", False) # Exceeds 200 max hierarchy limit, longer overall string than 200 +do_test("abc/"*201+"d", False) # Exceeds 200 max hierarchy limit, longer overall string than 200 exit(0)