The AbstractTlsSocket class provides the base functionality for TLS encrypted socket. More...

#include <AsyncFw/AbstractTlsSocket>

Inheritance diagram for AsyncFw::AbstractTlsSocket:

Collaboration diagram for AsyncFw::AbstractTlsSocket:

Public Types
enum	IgnoreErrors : uint8_t { TimeValidity = 0x01 }

Public Types inherited from AsyncFw::AbstractSocket
enum	State : uint8_t { Unconnected , Listening , Connecting , Connected , Active , Closing , Destroy }

enum	Error : uint8_t { None , Closed , Refused , Read , Write , Activate }

Public Member Functions
void	setDescriptor (int) override

bool	connect (const std::string &, uint16_t) override

void	disconnect () override

void	close () override

void	setContext (const TlsContext &) const

Public Member Functions inherited from AsyncFw::AbstractSocket
virtual void	destroy ()

bool	listen (const std::string &, uint16_t)

DataArray &	peek ()

int	read (uint8_t *, int)

DataArray	read (int=0)

int	write (const uint8_t *, int)

int	write (const DataArray &)

Error	error () const

std::string	errorString () const

Thread *	thread () const

std::string	address () const

uint16_t	port () const

std::string	peerAddress () const

uint16_t	peerPort () const

Public Member Functions inherited from AsyncFw::AnyData
template<typename T>
T	data () const

	AnyData (const std::any &)

std::any &	data () const

void	setData (const std::any &data) const

Protected Member Functions
virtual void	activateReady ()

void	activateEvent () override

int	read_available_fd () const override final

int	read_fd (void *_p, int _s) override final

int	write_fd (const void *_p, int _s) override final

Protected Member Functions inherited from AsyncFw::AbstractSocket
	AbstractSocket (int, int, int)

int	pendingRead () const

int	pendingWrite () const

void	setError (Error)

void	setErrorString (const std::string &) const

virtual void	stateEvent ()

virtual void	readEvent ()

virtual void	writeEvent ()

virtual void	incomingEvent ()

Friends
LogStream &	operator<< (LogStream &log, const AbstractTlsSocket &s)

Additional Inherited Members
Protected Attributes inherited from AsyncFw::AbstractSocket
Thread *	thread_

int	fd_ = -1

State	state_ = State::Unconnected

Protected Attributes inherited from AsyncFw::AnyData
std::any	data_

Detailed Description

The AbstractTlsSocket class provides the base functionality for TLS encrypted socket.

Example:

#include <AsyncFw/Thread>
#include <AsyncFw/AbstractTlsSocket>
#include <AsyncFw/TlsContext>
#include <AsyncFw/LogStream>
#include <AsyncFw/AddressInfo>
#include <AsyncFw/MainThread>
 
class TcpSocket : public AsyncFw::AbstractTlsSocket {
public:
  void stateEvent() {
    logDebug() << "State event:" << static_cast<int>(state_);
    if (state_ == Active) {
      logDebug() << "Send request";
      write("GET /a-ucontrol/AsyncFw HTTP/1.1\r\nHost:github.com\r\nConnection:close\r\n\r\n");
    } else if (error() >= Closed) {
      if (error() != Closed) logError() << errorString();
      else {
        logNotice() << "Received:" << da;
        logDebug() << da.view(0, 512) << "...";
      }
      if (h) {
        h.promise().resume_queued();
        h = {};
        return;
      }
      AsyncFw::MainThread::exit(0);
    }
  }
  void readEvent() {
    AsyncFw::DataArray _da = read();
    logTrace() << "Read event:" << _da.size() << std::endl << _da.view(0, 256);
    da += _da;
  }
 
  AsyncFw::CoroutineAwait coConnect(const std::string &address, uint16_t port) {
    return AsyncFw::CoroutineAwait([this, address, port](AsyncFw::CoroutineHandle _h) {
      h = _h;
      connect(address, port);
    });
  }
 
private:
  AsyncFw::CoroutineHandle h;
  AsyncFw::DataArray da;
};
 
int main(int argc, char *argv[]) {
  AsyncFw::TlsContext context;
 
  if (!context.setDefaultVerifyPaths()) {
    logError("Can't set default verify paths");
    return -1;
  }
  context.setVerifyName("github.com");
  TcpSocket socket;
  socket.setContext(context);
 
  auto coroTask {[&socket]() -> AsyncFw::CoroutineTask {
    AsyncFw::AddressInfo addressInfo;
    AsyncFw::CoroutineHandle h = co_await addressInfo.coResolve("github.com");
    AsyncFw::AddressInfo::Result list = h.promise().data<AsyncFw::AddressInfo::Result>();
    if (list.empty()) {
      logError("Resolve error");
      AsyncFw::MainThread::exit(-1);
      co_return;
    }
    for (const std::string _s : list) logNotice() << _s;
    co_await socket.coConnect(list[0], 443);
    AsyncFw::MainThread::exit(0);
  }};
  coroTask();
 
  logNotice() << "Start Applicaiton";
 
  int ret = AsyncFw::MainThread::exec();
 
  logNotice() << "End Applicaiton" << ret;
  return ret;
}