Send and receive in different sockets in UDP - c++

Question

Later in my application I will have three threads: one thread that listen data on a port, one thread that send the data to an address on the same port. The last one is not important here.
For the moment, I don't use threads, I just want to do some tests.
My problem is the following :
If I just use the server to send and receive data, there is no problem. But when it is the client that send the data, it's like the distant peer did not receive anything.
My code for server :
#include "server.h"
using namespace boost::asio::ip;
using Peer = udp::endpoint;
Server::Server(boost::asio::io_service& io_service, Peer peer, Agent& agent) :
socket_(io_service, Peer(boost::asio::ip::udp::v6(), peer.port())),
recv_buffer_(), send_buffer_(), root_(peer), agent_(agent)
{
/* //when this is uncomment, that works fine
BOOST_LOG_TRIVIAL(info) << "Server Initialisation:";
std::shared_ptr<PeersReq> peersreq(new PeersReq());
std::vector<std::shared_ptr<Tlv>> tlv_vector;
tlv_vector.push_back(peersreq);
Packet packet(tlv_vector);
write_log(packet, peer);
boost::asio::streambuf request;
std::ostream os(&request);
packet.format(os);
std::cout << peer.address() << std::endl;
int n = static_cast<int>(socket_.send_to(request.data(),peer));
BOOST_LOG_TRIVIAL(debug) << "Bytes sent: " << n << std::endl;
*/
}
void Server::write_log(Packet packet, Peer peer) {
BOOST_LOG_TRIVIAL(info) << "Packet send to " << peer.address().to_string() << ":" << peer.port() << std::endl;
BOOST_LOG_TRIVIAL(info) << "Packet\n" << packet << std::endl;
}
void Server::receive() {
Peer peer;
BOOST_LOG_TRIVIAL(info) << "Now listening on port:" << root_.port() << std::endl;
socket_.receive_from(boost::asio::buffer(recv_buffer_), peer);
BOOST_LOG_TRIVIAL(info) << "Packet received" << std::endl;
std::cout << static_cast<int>(recv_buffer_[0]) << std::endl;
std::cout << static_cast<int>(recv_buffer_[1]) << std::endl;
if (recv_buffer_[0] != 57) //TO DO magic number
exit(EXIT_FAILURE); //Change this to send a bad
else if(recv_buffer_[1] != 0) //TO DO magic number
exit(EXIT_FAILURE);
uint16_t packet_length = static_cast<uint16_t>((recv_buffer_[2]<<8)+recv_buffer_[3]);
std::cout << packet_length << std::endl;
if (packet_length > 1024) //TODO magic number
exit(EXIT_FAILURE);
//maybe log ?
for(int i = 0 ; i < packet_length ; i++)
std::cout << i << ":" << (static_cast<int>(recv_buffer_[i+4]) & 0xFF) << std::endl;
Packet packet = Packet::from_string(recv_buffer_.data()+4, packet_length);
std::cout << "packet received" << std::endl;
std::cout << packet << std::endl;
//agent_.notify(packet, peer);
/*
boost::asio::streambuf request;
std::ostream os(&request);
packet_to_send.format(os);
//std::cout << request.size() << std::endl;
socket_.send_to(request.data(), peer);
*/
receive();
}
And the code for my client is the following :
Client::Client(boost::asio::io_service& io_service, Peer peer) : socket_(io_service, Peer(boost::asio::ip::udp::v6(), peer.port())) , peers_(), queue_peer_() {
//socket_.open(boost::asio::ip::udp::v6());
peers_.insert(peer);
queue_peer_.insert(std::make_pair(peer.address().to_string(),std::vector<std::shared_ptr<Tlv>>()));
std::shared_ptr<PeersReq> peersReq(new PeersReq());
add_tlv_to_queue(peersReq, peer);
send();
}
void Client::add_tlv_to_queue(std::shared_ptr<Tlv> tlv, Peer peer) {
if(queue_peer_.find(peer.address().to_string())!= queue_peer_.end()) {
peers_.insert(peer);
queue_peer_.insert(std::make_pair(peer.address().to_string(),std::vector<std::shared_ptr<Tlv>>()));
}
queue_peer_.find(peer.address().to_string())->second.push_back(tlv);
}
void Client::send() {
for ( std::unordered_map<std::string, std::vector<std::shared_ptr<Tlv>>>::iterator it = queue_peer_.begin(); it != queue_peer_.end(); ++it ) {
if(it->second.size()>0) {
boost::asio::streambuf request;
std::ostream os(&request);
Packet packet(it->second);
packet.format(os);
Peer peer = get_peer_from_string(it->first);
std::cout << peer.address() << std::endl;
int n = static_cast<int>(socket_.send_to(request.data(),peer));
}
}
}
Peer Client::get_peer_from_string(std::string string) {
Peer peer;
for(std::set<Peer>::const_iterator it =peers_.begin() ; it != peers_.end() ; it++) {
if(it->address().to_string() == string)
peer=*it;
}
//undefined behaviour if the peer is not registred. But it shouldn't happen
return peer;
}
In the main I use the following code :
Agent agent(storage, peer);
Server server(io_service_server, peer, agent);
Client client(io_service_client, peer);
server.receive();
I don't know if I did something bad or there is something special to get this behviour.
EDIT :
This is a snippet :
#include<array>
#include<boost/asio.hpp>
#include<iostream>
using Peer = boost::asio::ip::udp::endpoint;
using namespace boost::asio::ip;
class Server {
public:
Server(boost::asio::io_service& io_service, Peer peer);
void receive();
private:
boost::asio::ip::udp::socket socket_;
std::array<char, 1024> recv_buffer_;
};
Server::Server(boost::asio::io_service& io_service, Peer peer) :
socket_(io_service, Peer(boost::asio::ip::udp::v6(), peer.port())),
recv_buffer_()
{
boost::asio::streambuf request;
std::ostream os(&request);
os << "Server";
int n = static_cast<int>(socket_.send_to(request.data(),peer));
}
void Server::receive() {
Peer peer;
socket_.receive_from(boost::asio::buffer(recv_buffer_), peer);
std::cout << static_cast<int>(recv_buffer_[0]) << std::endl;
receive();
}
class Client {
public:
Client(boost::asio::io_service& io_service, Peer peer);
void send(Peer peer);
private:
boost::asio::ip::udp::socket socket_;
};
Client::Client(boost::asio::io_service& io_service, Peer peer) : socket_(io_service) {
socket_.open(boost::asio::ip::udp::v6());
send(peer);
}
void Client::send(Peer peer) {
boost::asio::streambuf request;
std::ostream os(&request);
os << "Client";
int n = static_cast<int>(socket_.send_to(request.data(),peer));
}
int main(int argc, char* argv[]) {
boost::asio::io_service io_service_client;
boost::asio::io_service io_service_server;
Peer peer;
peer.address(); //Add an address here
peer.port(12345);
Client client(io_service_client, peer);
Server server(io_service_server, peer);
return 0;
}