void TestConnection::testConnectSendReceive()
{
DSTACK("TestConnection::Run");
/*
Test some real connections
NOTE: This mostly tests the legacy interface.
*/
u32 proto_id = 0xad26846a;
Handler hand_server("server");
Handler hand_client("client");
Address address(0, 0, 0, 0, 30001);
Address bind_addr(0, 0, 0, 0, 30001);
/*
* Try to use the bind_address for servers with no localhost address
* For example: FreeBSD jails
*/
std::string bind_str = g_settings->get("bind_address");
try {
bind_addr.Resolve(bind_str.c_str());
if (!bind_addr.isIPv6()) {
address = bind_addr;
}
} catch (ResolveError &e) {
}
infostream << "** Creating server Connection" << std::endl;
con::Connection server(proto_id, 512, 5.0, false, &hand_server);
server.Serve(address);
infostream << "** Creating client Connection" << std::endl;
con::Connection client(proto_id, 512, 5.0, false, &hand_client);
UASSERT(hand_server.count == 0);
UASSERT(hand_client.count == 0);
sleep_ms(50);
Address server_address(127, 0, 0, 1, 30001);
if (address != Address(0, 0, 0, 0, 30001)) {
server_address = bind_addr;
}
infostream << "** running client.Connect()" << std::endl;
client.Connect(server_address);
sleep_ms(50);
// Client should not have added client yet
UASSERT(hand_client.count == 0);
try {
NetworkPacket pkt;
infostream << "** running client.Receive()" << std::endl;
client.Receive(&pkt);
infostream << "** Client received: peer_id=" << pkt.getPeerId()
<< ", size=" << pkt.getSize() << std::endl;
} catch (con::NoIncomingDataException &e) {
}
// Client should have added server now
UASSERT(hand_client.count == 1);
UASSERT(hand_client.last_id == 1);
// Server should not have added client yet
UASSERT(hand_server.count == 0);
sleep_ms(100);
try {
NetworkPacket pkt;
infostream << "** running server.Receive()" << std::endl;
server.Receive(&pkt);
infostream << "** Server received: peer_id=" << pkt.getPeerId()
<< ", size=" << pkt.getSize()
<< std::endl;
} catch (con::NoIncomingDataException &e) {
// No actual data received, but the client has
// probably been connected
}
// Client should be the same
UASSERT(hand_client.count == 1);
UASSERT(hand_client.last_id == 1);
// Server should have the client
UASSERT(hand_server.count == 1);
UASSERT(hand_server.last_id == 2);
//sleep_ms(50);
while (client.Connected() == false) {
try {
NetworkPacket pkt;
infostream << "** running client.Receive()" << std::endl;
client.Receive(&pkt);
infostream << "** Client received: peer_id=" << pkt.getPeerId()
<< ", size=" << pkt.getSize() << std::endl;
} catch (con::NoIncomingDataException &e) {
}
sleep_ms(50);
}
sleep_ms(50);
try {
NetworkPacket pkt;
infostream << "** running server.Receive()" << std::endl;
server.Receive(&pkt);
infostream << "** Server received: peer_id=" << pkt.getPeerId()
<< ", size=" << pkt.getSize()
<< std::endl;
} catch (con::NoIncomingDataException &e) {
}
/*
Simple send-receive test
*/
{
NetworkPacket pkt;
pkt.putRawPacket((u8*) "Hello World !", 14, 0);
Buffer<u8> sentdata = pkt.oldForgePacket();
infostream<<"** running client.Send()"<<std::endl;
client.Send(PEER_ID_SERVER, 0, &pkt, true);
sleep_ms(50);
NetworkPacket recvpacket;
infostream << "** running server.Receive()" << std::endl;
server.Receive(&recvpacket);
infostream << "** Server received: peer_id=" << pkt.getPeerId()
<< ", size=" << pkt.getSize()
<< ", data=" << (const char*)pkt.getU8Ptr(0)
<< std::endl;
Buffer<u8> recvdata = pkt.oldForgePacket();
UASSERT(memcmp(*sentdata, *recvdata, recvdata.getSize()) == 0);
}
u16 peer_id_client = 2;
/*
Send a large packet
*/
{
const int datasize = 30000;
NetworkPacket pkt(0, datasize);
for (u16 i=0; i<datasize; i++) {
pkt << (u8) i/4;
}
infostream << "Sending data (size=" << datasize << "):";
for (int i = 0; i < datasize && i < 20; i++) {
if (i % 2 == 0)
infostream << " ";
char buf[10];
snprintf(buf, 10, "%.2X",
((int)((const char *)pkt.getU8Ptr(0))[i]) & 0xff);
infostream<<buf;
}
if (datasize > 20)
infostream << "...";
infostream << std::endl;
Buffer<u8> sentdata = pkt.oldForgePacket();
server.Send(peer_id_client, 0, &pkt, true);
//sleep_ms(3000);
Buffer<u8> recvdata;
infostream << "** running client.Receive()" << std::endl;
u16 peer_id = 132;
u16 size = 0;
bool received = false;
u32 timems0 = porting::getTimeMs();
for (;;) {
if (porting::getTimeMs() - timems0 > 5000 || received)
break;
try {
NetworkPacket pkt;
client.Receive(&pkt);
size = pkt.getSize();
peer_id = pkt.getPeerId();
recvdata = pkt.oldForgePacket();
received = true;
} catch (con::NoIncomingDataException &e) {
}
sleep_ms(10);
}
UASSERT(received);
infostream << "** Client received: peer_id=" << peer_id
<< ", size=" << size << std::endl;
infostream << "Received data (size=" << size << "): ";
for (int i = 0; i < size && i < 20; i++) {
if (i % 2 == 0)
infostream << " ";
char buf[10];
snprintf(buf, 10, "%.2X", ((int)(recvdata[i])) & 0xff);
infostream << buf;
}
if (size > 20)
infostream << "...";
infostream << std::endl;
UASSERT(memcmp(*sentdata, *recvdata, recvdata.getSize()) == 0);
UASSERT(peer_id == PEER_ID_SERVER);
}
// Check peer handlers
UASSERT(hand_client.count == 1);
UASSERT(hand_client.last_id == 1);
UASSERT(hand_server.count == 1);
UASSERT(hand_server.last_id == 2);
}
void Run()
{
DSTACK("TestConnection::Run");
TestHelpers();
/*
Test some real connections
*/
u32 proto_id = 0xad26846a;
Handler hand_server("server");
Handler hand_client("client");
infostream<<"** Creating server Connection"<<std::endl;
con::Connection server(proto_id, 512, 5.0, &hand_server);
server.Serve(30001);
infostream<<"** Creating client Connection"<<std::endl;
con::Connection client(proto_id, 512, 5.0, &hand_client);
assert(hand_server.count == 0);
assert(hand_client.count == 0);
sleep_ms(50);
Address server_address(127,0,0,1, 30001);
infostream<<"** running client.Connect()"<<std::endl;
client.Connect(server_address);
sleep_ms(50);
// Client should have added server now
assert(hand_client.count == 1);
assert(hand_client.last_id == 1);
// But server should not have added client
assert(hand_server.count == 0);
try
{
u16 peer_id;
u8 data[100];
infostream<<"** running server.Receive()"<<std::endl;
u32 size = server.Receive(peer_id, data, 100);
infostream<<"** Server received: peer_id="<<peer_id
<<", size="<<size
<<std::endl;
}
catch(con::NoIncomingDataException &e)
{
// No actual data received, but the client has
// probably been connected
}
// Client should be the same
assert(hand_client.count == 1);
assert(hand_client.last_id == 1);
// Server should have the client
assert(hand_server.count == 1);
assert(hand_server.last_id == 2);
//sleep_ms(50);
while(client.Connected() == false)
{
try
{
u16 peer_id;
u8 data[100];
infostream<<"** running client.Receive()"<<std::endl;
u32 size = client.Receive(peer_id, data, 100);
infostream<<"** Client received: peer_id="<<peer_id
<<", size="<<size
<<std::endl;
}
catch(con::NoIncomingDataException &e)
{
}
sleep_ms(50);
}
sleep_ms(50);
try
{
u16 peer_id;
u8 data[100];
infostream<<"** running server.Receive()"<<std::endl;
u32 size = server.Receive(peer_id, data, 100);
infostream<<"** Server received: peer_id="<<peer_id
<<", size="<<size
<<std::endl;
}
catch(con::NoIncomingDataException &e)
{
}
{
/*u8 data[] = "Hello World!";
u32 datasize = sizeof(data);*/
SharedBuffer<u8> data = SharedBufferFromString("Hello World!");
infostream<<"** running client.Send()"<<std::endl;
client.Send(PEER_ID_SERVER, 0, data, true);
sleep_ms(50);
u16 peer_id;
u8 recvdata[100];
infostream<<"** running server.Receive()"<<std::endl;
u32 size = server.Receive(peer_id, recvdata, 100);
infostream<<"** Server received: peer_id="<<peer_id
<<", size="<<size
<<", data="<<*data
<<std::endl;
assert(memcmp(*data, recvdata, data.getSize()) == 0);
}
u16 peer_id_client = 2;
{
/*
Send consequent packets in different order
*/
//u8 data1[] = "hello1";
//u8 data2[] = "hello2";
SharedBuffer<u8> data1 = SharedBufferFromString("hello1");
SharedBuffer<u8> data2 = SharedBufferFromString("Hello2");
Address client_address =
server.GetPeer(peer_id_client)->address;
infostream<<"*** Sending packets in wrong order (2,1,2)"
<<std::endl;
u8 chn = 0;
con::Channel *ch = &server.GetPeer(peer_id_client)->channels[chn];
u16 sn = ch->next_outgoing_seqnum;
ch->next_outgoing_seqnum = sn+1;
server.Send(peer_id_client, chn, data2, true);
ch->next_outgoing_seqnum = sn;
server.Send(peer_id_client, chn, data1, true);
ch->next_outgoing_seqnum = sn+1;
server.Send(peer_id_client, chn, data2, true);
sleep_ms(50);
infostream<<"*** Receiving the packets"<<std::endl;
u16 peer_id;
u8 recvdata[20];
u32 size;
infostream<<"** running client.Receive()"<<std::endl;
peer_id = 132;
size = client.Receive(peer_id, recvdata, 20);
infostream<<"** Client received: peer_id="<<peer_id
<<", size="<<size
<<", data="<<recvdata
<<std::endl;
assert(size == data1.getSize());
assert(memcmp(*data1, recvdata, data1.getSize()) == 0);
assert(peer_id == PEER_ID_SERVER);
infostream<<"** running client.Receive()"<<std::endl;
peer_id = 132;
size = client.Receive(peer_id, recvdata, 20);
infostream<<"** Client received: peer_id="<<peer_id
<<", size="<<size
<<", data="<<recvdata
<<std::endl;
assert(size == data2.getSize());
assert(memcmp(*data2, recvdata, data2.getSize()) == 0);
assert(peer_id == PEER_ID_SERVER);
bool got_exception = false;
try
{
infostream<<"** running client.Receive()"<<std::endl;
peer_id = 132;
size = client.Receive(peer_id, recvdata, 20);
infostream<<"** Client received: peer_id="<<peer_id
<<", size="<<size
<<", data="<<recvdata
<<std::endl;
}
catch(con::NoIncomingDataException &e)
{
infostream<<"** No incoming data for client"<<std::endl;
got_exception = true;
}
assert(got_exception);
}
{
const int datasize = 30000;
SharedBuffer<u8> data1(datasize);
for(u16 i=0; i<datasize; i++){
data1[i] = i/4;
}
infostream<<"Sending data (size="<<datasize<<"):";
for(int i=0; i<datasize && i<20; i++){
if(i%2==0) DEBUGPRINT(" ");
DEBUGPRINT("%.2X", ((int)((const char*)*data1)[i])&0xff);
}
if(datasize>20)
infostream<<"...";
infostream<<std::endl;
server.Send(peer_id_client, 0, data1, true);
sleep_ms(50);
u8 recvdata[datasize + 1000];
infostream<<"** running client.Receive()"<<std::endl;
u16 peer_id = 132;
u16 size = client.Receive(peer_id, recvdata, datasize + 1000);
infostream<<"** Client received: peer_id="<<peer_id
<<", size="<<size
<<std::endl;
infostream<<"Received data (size="<<size<<"):";
for(int i=0; i<size && i<20; i++){
if(i%2==0) DEBUGPRINT(" ");
DEBUGPRINT("%.2X", ((int)((const char*)recvdata)[i])&0xff);
}
if(size>20)
infostream<<"...";
infostream<<std::endl;
assert(memcmp(*data1, recvdata, data1.getSize()) == 0);
assert(peer_id == PEER_ID_SERVER);
}
// Check peer handlers
assert(hand_client.count == 1);
assert(hand_client.last_id == 1);
assert(hand_server.count == 1);
assert(hand_server.last_id == 2);
//assert(0);
}
