A TCP connection with framed instead of streamed content. More...

#include <AsyncFramedTcpConnection.h>

Inheritance diagram for Async::FramedTcpConnection:

Public Member Functions
	FramedTcpConnection (size_t recv_buf_len=DEFAULT_RECV_BUF_LEN)
	Constructor.

	FramedTcpConnection (int sock, const IpAddress &remote_addr, uint16_t remote_port, size_t recv_buf_len=DEFAULT_RECV_BUF_LEN)
	Constructor.

virtual	~FramedTcpConnection (void)
	Destructor.

virtual TcpConnection &	operator= (TcpConnection &&other_base) override
	Move assignmnt operator.

void	setMaxRxFrameSize (uint32_t frame_size)
	Set the maximum RX frame size.

void	setMaxTxFrameSize (uint32_t frame_size)
	Set the maximum TX frame size.

void	setMaxFrameSize (uint32_t frame_size)
	Set the maximum frame size.

virtual int	write (const void *buf, int count) override
	Send a frame on the TCP connection.

Public Member Functions inherited from Async::TcpConnection
	TcpConnection (size_t recv_buf_len=DEFAULT_RECV_BUF_LEN)
	Constructor.

	TcpConnection (int sock, const IpAddress &remote_addr, uint16_t remote_port, size_t recv_buf_len=DEFAULT_RECV_BUF_LEN)
	Constructor.

virtual	~TcpConnection (void)
	Destructor.

void	setRecvBufLen (size_t recv_buf_len)
	Set a new receive buffer size.

size_t	recvBufLen (void) const

virtual void	disconnect (void)
	Disconnect from the remote host.

IpAddress	localHost (void) const
	Get the local IP address associated with this connection.

uint16_t	localPort (void) const
	Get the local TCP port associated with this connection.

const IpAddress &	remoteHost (void) const
	Return the IP-address of the remote host.

uint16_t	remotePort (void) const
	Return the remote port used.

bool	isConnected (void) const
	Check if the connection is established or not.

bool	isIdle (void) const
	Check if the connection is idle.

void	enableSsl (bool enable)
	Enable or disable TLS for this connection.

SslX509	sslPeerCertificate (void)
	Get the peer certificate associated with this connection.

Async::SslX509	sslCertificate (void) const

long	sslVerifyResult (void) const
	Get the result of the certificate verification process.

void	setSslContext (SslContext &ctx, bool is_server)
	Set the OpenSSL context to use when setting up the connection.

SslContext *	sslContext (void)

bool	isServer (void) const

void	freeze (void)
	Stop all communication.

void	unfreeze (void)
	Reenable all communication.

Public Attributes
sigc::signal< void, FramedTcpConnection *, DisconnectReason >	disconnected
	A signal that is emitted when a connection has been terminated.

sigc::signal< void, FramedTcpConnection *, std::vector< uint8_t > & >	frameReceived
	A signal that is emitted when a frame has been received on the connection.

Public Attributes inherited from Async::TcpConnection
sigc::signal< void, TcpConnection *, DisconnectReason >	disconnected
	Get common name for the SSL connection.

sigc::signal< int, TcpConnection , void , int >	dataReceived
	A signal that is emitted when data has been received on the connection.

sigc::signal< if_all_true_acc::result_type, TcpConnection , int, X509_STORE_CTX >::accumulated< if_all_true_acc >	verifyPeer
	A signal that is emitted on SSL/TLS certificate verification.

sigc::signal< void, TcpConnection * >	sslConnectionReady
	A signal that is emitted when the SSL connection is ready.

Protected Member Functions
FramedTcpConnection &	operator= (const FramedTcpConnection &)=delete

virtual void	closeConnection (void) override
	Disconnect from the remote peer.

virtual void	onDisconnected (DisconnectReason reason) override
	Called when a connection has been terminated.

virtual int	onDataReceived (void *buf, int count) override
	Called when data has been received on the connection.

virtual void	emitDisconnected (DisconnectReason reason) override
	Emit the disconnected signal.

Protected Member Functions inherited from Async::TcpConnection
void	setSocket (int sock)
	Setup information about the connection.

void	setRemoteAddr (const IpAddress &remote_addr)
	Setup information about the connection.

void	setRemotePort (uint16_t remote_port)
	Setup information about the connection.

int	socket (void) const
	Return the socket file descriptor.

virtual int	emitVerifyPeer (int preverify_ok, X509_STORE_CTX *store_ctx)
	Emit the verifyPeer signal.

Protected Attributes
sigc::signal< int, TcpConnection , void , int >	dataReceived

sigc::signal< void, bool >	sendBufferFull

Additional Inherited Members
Public Types inherited from Async::TcpConnection
enum	DisconnectReason { DR_HOST_NOT_FOUND , DR_REMOTE_DISCONNECTED , DR_SYSTEM_ERROR , DR_ORDERED_DISCONNECT , DR_PROTOCOL_ERROR , DR_SWITCH_PEER , DR_BAD_STATE }
	Reason code for disconnects. More...

