C++ TCP Proxy ASIO missing packets - c++

Question

I am building a small application for my company. I will spare you on the details why, but I was requested to build a TCP Proxy for a specific application and protocol that we have.
For this Proxy, it would make a TCP connection to a server that would send us data periodically, and the Proxy would mirror the data received to two other applications on different ports. For this, I used C++ and ASIO library. I will spare you the full code, but here is (what I think) the important part regarding TCP Connections:
The class belowhandles the incoming data received by our Proxy. Data received here should be sent to our clients.
#include "TCPInConnection.h"
namespace Proxy
{
TCPInConnection::TCPInConnection(asio::io_context& io_context, std::string host, int port) :
host(host),
port(port),
io_context(&io_context),
socket(io_context)
{
}
TCPInConnection::~TCPInConnection()
{
Close();
}
//Starts connection to the server
void TCPInConnection::Start()
{
if(!socket.is_open())
connect();
}
void TCPInConnection::Close()
{
if (socket.is_open())
socket.close();
}
//Receives a callback. The callback passed should be called everytime a new packet was received
void TCPInConnection::OnReceive(std::function<std::vector<uint8_t>(std::vector<uint8_t>&)> callback)
{
this->callback = callback;
}
//Handles the connection. If an error occured while connecting, try connection again. When connecting, call receive handler to read data received
void TCPInConnection::connect()
{
socket.async_connect(asio::ip::tcp::endpoint(asio::ip::address::from_string(host), port), [this](const asio::error_code& error) {
if (error)
{
this->connect();
return;
}
asio::socket_base::receive_buffer_size option(8192 * 40);
socket.set_option(option);
receive();
});
}
//Handles the reception of data. For evey incoming packet, it should call itself to receive the next packet. If socket is closed, try to reconnect.
void TCPInConnection::receive()
{
std::array<char, 4000>* receiveBuffer = new std::array<char, 4000>();
socket.async_receive(asio::buffer(*receiveBuffer), 0, [this, receiveBuffer](const asio::error_code& error, std::size_t len) {
if (error == asio::error::eof || error == asio::error::connection_reset)
{
if (this->socket.is_open())
this->socket.close();
connect();
delete receiveBuffer;
return;
}
receive();
if (len == 0)
{
delete receiveBuffer;
return;
}
std::vector<uint8_t> packet(receiveBuffer->begin(), receiveBuffer->begin() + len);
auto data = callback(packet);
delete receiveBuffer;
if (data.size() == 0)
return;
std::vector<uint8_t>* output = new std::vector<uint8_t>(data.begin(), data.end());
socket.async_write_some(asio::buffer(*output), [output](const asio::error_code& error, std::size_t bytes_transferred) {
delete output;
});
});
}
}
The next class handles the output to our clients:
#include "TCPOutConnection.h"
namespace Proxy
{
TCPOutConnection::TCPOutConnection(asio::io_context& io_context, int port) :
io_context(&io_context),
acceptor(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)),
clientsMutex(),
clients()
{
}
TCPOutConnection::~TCPOutConnection()
{
Close();
}
//Starts listening for clients
void TCPOutConnection::Start()
{
connect();
}
void TCPOutConnection::Close()
{
std::lock_guard<std::mutex> guard(closingMutex);
if (acceptor.is_open())
acceptor.close();
{
std::lock_guard<std::mutex> guard(clientsMutex);
for (auto c = clients.begin(); c != clients.end(); ++c)
{
asio::ip::tcp::socket* socket = *c;
socket->close();
delete socket;
}
clients.clear();
}
}
//Sends data to each of the clients.
void TCPOutConnection::Send(std::vector<uint8_t> data)
{
if (data.size() == 0)
return;
std::lock_guard<std::mutex> guard(clientsMutex);
for (auto& socket : clients)
{
std::vector<uint8_t>* dataToSend = new std::vector<uint8_t>(data.begin(), data.end());
socket->async_send(asio::buffer(*dataToSend), [socket, this, dataToSend](const asio::error_code& error, std::size_t bytes_transferred) {
delete dataToSend;
if (!error)
return;
std::lock_guard<std::mutex> guard(clientsMutex);
clients.remove(socket);
});
}
}~
//Still not used. Would be implemented later.
void TCPOutConnection::OnDataReceived(std::function<void(std::vector<uint8_t>)> callback)
{
}
//Handles connection of new clients. Everytime a client comes, it should listen for another one
void TCPOutConnection::connect()
{
asio::ip::tcp::socket* socket = new asio::ip::tcp::socket(*io_context);
acceptor.async_accept(*socket, [socket, this](const asio::error_code& error) {
connect();
if (error)
{
delete socket;
return;
}
asio::ip::tcp::no_delay option1;
socket->set_option(option1);
asio::socket_base::receive_buffer_size option2(8192 * 40);
socket->set_option(option2);
std::lock_guard<std::mutex> guard(clientsMutex);
clients.push_back(socket);
});
}
}
Although the above works fine, I am losing some packets when our server is sending too much packets to the proxy (~15 packets per millisecond).
Is there anything I could do to avoid losing packets?