How to read Inexhaustible data from LAN port in C++ - c++

Question

This is my code for read a data from file:
void sendfile(string pathname)
{
ifstream ifs(pathname, std::ifstream::in);
if(ifs.fail())
{
throw "error opening";
}
const size_t BUFFER_SIZE = 1024;
char* buffer;
buffer = new char[BUFFER_SIZE];
// get file size
ifs.seekg(0, ios::end);
int file_size = ifs.tellg();
ifs.seekg(0, ios::beg);
cout <<"File size : "<<file_size<< "bytes"<<endl;
unsigned char *data = new unsigned char [file_size];
ifs.read((char*)data, file_size);
for(int i=0; i < file_size; i += 2)
{
if (data[i] == 0xAF
&& data[i+1] == 0xDB
&& data[i+2] == 0xAA
&& data[i+3] == 0x00)
{
if (data[i + BUFFER_SIZE - 4] == 0xFF
&& data[i + BUFFER_SIZE - 3] == 0xAA
&& data[i + BUFFER_SIZE - 2] == 0xDF
&& data[i + BUFFER_SIZE - 1] == 0x00)
{
cout << "Packet" << endl;
}
}
}
delete[] data;
ifs.close();
But now I try to read Inexhaustible data from file or serial port byte by byte and check them to HEADER and FOOTER then send data with TCP/IP port to server.
I have written the client and server part codes and now I am trying to get this part of the inexhaustible data byte by byte. I mean, I am still unaware of the next byte and I want to check the HEADER and FOOTER and then send the packet[1024 byte].
using boost::asio for this example.
State machine:
What should I do?
UPDATE
Client header file:
#include <iostream>
#include <fstream>
#include <bitset>
#include <boost/asio.hpp>
using namespace boost::asio;
using ip::tcp;
using std::string;
using std::cout;
using std::endl;
using byte = unsigned char;
class Client
{
public:
Client(io_context& io_context,
char host[10],
unsigned int port)
: socket_(io_context)
{
start(host, port);
}
~Client()
{
stop();
}
private:
enum { CLIENT_DATA_BUFFER_SIZE = 1024 };
char buffer[CLIENT_DATA_BUFFER_SIZE];
boost::asio::streambuf receive_buffer;
tcp::socket socket_;
void start(char[10], unsigned int);
void stop();
};
Server Header file:
TCPServer::TCPServer(io_context& io_service, char host[10], unsigned int port)
: io_context_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
{
cout << "Server is running ..." << endl;
cout << "Server: got connection from " << host << " port " << port << endl;
//Timer await
timer = new deadline_timer(io_service, boost::posix_time::milliseconds(3100));
timer->wait();
std::cout << "Blocking wait(): " << 3 << " second-wait\n";
start_accept();
}
//Creates a socket and initiates an asynchronous accept operation to wait for a new connection.
void TCPServer::start_accept()
{
// socket definition
connection = connectionHandler::create(io_context_);
// asynchronous accept operation and wait for a new connection.
acceptor_.async_accept
(
connection->socket(),
boost::bind(&TCPServer::handle_accept,
this,
connection,
boost::asio::placeholders::error)
);
}
//It services the client request, and then calls start_accept() to initiate the next accept operation.
void TCPServer::handle_accept(connectionHandler::pointer connection, const boost::system::error_code& err)
{
if (!err)
{
connection->start();
}
start_accept();
}
void TCPServer::stop()
{
connection->stop();
}