Static Public Member Functions inherited from Async::TcpConnection
static const char *	disconnectReasonStr (DisconnectReason reason)
	Translate disconnect reason to a string.

Static Public Attributes inherited from Async::TcpConnection
static const int	DEFAULT_RECV_BUF_LEN = 1024
	The default size of the reception buffer.

Detailed Description

A TCP connection with framed instead of streamed content.

Author: Tobias Blomberg / SM0SVX

Date: 2017-03-30

This class implements a framed TCP connection. It will make sure that the data given to one call to the write function will arrive at the other end in one piece or not at all. This makes it easier to implement message based protocols that only want to see completely transfered messages at the other end.

#include <iostream>
#include <AsyncCppApplication.h>
#include <AsyncTcpClient.h>
#include <AsyncFramedTcpConnection.h>
 
using namespace std;
using namespace Async;
 
class MyClass : public sigc::trackable
{
  public:
    MyClass(void)
    {
      con = new TcpClient<FramedTcpConnection>("localhost", 12345);
      con->connected.connect(mem_fun(*this, &MyClass::onConnected));
      con->disconnected.connect(mem_fun(*this, &MyClass::onDisconnected));
      con->frameReceived.connect(mem_fun(*this, &MyClass::onFrameReceived));
      con->connect();
    }
 
    ~MyClass(void)
    {
      delete con;
    }
 
  private:
    TcpClient<FramedTcpConnection> *con;
 
    void onConnected(void)
    {
      cout << "Connection established to " << con->remoteHost() << "...\n";
      size_t bufsize = 10000000;
      char *buf = new char[bufsize];
      for (size_t i=0; i<bufsize; ++i) { buf[i] = i & 0xff; }
      cout << "Sending 3x frames to the server..." << endl;
      con->write(buf, bufsize/4);
      con->write(buf, bufsize/2);
      con->write(buf, bufsize);
      cout << "Sending QUIT to server" << endl;
      con->write("QUIT", 4);
      delete [] buf;
    }
 
    void onDisconnected(FramedTcpConnection *con,
                        TcpClient<FramedTcpConnection>::DisconnectReason reason)
    {
      cout << "Disconnected from " << con->remoteHost() << "...\n";
      Application::app().quit();
    }
 
    void onFrameReceived(FramedTcpConnection *con, vector<uint8_t>& frame)
    {
      char *str = reinterpret_cast<char *>(frame.data());
      string html(str, str+frame.size());
      cout << html;
    }
};
 
int main(int argc, char **argv)
{
  CppApplication app;
  MyClass my_class;
  app.exec();
}

#include <iostream>
#include <cassert>
#include <AsyncCppApplication.h>
#include <AsyncTcpServer.h>
#include <AsyncFramedTcpConnection.h>
 
using namespace std;
using namespace Async;
 
class MyClass : public sigc::trackable
{
  public:
    MyClass(void)
    {
      server = new TcpServer<FramedTcpConnection>("12345");
      server->clientConnected.connect(
          mem_fun(*this, &MyClass::onClientConnected));
      server->clientDisconnected.connect(
          mem_fun(*this, &MyClass::onClientDisconnected));
      cout << "Start AsyncFramedTcpClient_demo in another window to transfer "
              "some frames to the server" << endl;
    }
 
    ~MyClass(void)
    {
      delete server;
    }
 
  private:
    TcpServer<FramedTcpConnection> *server;
 
    void onClientConnected(FramedTcpConnection *con)
    {
      cout << "Client " << con->remoteHost() << ":"
           << con->remotePort() << " connected, "
           << server->numberOfClients() << " clients connected\n";
      con->frameReceived.connect(mem_fun(*this, &MyClass::onFrameReceived));
    }
 
    void onClientDisconnected(FramedTcpConnection *con,
                              FramedTcpConnection::DisconnectReason reason)
    {
      cout << "Client " << con->remoteHost().toString() << ":"
           << con->remotePort() << " disconnected,"
           << server->numberOfClients() << " clients connected\n";
      /* Don't delete the con object, the TcpServer will do it */
    }
 
    void onFrameReceived(FramedTcpConnection *con, std::vector<uint8_t>& buf)
    {
      cout << "Received a frame with " << buf.size() << " bytes of data\n";
      if (buf.size() == 4)
      {
        std::string cmd(buf.begin(), buf.end());
        cout << "Quitting!\n";
        Application::app().quit();
      }
      else
      {
          // Check content. Should be a repeating 0-255 series.
        uint8_t next = 0;
        for (size_t i=0; i<buf.size(); ++i)
        {
          assert(buf[i] == next++);
        }
      }
    }
};
 
int main(int argc, char **argv)
{
  CppApplication app;
  MyClass my_class;
  app.exec();
}
 
 

Examples: AsyncFramedTcpClient_demo.cpp, and AsyncFramedTcpServer_demo.cpp.

Definition at line 131 of file AsyncFramedTcpConnection.h.

Constructor & Destructor Documentation

◆ FramedTcpConnection() [1/2]

Async::FramedTcpConnection::FramedTcpConnection ( size_t recv_buf_len = DEFAULT_RECV_BUF_LEN )

