bool
TestSuccess(const char* hdr, bool extraTokens,
uint64_t expectedMaxAge, bool expectedIncludeSubdomains,
nsISiteSecurityService* sss)
{
nsCOMPtr<nsIURI> dummyUri;
nsresult rv = NS_NewURI(getter_AddRefs(dummyUri), "https://foo.com/bar.html");
EXPECT_SUCCESS(rv, "Failed to create URI");
uint64_t maxAge = 0;
bool includeSubdomains = false;
rv = sss->UnsafeProcessHeader(nsISiteSecurityService::HEADER_HSTS, dummyUri,
hdr, 0, &maxAge, &includeSubdomains, nullptr);
EXPECT_SUCCESS(rv, "Failed to process valid header: %s", hdr);
REQUIRE_EQUAL(maxAge, expectedMaxAge, "Did not correctly parse maxAge");
REQUIRE_EQUAL(includeSubdomains, expectedIncludeSubdomains, "Did not correctly parse presence/absence of includeSubdomains");
if (extraTokens) {
REQUIRE_EQUAL(rv, NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA,
"Extra tokens were expected when parsing, but were not encountered.");
} else {
REQUIRE_EQUAL(rv, NS_OK, "Unexpected tokens found during parsing.");
}
passed(hdr);
return true;
}
static int TestGetCurrentFrameStatic()
{
struct TBacktraceRecord record;
int result = GetCurrentFrame(&record, 0);
REQUIRE_EQUAL(result, 1);
#ifdef __FreeBSD__
REQUIRE_STRINGS_EQUAL(record.Symbol_, "_start");
#else
REQUIRE_EQUAL(record.Symbol_, 0);
#endif
return 0;
}
int TestGetCurrentFrame()
{
struct TBacktraceRecord record;
int result = GetCurrentFrame(&record, 0);
REQUIRE_EQUAL(result, 1);
REQUIRE_STRINGS_EQUAL(record.Symbol_, "TestGetCurrentFrame");
result = GetCurrentFrame(&record, 1);
REQUIRE_EQUAL(result, 1);
REQUIRE_STRINGS_EQUAL(record.Symbol_, "main");
result = GetCurrentFrame(&record, 100);
REQUIRE_EQUAL(result, 0);
return 0;
}
greet_key_response::greet_key_response(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, GREET_KEY_RESPONSE);
_pub_key = m.meta.extra["pub_key"].as_string();
_host = m.meta.extra["from_ip"].as_string();
_port = m.meta.extra["from_port"].as_int();
}
void conversation_service::received_ask_contact_res(const message::message& m)
{
INVARIANT(_user_service);
REQUIRE_EQUAL(m.meta.type, ASK_CONTACT_RES);
m::expect_symmetric(m);
ask_contact_res_msg r;
r.from_message(m);
auto fc = _user_service->user().contacts().by_id(r.from_id);
if(!fc) return;
auto c = _user_service->user().contacts().by_id(r.id);
if(!c) return;
auto s = conversation_by_id(r.conversation_id);
if(!s) return;
s->know_contact(r.id, r.from_id,
r.status == 1 ?
know_request::KNOW : know_request::DONT_KNOW);
auto part_ret = s->part_of_clique(r.id);
switch(part_ret.is_part)
{
case clique_status::PART: add_contact_to_conversation_p(c, s); break;
case clique_status::NOT_PART: fire_not_part_of_clique(s->id(), c->id(), part_ret.contacts); break;
case clique_status::DONT_KNOW: break; // do nothing
default: CHECK(false && "missed case");
};
}
greet_find_request::greet_find_request(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, GREET_FIND_REQUEST);
_from_id = m.meta.extra["from_id"].as_string();
_search_id = m.meta.extra["search_id"].as_string();
}
void backend_client::received_event_message(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, EVENT_MESSAGE);
INVARIANT(_api);
event_message em{m, _api.get()};
_api->event_received(em);
}
//simple low pass filter
void reduce_noise(u::bytes& s, size_t len)
{
REQUIRE_EQUAL(s.size() % 2, 0);
auto ss = reinterpret_cast<short*>(s.data());
len /= 2;
for(size_t i = 1; i < len; i++)
ss[i] = (0.333 * ss[i]) + ((1 - 0.333) * ss[i-1]) + 0.5;
}
void backend_client::received_script_message(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, SCRIPT_MESSAGE);
INVARIANT(_api);
script_message sm{m, _api.get()};
_api->message_received(sm);
}
greet_register::greet_register(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, GREET_REGISTER);
_id = m.meta.extra["from_id"].as_string();
_local.ip = m.meta.extra["loc_ip"].as_string();
_local.port = m.meta.extra["loc_port"].as_int();
_pub_key = m.meta.extra["pub_key"].as_string();
_response_service_address = m.meta.extra["response_address"].as_string();
}
greet_find_response::greet_find_response(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, GREET_FIND_RESPONSE);
_id = m.meta.extra["search_id"].as_string();
_local.ip = m.meta.extra["loc_ip"].as_string();
_local.port = m.meta.extra["loc_port"].as_int();
_ext.ip = m.meta.extra["ext_ip"].as_string();
_ext.port = m.meta.extra["ext_port"].as_int();
_found = m.meta.extra["found"].as_int() == 1;
}
void backend_client::received_contact_joined(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, CONTACT_JOINED);
INVARIANT(_api);
m::expect_remote(m);
m::expect_symmetric(m);
contact_joined_msg j;
j.from_message(m);
_api->contact_joined(j.from_id);
}
//decimate sound to SAMPLE_RATE, using averaging
void decimate(const u::bytes& s, u::bytes& d, size_t channels, size_t skip)
{
REQUIRE_FALSE(s.empty());
REQUIRE_EQUAL(s.size() % 2, 0);
//get sizes
auto dz = (s.size() / skip);
auto nz = d.size() + dz;
//add padding
if(nz % 2 == 1) nz += 1;
CHECK_EQUAL(nz % 2, 0);
//resize dest
const auto odz = d.size();
d.resize(nz);
//cast to short arrays
auto ss = reinterpret_cast<const short*>(s.data());
const auto sz = s.size() / 2;
auto sd = reinterpret_cast<short*>(d.data());
const auto sdz = nz / 2;
int accum = 0;
size_t c = 1;
size_t si = 0;
auto di = odz / 2;
for(;si < sz; si+=channels)
{
accum += static_cast<int>(ss[si]);
if(c == skip)
{
accum /= c;
sd[di] = accum;
di++;
accum = 0;
c = 1;
continue;
}
c++;
}
//repeat last value if we have padding
si = sz-1;
while(di < sdz)
{
sd[di] = ss[si];
di++;
}
CHECK_EQUAL(di, sdz);
}
int TestGetBacktrace()
{
int size;
int sizeMinus1;
struct TBacktraceRecord* backtrace = GetBacktrace(&size, 0, 1);
REQUIRE_NOT_EQUAL(backtrace, 0);
REQUIRE_STRINGS_EQUAL(backtrace->Symbol_, "TestGetBacktrace");
REQUIRE_STRINGS_EQUAL(backtrace[1].Symbol_, "main");
free(backtrace);
backtrace = GetBacktrace(&sizeMinus1, 1, 10);
REQUIRE_NOT_EQUAL(backtrace, 0);
REQUIRE_EQUAL(size - 1, sizeMinus1);
REQUIRE_STRINGS_EQUAL(backtrace->Symbol_, "main");
free(backtrace);
backtrace = GetBacktrace(&size, 100, 10);
REQUIRE_EQUAL(backtrace, 0);
REQUIRE_EQUAL(errno, ERANGE);
backtrace = GetBacktrace(&size, 100, 0x7fffffff);
REQUIRE_EQUAL(backtrace, 0);
REQUIRE_EQUAL(errno, EDOM);
return 0;
}
void script_app::received_event_message(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, l::EVENT_MESSAGE);
INVARIANT(_conversation);
INVARIANT(_api);
auto id = m.meta.extra["from_id"].as_string();
if(!_conversation->user_service()->by_id(id))
return;
l::event_message em{m, _api.get()};
_api->event_received(em);
}
void from_message(const message& m)
{
REQUIRE_EQUAL(m.meta.type, type);
if(m.meta.extra.has("from_id"))
from_id = m.meta.extra["from_id"].as_string();
if(m.meta.extra.has("from_ip"))
from_ip = m.meta.extra["from_ip"].as_string();
if(m.meta.extra.has("from_port"))
from_port = m.meta.extra["from_port"];
CHECK(this);
C& self = reinterpret_cast<C&>(*this);
util::deserialize(m.data, self);
}
void script_app::received_script_message(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, l::SCRIPT_MESSAGE);
INVARIANT(_conversation);
INVARIANT(_api);
bool local = m.meta.extra.has("local_app_id");
auto id = m.meta.extra["from_id"].as_string();
if(!local && !_conversation->user_service()->by_id(id))
return;
l::script_message sm{m, _api.get()};
_api->message_received(sm);
}
void inflate(const u::bytes& s, u::bytes& d, size_t channels, size_t rep)
{
REQUIRE_EQUAL(s.size() % 2, 0);
rep*=channels;
d.resize(s.size() * rep);
auto ss = reinterpret_cast<const short*>(s.data());
auto sz = s.size() / 2;
auto sd = reinterpret_cast<short*>(d.data());
size_t di = 0;
for(size_t si = 0; si < sz; si++)
for(size_t p = 0; p < rep; p++, di++)
sd[di] = ss[si];
}
void conversation_service::received_quit(const message::message& m)
{
INVARIANT(_user_service);
REQUIRE_EQUAL(m.meta.type, QUIT_CONVERSATION);
m::expect_symmetric(m);
quit_conversation_msg q;
q.from_message(m);
auto c = _user_service->user().contacts().by_id(q.from_id);
if(!c) return;
auto s = conversation_by_id(q.conversation_id);
if(!s) return;
s->remove_contact(q.from_id);
fire_contact_removed(q.conversation_id, q.from_id);
}
void conversation_service::received_ask_contact_req(const message::message& m)
{
INVARIANT(_user_service);
REQUIRE_EQUAL(m.meta.type, ASK_CONTACT_REQ);
m::expect_symmetric(m);
ask_contact_req_msg a;
a.from_message(m);
bool hc = _user_service->user().contacts().has(a.from_id);
if(!hc) return;
auto s = conversation_by_id(a.conversation_id);
if(!s) return;
bool know = _user_service->user().contacts().has(a.id);
ask_contact_res_msg r;
r.conversation_id = a.conversation_id;
r.id = a.id;
r.status = know ? 1 : 0;
_sender->send(a.from_id, r.to_message());
}
abb::void_block operator()(int elem) {
++this->counter;
REQUIRE_EQUAL(this->counter, elem);
HIT();
return abb::success();
}
/**** Main ****/
int
main(int32_t argc, char *argv[])
{
nsresult rv;
ScopedXPCOM xpcom("UDP ServerSocket");
if (xpcom.failed())
return -1;
// Create UDPSocket
nsCOMPtr<nsIUDPSocket> server, client;
server = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
client = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
// Create UDPServerListener to process UDP packets
nsRefPtr<UDPServerListener> serverListener = new UDPServerListener();
// Bind server socket to 0.0.0.0
rv = server->Init(0, false);
NS_ENSURE_SUCCESS(rv, -1);
int32_t serverPort;
server->GetPort(&serverPort);
server->AsyncListen(serverListener);
// Bind clinet on arbitrary port
nsRefPtr<UDPClientListener> clientListener = new UDPClientListener();
client->Init(0, false);
client->AsyncListen(clientListener);
// Write data to server
uint32_t count;
const uint32_t data = REQUEST;
phase = TEST_OUTPUT_STREAM;
rv = client->Send(NS_LITERAL_CSTRING("127.0.0.1"), serverPort, (uint8_t*)&data, sizeof(uint32_t), &count);
NS_ENSURE_SUCCESS(rv, -1);
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Request written by Send");
// Wait for server
PumpEvents();
NS_ENSURE_SUCCESS(serverListener->mResult, -1);
// Read response from server
NS_ENSURE_SUCCESS(clientListener->mResult, -1);
mozilla::net::NetAddr clientAddr;
rv = client->GetAddress(&clientAddr);
NS_ENSURE_SUCCESS(rv, -1);
// The client address is 0.0.0.0, but Windows won't receive packets there, so
// use 127.0.0.1 explicitly
clientAddr.inet.ip = PR_htonl(127 << 24 | 1);
phase = TEST_SEND_API;
rv = server->SendWithAddress(&clientAddr, (uint8_t*)&data, sizeof(uint32_t), &count);
NS_ENSURE_SUCCESS(rv, -1);
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Request written by SendWithAddress");
// Wait for server
PumpEvents();
NS_ENSURE_SUCCESS(serverListener->mResult, -1);
// Read response from server
NS_ENSURE_SUCCESS(clientListener->mResult, -1);
// Setup timer to detect multicast failure
nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1");
if (NS_WARN_IF(!timer)) {
return -1;
}
nsRefPtr<MulticastTimerCallback> timerCb = new MulticastTimerCallback();
// The following multicast tests using multiple sockets require a firewall
// exception on Windows XP before they pass. For now, we'll skip them here.
// Later versions of Windows don't seem to have this issue.
#ifdef XP_WIN
OSVERSIONINFO OsVersion;
OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
#pragma warning(push)
#pragma warning(disable:4996) // 'GetVersionExA': was declared deprecated
GetVersionEx(&OsVersion);
#pragma warning(pop)
if (OsVersion.dwMajorVersion == 5 && OsVersion.dwMinorVersion == 1) {
goto close;
}
#endif
// Join multicast group
printf("Joining multicast group\n");
phase = TEST_MULTICAST;
mozilla::net::NetAddr multicastAddr;
multicastAddr.inet.family = AF_INET;
multicastAddr.inet.ip = PR_htonl(224 << 24 | 255);
multicastAddr.inet.port = PR_htons(serverPort);
rv = server->JoinMulticastAddr(multicastAddr, nullptr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return -1;
}
// Send multicast ping
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, (uint8_t*)&data, sizeof(uint32_t), &count);
if (NS_WARN_IF(NS_FAILED(rv))) {
return -1;
}
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Multicast ping written by SendWithAddress");
// Wait for server to receive successfully
PumpEvents();
if (NS_WARN_IF(NS_FAILED(serverListener->mResult))) {
return -1;
}
if (NS_WARN_IF(NS_FAILED(timerCb->mResult))) {
return -1;
}
timer->Cancel();
passed("Server received ping successfully");
// Disable multicast loopback
printf("Disable multicast loopback\n");
client->SetMulticastLoopback(false);
server->SetMulticastLoopback(false);
// Send multicast ping
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, (uint8_t*)&data, sizeof(uint32_t), &count);
if (NS_WARN_IF(NS_FAILED(rv))) {
return -1;
}
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Multicast ping written by SendWithAddress");
// Wait for server to fail to receive
PumpEvents();
if (NS_WARN_IF(NS_SUCCEEDED(timerCb->mResult))) {
return -1;
}
timer->Cancel();
passed("Server failed to receive ping correctly");
// Reset state
client->SetMulticastLoopback(true);
server->SetMulticastLoopback(true);
// Change multicast interface
printf("Changing multicast interface\n");
mozilla::net::NetAddr loopbackAddr;
loopbackAddr.inet.family = AF_INET;
loopbackAddr.inet.ip = PR_htonl(INADDR_LOOPBACK);
client->SetMulticastInterfaceAddr(loopbackAddr);
// Send multicast ping
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, (uint8_t*)&data, sizeof(uint32_t), &count);
if (NS_WARN_IF(NS_FAILED(rv))) {
return -1;
}
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Multicast ping written by SendWithAddress");
// Wait for server to fail to receive
PumpEvents();
if (NS_WARN_IF(NS_SUCCEEDED(timerCb->mResult))) {
return -1;
}
timer->Cancel();
passed("Server failed to receive ping correctly");
// Reset state
mozilla::net::NetAddr anyAddr;
anyAddr.inet.family = AF_INET;
anyAddr.inet.ip = PR_htonl(INADDR_ANY);
client->SetMulticastInterfaceAddr(anyAddr);
// Leave multicast group
printf("Leave multicast group\n");
rv = server->LeaveMulticastAddr(multicastAddr, nullptr);
if (NS_WARN_IF(NS_FAILED(rv))) {
return -1;
}
// Send multicast ping
timerCb->mResult = NS_OK;
timer->InitWithCallback(timerCb, MULTICAST_TIMEOUT, nsITimer::TYPE_ONE_SHOT);
rv = client->SendWithAddress(&multicastAddr, (uint8_t*)&data, sizeof(uint32_t), &count);
if (NS_WARN_IF(NS_FAILED(rv))) {
return -1;
}
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Multicast ping written by SendWithAddress");
// Wait for server to fail to receive
PumpEvents();
if (NS_WARN_IF(NS_SUCCEEDED(timerCb->mResult))) {
return -1;
}
timer->Cancel();
passed("Server failed to receive ping correctly");
goto close;
close:
// Close server
printf("*** Attempting to close server ...\n");
server->Close();
client->Close();
PumpEvents();
passed("Server closed");
return 0; // failure is a non-zero return
}
/**** Main ****/
int
main(int32_t argc, char *argv[])
{
nsresult rv;
ScopedXPCOM xpcom("UDP ServerSocket");
if (xpcom.failed())
return -1;
// Create UDPServerSocket
nsCOMPtr<nsIUDPServerSocket> server;
server = do_GetService("@mozilla.org/network/server-socket-udp;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
// Create UDPListener to process UDP packets
nsCOMPtr<UDPListener> listener = new UDPListener();
// Init async server
server->Init(UDP_PORT, false);
server->AsyncListen(listener);
// Create UDP socket and streams
nsCOMPtr<nsISocketTransportService> sts =
do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
nsCOMPtr<nsISocketTransport> transport;
const char *protocol = "udp";
rv = sts->CreateTransport(&protocol, 1, NS_LITERAL_CSTRING("127.0.0.1"),
UDP_PORT, nullptr, getter_AddRefs(transport));
NS_ENSURE_SUCCESS(rv, -1);
nsCOMPtr<nsIOutputStream> outstream;
rv = transport->OpenOutputStream(nsITransport::OPEN_BLOCKING,
0, 0, getter_AddRefs(outstream));
NS_ENSURE_SUCCESS(rv, -1);
nsCOMPtr<nsIInputStream> instream;
rv = transport->OpenInputStream(nsITransport::OPEN_BLOCKING,
0, 0, getter_AddRefs(instream));
NS_ENSURE_SUCCESS(rv, -1);
// Write data to server
uint32_t count, read;
const uint32_t data = REQUEST;
printf("*** Attempting to write request 0x%x to server ...\n", REQUEST);
rv = outstream->Write((const char*)&data, sizeof(uint32_t), &count);
NS_ENSURE_SUCCESS(rv, -1);
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Request written");
// Wait for server
PumpEvents();
NS_ENSURE_SUCCESS(listener->mResult, -1);
// Read response from server
printf("*** Attempting to read response from server ...\n");
rv = instream->Read((char*)&read, sizeof(uint32_t), &count);
REQUIRE_EQUAL(count, sizeof(uint32_t), "Did not read enough bytes from input stream");
REQUIRE_EQUAL(read, RESPONSE, "Did not read expected data from stream. Received 0x%x", read);
passed("Response from server 0x%x", read);
// Close server
printf("*** Attempting to close server ...\n");
server->Close();
PumpEvents();
passed("Server closed");
return 0; // failure is a non-zero return
}
/**** Main ****/
int
main(int32_t argc, char *argv[])
{
nsresult rv;
ScopedXPCOM xpcom("UDP ServerSocket");
if (xpcom.failed())
return -1;
// Create UDPSocket
nsCOMPtr<nsIUDPSocket> server, client;
server = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
client = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
// Create UDPServerListener to process UDP packets
nsRefPtr<UDPServerListener> serverListener = new UDPServerListener();
// Bind server socket to 127.0.0.1
rv = server->Init(0, true);
NS_ENSURE_SUCCESS(rv, -1);
int32_t serverPort;
server->GetPort(&serverPort);
server->AsyncListen(serverListener);
// Bind clinet on arbitrary port
nsRefPtr<UDPClientListener> clientListener = new UDPClientListener();
client->Init(0, true);
client->AsyncListen(clientListener);
// Write data to server
uint32_t count;
const uint32_t data = REQUEST;
phase = TEST_OUTPUT_STREAM;
rv = client->Send(NS_LITERAL_CSTRING("127.0.0.1"), serverPort, (uint8_t*)&data, sizeof(uint32_t), &count);
NS_ENSURE_SUCCESS(rv, -1);
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Request written by Send");
// Wait for server
PumpEvents();
NS_ENSURE_SUCCESS(serverListener->mResult, -1);
// Read response from server
NS_ENSURE_SUCCESS(clientListener->mResult, -1);
mozilla::net::NetAddr clientAddr;
rv = client->GetAddress(&clientAddr);
NS_ENSURE_SUCCESS(rv, -1);
phase = TEST_SEND_API;
rv = server->SendWithAddress(&clientAddr, (uint8_t*)&data, sizeof(uint32_t), &count);
NS_ENSURE_SUCCESS(rv, -1);
REQUIRE_EQUAL(count, sizeof(uint32_t), "Error");
passed("Request written by SendWithAddress");
// Wait for server
PumpEvents();
NS_ENSURE_SUCCESS(serverListener->mResult, -1);
// Read response from server
NS_ENSURE_SUCCESS(clientListener->mResult, -1);
// Close server
printf("*** Attempting to close server ...\n");
server->Close();
client->Close();
PumpEvents();
passed("Server closed");
return 0; // failure is a non-zero return
}
greet_key_request::greet_key_request(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, GREET_KEY_REQUEST);
_response_service_address = m.meta.extra["response_address"].as_string();
}
pinhole::pinhole(const m::message& m)
{
REQUIRE_EQUAL(m.meta.type, PINHOLE);
}
