jabber.developer2
250703a0bf
All checks were successful
CI Code / Check spelling (pull_request) Successful in 14s
CI Code / Check coding style (pull_request) Successful in 26s
CI Code / Code Coverage (pull_request) Successful in 3m29s
CI Code / Linux (debian) (pull_request) Successful in 5m13s
CI Code / Linux (ubuntu) (pull_request) Successful in 5m16s
CI Code / Linux (arch) (pull_request) Successful in 7m34s
T02: guard the receive-path handlers that dereferenced jid_create() without a NULL check — MUC join errors, subscribed/unsubscribed presence and, with silence.non-roster enabled, every incoming message. A stanza with a missing or malformed 'from' crashed the client (REQ-INP-01) T11: restrict /url open and /url save to http, https and aesgcm, so a received file:, javascript: or data: URL is refused (REQ-INP-06); spawn terminal-notifier through g_spawn_async with an argv instead of building a shell command for system() (REQ-INP-07); apply the XEP-0359 disco gate to MAM result ids, as live stanza-ids already do (REQ-INP-05); replace control and bidi-reordering characters in incoming message bodies with U+FFFD before they reach the terminal, the logs and the database, keeping LRM/RLM for legitimate RTL text (REQ-INP-08); cover JID part-length boundaries and invalid UTF-8 (REQ-INP-02) T10: replace strcpy/strcat/alloca and sprintf with g_strdup_printf and g_snprintf (REQ-MEM-03); allocate the OMEMO key buffers with g_malloc so a failed allocation cannot reach the following memcpy (REQ-MEM-04); remove the variable-length arrays and enforce -Werror=vla. Two of them were sized from remote input: the disco#info feature count and a chat message word length. The flag also caught a one-past-the-end write and a leak in the plugin autocompleter bindings (REQ-MEM-09)
445 lines
12 KiB
C
445 lines
12 KiB
C
#include "prof_cmocka.h"
|
|
#include <stdlib.h>
|
|
|
|
#include "xmpp/jid.h"
|
|
|
|
void
|
|
jid_create__returns__null_from_null(void** state)
|
|
{
|
|
Jid* result = jid_create(NULL);
|
|
assert_null(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_from_empty_string(void** state)
|
|
{
|
|
Jid* result = jid_create("");
|
|
assert_null(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__full_from_full(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain/laptop");
|
|
assert_string_equal("myuser@mydomain/laptop", result->fulljid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__bare_from_full(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain/laptop");
|
|
assert_string_equal("myuser@mydomain", result->barejid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__resourcepart_from_full(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain/laptop");
|
|
assert_string_equal("laptop", result->resourcepart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__localpart_from_full(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain/laptop");
|
|
assert_string_equal("myuser", result->localpart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__domainpart_from_full(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain/laptop");
|
|
assert_string_equal("mydomain", result->domainpart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__full_from_full_nolocal(void** state)
|
|
{
|
|
Jid* result = jid_create("mydomain/laptop");
|
|
assert_string_equal("mydomain/laptop", result->fulljid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__bare_from_full_nolocal(void** state)
|
|
{
|
|
Jid* result = jid_create("mydomain/laptop");
|
|
assert_string_equal("mydomain", result->barejid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__resourcepart_from_full_nolocal(void** state)
|
|
{
|
|
Jid* result = jid_create("mydomain/laptop");
|
|
assert_string_equal("laptop", result->resourcepart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__domainpart_from_full_nolocal(void** state)
|
|
{
|
|
Jid* result = jid_create("mydomain/laptop");
|
|
assert_string_equal("mydomain", result->domainpart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_localpart_from_full_nolocal(void** state)
|
|
{
|
|
Jid* result = jid_create("mydomain/laptop");
|
|
assert_null(result->localpart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_full_from_bare(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain");
|
|
assert_null(result->fulljid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_resource_from_bare(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain");
|
|
assert_null(result->resourcepart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__bare_from_bare(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain");
|
|
assert_string_equal("myuser@mydomain", result->barejid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__localpart_from_bare(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain");
|
|
assert_string_equal("myuser", result->localpart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__domainpart_from_bare(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain");
|
|
assert_string_equal("mydomain", result->domainpart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create_from_bare_and_resource__returns__room(void** state)
|
|
{
|
|
Jid* result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");
|
|
|
|
assert_string_equal("room@conference.domain.org", result->barejid);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create_from_bare_and_resource__returns__nick(void** state)
|
|
{
|
|
Jid* result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");
|
|
|
|
assert_string_equal("myname", result->resourcepart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__correct_parts_with_slash_in_resource(void** state)
|
|
{
|
|
Jid* result = jid_create("room@conference.domain.org/my/nick");
|
|
|
|
assert_string_equal("room", result->localpart);
|
|
assert_string_equal("conference.domain.org", result->domainpart);
|
|
assert_string_equal("my/nick", result->resourcepart);
|
|
assert_string_equal("room@conference.domain.org", result->barejid);
|
|
assert_string_equal("room@conference.domain.org/my/nick", result->fulljid);
|
|
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__correct_parts_with_at_in_resource(void** state)
|
|
{
|
|
Jid* result = jid_create("room@conference.domain.org/my@nick");
|
|
|
|
assert_string_equal("room", result->localpart);
|
|
assert_string_equal("conference.domain.org", result->domainpart);
|
|
assert_string_equal("my@nick", result->resourcepart);
|
|
assert_string_equal("room@conference.domain.org", result->barejid);
|
|
assert_string_equal("room@conference.domain.org/my@nick", result->fulljid);
|
|
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__correct_parts_with_at_and_slash_in_resource(void** state)
|
|
{
|
|
Jid* result = jid_create("room@conference.domain.org/my@nick/something");
|
|
|
|
assert_string_equal("room", result->localpart);
|
|
assert_string_equal("conference.domain.org", result->domainpart);
|
|
assert_string_equal("my@nick/something", result->resourcepart);
|
|
assert_string_equal("room@conference.domain.org", result->barejid);
|
|
assert_string_equal("room@conference.domain.org/my@nick/something", result->fulljid);
|
|
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__correct_parts_with_trailing_slash(void** state)
|
|
{
|
|
Jid* result = jid_create("room@conference.domain.org/nick/");
|
|
|
|
assert_string_equal("room", result->localpart);
|
|
assert_string_equal("conference.domain.org", result->domainpart);
|
|
assert_string_equal("nick/", result->resourcepart);
|
|
assert_string_equal("room@conference.domain.org", result->barejid);
|
|
assert_string_equal("room@conference.domain.org/nick/", result->fulljid);
|
|
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_fulljid_or_barejid__returns__fulljid_when_exists(void** state)
|
|
{
|
|
Jid* jid = jid_create("localpart@domainpart/resourcepart");
|
|
|
|
const gchar* result = jid_fulljid_or_barejid(jid);
|
|
|
|
assert_string_equal("localpart@domainpart/resourcepart", result);
|
|
|
|
jid_destroy(jid);
|
|
}
|
|
|
|
void
|
|
jid_fulljid_or_barejid__returns__barejid_when_fulljid_not_exists(void** state)
|
|
{
|
|
Jid* jid = jid_create("localpart@domainpart");
|
|
|
|
const gchar* result = jid_fulljid_or_barejid(jid);
|
|
|
|
assert_string_equal("localpart@domainpart", result);
|
|
|
|
jid_destroy(jid);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__bare_from_trailing_slash(void** state)
|
|
{
|
|
Jid* result = jid_create("myuser@mydomain/");
|
|
assert_non_null(result);
|
|
assert_string_equal("myuser@mydomain", result->barejid);
|
|
assert_null(result->resourcepart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_from_invalid_localpart_chars(void** state)
|
|
{
|
|
// Space
|
|
Jid* result = jid_create("user name@domain.com");
|
|
assert_null(result);
|
|
|
|
// Double quote
|
|
result = jid_create("user\"name@domain.com");
|
|
assert_null(result);
|
|
|
|
// Ampersand
|
|
result = jid_create("user&name@domain.com");
|
|
assert_null(result);
|
|
|
|
// Single quote
|
|
result = jid_create("user'name@domain.com");
|
|
assert_null(result);
|
|
|
|
// Colon
|
|
result = jid_create("user:name@domain.com");
|
|
assert_null(result);
|
|
|
|
// Less than
|
|
result = jid_create("user<name@domain.com");
|
|
assert_null(result);
|
|
|
|
// Greater than
|
|
result = jid_create("user>name@domain.com");
|
|
assert_null(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_from_empty_parts(void** state)
|
|
{
|
|
// Empty local
|
|
Jid* result = jid_create("@domain.com");
|
|
assert_null(result);
|
|
|
|
// Empty domain (trailing @)
|
|
result = jid_create("user@");
|
|
assert_null(result);
|
|
|
|
// Empty domain in full jid
|
|
result = jid_create("user@/resource");
|
|
assert_null(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__null_from_multiple_at_in_bare(void** state)
|
|
{
|
|
Jid* result = jid_create("user@domain@other.com");
|
|
assert_null(result);
|
|
}
|
|
|
|
void
|
|
jid_create__returns__correct_parts_with_at_in_resource_only(void** state)
|
|
{
|
|
// domain.com/user@host (no localpart)
|
|
Jid* result = jid_create("domain.com/user@host");
|
|
assert_non_null(result);
|
|
assert_null(result->localpart);
|
|
assert_string_equal("domain.com", result->domainpart);
|
|
assert_string_equal("user@host", result->resourcepart);
|
|
jid_destroy(result);
|
|
}
|
|
|
|
void
|
|
jid_is_valid_user_jid__is__true_for_valid_user_jid(void** state)
|
|
{
|
|
assert_true(jid_is_valid_user_jid("myuser@mydomain/laptop"));
|
|
assert_true(jid_is_valid_user_jid("myuser@mydomain"));
|
|
}
|
|
|
|
void
|
|
jid_is_valid_user_jid__is__true_for_at_in_resource(void** state)
|
|
{
|
|
// RFC 6122 section 2.4: '@' is allowed in the resourcepart.
|
|
assert_true(jid_is_valid_user_jid("myuser@mydomain/user@laptop"));
|
|
assert_true(jid_is_valid_user_jid("room@conference.example.org/user@host.example.org"));
|
|
}
|
|
|
|
void
|
|
jid_is_valid_user_jid__is__false_for_domain_jid(void** state)
|
|
{
|
|
assert_false(jid_is_valid_user_jid("mydomain/laptop"));
|
|
assert_false(jid_is_valid_user_jid("mydomain"));
|
|
}
|
|
|
|
void
|
|
jid_is_valid_user_jid__is__false_for_invalid_jid(void** state)
|
|
{
|
|
assert_false(jid_is_valid_user_jid("@mydomain"));
|
|
assert_false(jid_is_valid_user_jid("/laptop"));
|
|
assert_false(jid_is_valid_user_jid(NULL));
|
|
assert_false(jid_is_valid_user_jid(""));
|
|
}
|
|
|
|
void
|
|
jid_is_valid__is__true_for_valid_jid(void** state)
|
|
{
|
|
assert_true(jid_is_valid("myuser@mydomain/laptop"));
|
|
assert_true(jid_is_valid("myuser@mydomain"));
|
|
assert_true(jid_is_valid("mydomain/laptop"));
|
|
assert_true(jid_is_valid("mydomain"));
|
|
}
|
|
|
|
void
|
|
jid_is_valid__is__false_for_invalid_jid(void** state)
|
|
{
|
|
assert_false(jid_is_valid("@mydomain"));
|
|
assert_false(jid_is_valid("/laptop"));
|
|
}
|
|
|
|
void
|
|
jid_is_valid__is__false_for_null(void** state)
|
|
{
|
|
assert_false(jid_is_valid(NULL));
|
|
}
|
|
|
|
void
|
|
jid_is_valid__is__false_for_empty_string(void** state)
|
|
{
|
|
assert_false(jid_is_valid(""));
|
|
}
|
|
|
|
/* RFC 6122 size limits: 1023 bytes per part, 3071 for the full JID */
|
|
void
|
|
jid_is_valid__boundary__localpart_length(void** state)
|
|
{
|
|
gchar* local_ok = g_strnfill(1023, 'a');
|
|
gchar* jid_ok = g_strdup_printf("%s@domain", local_ok);
|
|
assert_true(jid_is_valid(jid_ok));
|
|
|
|
gchar* local_over = g_strnfill(1024, 'a');
|
|
gchar* jid_over = g_strdup_printf("%s@domain", local_over);
|
|
assert_false(jid_is_valid(jid_over));
|
|
|
|
g_free(local_ok);
|
|
g_free(jid_ok);
|
|
g_free(local_over);
|
|
g_free(jid_over);
|
|
}
|
|
|
|
void
|
|
jid_is_valid__boundary__domainpart_length(void** state)
|
|
{
|
|
gchar* domain_ok = g_strnfill(1023, 'd');
|
|
assert_true(jid_is_valid(domain_ok));
|
|
|
|
gchar* domain_over = g_strnfill(1024, 'd');
|
|
assert_false(jid_is_valid(domain_over));
|
|
|
|
g_free(domain_ok);
|
|
g_free(domain_over);
|
|
}
|
|
|
|
void
|
|
jid_is_valid__boundary__resourcepart_length(void** state)
|
|
{
|
|
gchar* res_ok = g_strnfill(1023, 'r');
|
|
gchar* jid_ok = g_strdup_printf("user@domain/%s", res_ok);
|
|
assert_true(jid_is_valid(jid_ok));
|
|
|
|
gchar* res_over = g_strnfill(1024, 'r');
|
|
gchar* jid_over = g_strdup_printf("user@domain/%s", res_over);
|
|
assert_false(jid_is_valid(jid_over));
|
|
|
|
g_free(res_ok);
|
|
g_free(jid_ok);
|
|
g_free(res_over);
|
|
g_free(jid_over);
|
|
}
|
|
|
|
void
|
|
jid_is_valid__boundary__total_length(void** state)
|
|
{
|
|
// 1023 + '@' + 1023 + '/' + 1023 = 3071, the largest legal JID
|
|
gchar* local = g_strnfill(1023, 'a');
|
|
gchar* domain = g_strnfill(1023, 'd');
|
|
gchar* res = g_strnfill(1023, 'r');
|
|
gchar* jid_max = g_strdup_printf("%s@%s/%s", local, domain, res);
|
|
assert_true(jid_is_valid(jid_max));
|
|
|
|
g_free(local);
|
|
g_free(domain);
|
|
g_free(res);
|
|
g_free(jid_max);
|
|
}
|
|
|
|
void
|
|
jid_is_valid__is__false_for_invalid_utf8(void** state)
|
|
{
|
|
assert_false(jid_is_valid("user\xff\xfe@domain"));
|
|
assert_false(jid_is_valid("us\xc3@domain")); // truncated multi-byte sequence
|
|
assert_false(jid_is_valid("user@domain/res\x80")); // stray continuation byte
|
|
}
|