explicit

Constructor.

Parameters

recv_buf_len The length of the receiver buffer to use

◆ FramedTcpConnection() [2/2]

Async::FramedTcpConnection::FramedTcpConnection	(	int	sock,
		const IpAddress &	remote_addr,
		uint16_t	remote_port,
		size_t	recv_buf_len = DEFAULT_RECV_BUF_LEN )

Constructor.

Parameters

sock	The socket for the connection to handle
remote_addr	The remote IP-address of the connection
remote_port	The remote TCP-port of the connection
recv_buf_len	The length of the receiver buffer to use

◆ ~FramedTcpConnection()

virtual Async::FramedTcpConnection::~FramedTcpConnection ( void )

virtual

Destructor.

Member Function Documentation

◆ closeConnection()

virtual void Async::FramedTcpConnection::closeConnection ( void )

overrideprotectedvirtual

Disconnect from the remote peer.

This function is used internally to close the connection to the remote peer.

Reimplemented from Async::TcpConnection.

◆ emitDisconnected()

virtual void Async::FramedTcpConnection::emitDisconnected ( DisconnectReason reason )

inlineoverrideprotectedvirtual

Emit the disconnected signal.

Parameters

reason The reason for the disconnection

Reimplemented from Async::TcpConnection.

Definition at line 283 of file AsyncFramedTcpConnection.h.

References disconnected, and Async::TcpConnection::emitDisconnected().

◆ onDataReceived()

virtual int Async::FramedTcpConnection::onDataReceived	(	void *	buf,
		int	count )

overrideprotectedvirtual

Called when data has been received on the connection.

Parameters

buf	A buffer containg the read data
count	The number of bytes in the buffer

Returns: Return the number of processed bytes

This function is called when data has been received on this connection. The buffer will contain the bytes read from the operating system. The function will return the number of bytes that has been processed. The bytes not processed will be stored in the receive buffer for this class and presented again to the slot when more data arrives. The new data will be appended to the old data. The default action for this function is to emit the dataReceived signal.

Reimplemented from Async::TcpConnection.

◆ onDisconnected()

virtual void Async::FramedTcpConnection::onDisconnected ( DisconnectReason reason )

overrideprotectedvirtual

Called when a connection has been terminated.

Parameters

reason The reason for the disconnect

This function will be called when the connection has been terminated. The default action for this function is to emit the disconnected signal.

Reimplemented from Async::TcpConnection.

◆ operator=() [1/2]

FramedTcpConnection & Async::FramedTcpConnection::operator= ( const FramedTcpConnection & )

protecteddelete

◆ operator=() [2/2]

virtual TcpConnection & Async::FramedTcpConnection::operator= ( TcpConnection && other_base )

overridevirtual

Move assignmnt operator.

Parameters

other_base The object to move from

Returns: Returns this object

The move operator move the state of a specified TcpFramedConnection object into this object. After the move, the state of the other object will be the same as if it had just been default constructed.

Reimplemented from Async::TcpConnection.

◆ setMaxFrameSize()

void Async::FramedTcpConnection::setMaxFrameSize ( uint32_t frame_size )

inline

Set the maximum frame size.

Parameters

frame_size The maximum frame size in bytes

Use this function to set the maximum allowed frame size. If a frame size number larger than this is received a disconnection is immediately issued. The default maximum frame size is DEFAULT_MAX_FRAME_SIZE.

Definition at line 203 of file AsyncFramedTcpConnection.h.

References setMaxRxFrameSize(), and setMaxTxFrameSize().

◆ setMaxRxFrameSize()

void Async::FramedTcpConnection::setMaxRxFrameSize ( uint32_t frame_size )

inline

Set the maximum RX frame size.

Parameters

frame_size The maximum frame size in bytes

Use this function to set the maximum allowed received frame size. If a frame size number larger than this is received a disconnection is immediately issued. The default maximum frame size is DEFAULT_MAX_FRAME_SIZE.

Definition at line 176 of file AsyncFramedTcpConnection.h.

Referenced by setMaxFrameSize().

◆ setMaxTxFrameSize()

void Async::FramedTcpConnection::setMaxTxFrameSize ( uint32_t frame_size )

inline

Set the maximum TX frame size.

Parameters

frame_size The maximum frame size in bytes

Use this function to set the maximum allowed transmitted frame size. If a frame size larger than this is transmitted the write function will return an error. The default maximum frame size is DEFAULT_MAX_FRAME_SIZE.

Definition at line 190 of file AsyncFramedTcpConnection.h.

Referenced by setMaxFrameSize().

◆ write()

virtual int Async::FramedTcpConnection::write	(	const void *	buf,
		int	count )

overridevirtual

Send a frame on the TCP connection.

Parameters

buf	The buffer containing the frame to send
count	The number of bytes in the frame

Returns: Return bytes written or -1 on failure

This function will send a frame of data on the TCP connection. The frame will either be completely transmitted or discarded on error. There is no inbetween so this function will always return either the given count or -1 on error.

Reimplemented from Async::TcpConnection.