Template class of IPv4 and IPv6 based client side TCP connection mode sockets. More...

#include <TCPClientSocket.hxx>

Inheritance diagram for cosmos::TCPClientSocketT< FAMILY >:

Public Types
using	IPAddress = typename FamilyTraits<FAMILY>::Address

using	Connection = TCPConnectionT<FAMILY>

Public Types inherited from cosmos::IPSocketT< FAMILY >
using	IPAddress = typename FamilyTraits<FAMILY>::Address

Public Types inherited from cosmos::Socket
enum class	Direction : int { READ = SHUT_RD , WRITE = SHUT_WR , READ_WRITE = SHUT_RDWR }
	Type used in Socket::shutdown(). More...

using	AddressFilledIn = NamedBool<struct addr_filled_in_t, false>
	Boolean flag used in receiveFrom() to signify if a peer address could be provided.

Public Types inherited from cosmos::StreamIO
enum class	SeekType : int { SET = SEEK_SET , CUR = SEEK_CUR , END = SEEK_END , DATA = SEEK_DATA , HOLE = SEEK_HOLE }
	Different methods for changing the file read/write position. More...

Public Member Functions
	TCPClientSocketT (const SocketFlags flags=SocketFlags{SocketFlag::CLOEXEC})

auto	tcpOptions ()

auto	tcpOptions () const

void	bind (const IPAddress &addr)
	Bind to the given IP address.

TCPConnectionT< FAMILY >	connect (const IPAddress &addr)
	Connect to the given IP address.

Public Member Functions inherited from cosmos::IPSocketT< FAMILY >
auto	ipOptions ()

auto	ipOptions () const

void	getSockName (IPAddress &addr)
	Returns the current address that the socket is bound to, if any.

Public Member Functions inherited from cosmos::Socket
auto	sockOptions ()

auto	sockOptions () const

void	getSockName (SocketAddress &addr)
	Returns the current address that the socket is bound to, if any.

void	shutdown (const Direction dir)
	Shutdown part or all of the connection on protocol level.

Public Member Functions inherited from cosmos::FDFile
	FDFile (const FileDescriptor fd, const AutoCloseFD auto_close)
	Wrap the given file descriptor applying the specified auto-close behaviour.

	FDFile (FDFile &&other) noexcept

FDFile &	operator= (FDFile &&other) noexcept

void	open (const FileDescriptor fd, const AutoCloseFD auto_close)
	Takes the already open file descriptor fd and operates on it.

void	close () override
	Close the current file object.

Public Member Functions inherited from cosmos::FileBase
	FileBase (const FileBase &)=delete

FileBase &	operator= (const FileBase &)=delete

bool	isOpen () const
	Returns whether currently a FileDescriptor is opened.

FileDescriptor	fd () const
	Allows access to the underlying fd with const semantics.

void	truncate (const off_t length)

Public Member Functions inherited from cosmos::StreamIO
	StreamIO (FileDescriptor &fd)

	StreamIO (const StreamIO &)=delete

StreamIO &	operator= (const StreamIO &)=delete

StreamIO &	operator= (StreamIO &&) noexcept

size_t	read (void *buf, size_t length)
	Read up to `length` bytes from the file into `buf`.

size_t	write (const void *buf, size_t length)
	Write up to `length` bytes from `buf` into the underlying file.

size_t	write (const std::string_view data)
	string_view wrapper around write(const void*, size_t).

void	readAll (void *buf, size_t length)
	Read all `length` bytes from the underlying file.

void	readAll (std::string &s, size_t length)
	Like readAll(void*, size_t) using an STL string.

void	writeAll (const void *buf, size_t length)
	Write all `length` bytes into the underlying file.

void	writeAll (const std::string_view data)
	string_view wrapper around writeAll(const void*, size_t).

bool	read (ReadIOVector &iovec)
	Read data from file into a vector of data regions.

bool	write (WriteIOVector &iovec)
	Write data to file from a vector of data regions.

void	readAll (ReadIOVector &iovec)
	Read into all data regions specified in `iovec`.

void	writeAll (WriteIOVector &iovec)
	Write all data regions specified in `iovec`.

off_t	seek (const SeekType type, off_t off)
	Seek to the given offset based on the given offset `type`.

off_t	seekFromStart (off_t off)
	Seek to the given offset relative to the start of the file.

off_t	seekFromCurrent (off_t off)
	Seek to the given offset relative to the current file position.

off_t	seekFromEnd (off_t off)
	Seek to the given offset relative to the end of the file.

Static Public Attributes
static constexpr auto	TYPE = SocketType::STREAM

Additional Inherited Members
Protected Member Functions inherited from cosmos::IPSocketT< FAMILY >
	IPSocketT (const SocketType type, const SocketFlags flags=SocketFlags{SocketFlag::CLOEXEC}, const SocketProtocol protocol=SocketProtocol::DEFAULT)

	IPSocketT (FileDescriptor fd, const AutoCloseFD auto_close)

Protected Member Functions inherited from cosmos::Socket
	Socket (const SocketFamily family, const SocketType type, const SocketFlags flags=SocketFlags{SocketFlag::CLOEXEC}, const SocketProtocol protocol=SocketProtocol::DEFAULT)
	Creates a new socket using the given properties.

	Socket (FileDescriptor fd, const AutoCloseFD auto_close)
	Creates a new socket from the given existing file descriptor.

void	bind (const SocketAddress &addr)
	Bind the socket to the given local address.

void	connect (const SocketAddress &addr)
	Establish a new connection using the given destination address.

void	listen (const size_t backlog)
	Enter into a passive listen state, allowing new connections.

FileDescriptor	accept (SocketAddress *addr)
	Accept a new connection on the socket.

size_t	send (const void *buf, size_t length, const MessageFlags flags=MessageFlags{})
	Send the given data over the socket, using specific send flags.

size_t	send (const std::string_view data, const MessageFlags flags=MessageFlags{})
	Variant of send() that takes a std::string_view container instead of a raw input buffer.

size_t	sendTo (const void *buf, size_t length, const SocketAddress &addr, const MessageFlags flags=MessageFlags{})
	Send a packet to a specific destination address.

size_t	sendTo (const std::string_view data, const SocketAddress &addr, const MessageFlags flags=MessageFlags{})
	Variant of sendTo() that takes a std::string_view container instead of a raw input buffer.

void	sendMessage (SendMessageHeader &header, const SocketAddress *addr=nullptr)
	Sends a message over the socket using extended SendMessageHeader data.

size_t	receive (void *buf, size_t length, const MessageFlags flags=MessageFlags{})
	Receive data from the socket, using specific receive flags.

std::pair< size_t, AddressFilledIn >	receiveFrom (void *buf, size_t length, SocketAddress &addr, const MessageFlags flags=MessageFlags{})
	Receive a packet, filling in the sender's address.

AddressFilledIn	receiveMessage (ReceiveMessageHeader &header, SocketAddress *addr=nullptr)
	Receives a message from the socket using extended ReceiveMessageHeader data.

Protected Member Functions inherited from cosmos::FileBase
	FileBase (const FileDescriptor fd=FileDescriptor{})

	FileBase (FileBase &&other) noexcept

FileBase &	operator= (FileBase &&other) noexcept

Protected Attributes inherited from cosmos::FDFile
AutoCloseFD	m_auto_close

Protected Attributes inherited from cosmos::FileBase
FileDescriptor	m_fd

Protected Attributes inherited from cosmos::StreamIO
FileDescriptor &	m_stream_fd

Detailed Description

template<SocketFamily FAMILY>
class cosmos::TCPClientSocketT< FAMILY >

Template class of IPv4 and IPv6 based client side TCP connection mode sockets.

Use cosmos::TCP4Socket for the IPv4 variant and cosmos::TCP6Socket for the IPv6 variant of this type. This type offers access to TCP socket specific socket options. Furthermore it makes accessible the connect() function for their respective IP address type.

The send and receive I/O functions are not available on this level. connect() will return a TCPConnectionT type that represents an existing connection and corresponding I/O methods.

For the server side listening socket look at the TCP4ListenSocket and TCP6ListenSocket classes.

Definition at line 26 of file TCPClientSocket.hxx.

Member Typedef Documentation

◆ Connection

template<SocketFamily FAMILY>

using cosmos::TCPClientSocketT< FAMILY >::Connection = TCPConnectionT<FAMILY>

Definition at line 31 of file TCPClientSocket.hxx.

◆ IPAddress

template<SocketFamily FAMILY>

using cosmos::TCPClientSocketT< FAMILY >::IPAddress = typename FamilyTraits<FAMILY>::Address

Definition at line 30 of file TCPClientSocket.hxx.

Constructor & Destructor Documentation

◆ TCPClientSocketT()

template<SocketFamily FAMILY>

cosmos::TCPClientSocketT< FAMILY >::TCPClientSocketT ( const SocketFlags flags = SocketFlags{SocketFlag::CLOEXEC} )

inlineexplicit

Definition at line 36 of file TCPClientSocket.hxx.

                                                                       {SocketFlag::CLOEXEC}) :
                        IPSocketT<FAMILY>{TYPE, flags} {
        }

Member Function Documentation

◆ bind()

template<SocketFamily FAMILY>

void cosmos::TCPClientSocketT< FAMILY >::bind ( const IPAddress & addr )

inline

Bind to the given IP address.

Explicitly bind to a local IP address. This is usually not necessary for client side TCP sockets. The operating system will automatically select a proper local address and port when connecting to a remote party. In some cases it can be helpful to have full control over the local address and port used, though.

See also: Socket::bind

Definition at line 58 of file TCPClientSocket.hxx.

                                         {
                return Socket::bind(addr);
        }

◆ connect()

template<SocketFamily FAMILY>

TCPConnectionT< FAMILY > cosmos::TCPClientSocketT< FAMILY >::connect ( const IPAddress & addr )

inline

Connect to the given IP address.

By connecting a TCP socket, a connection is established. After this is done send() and receive() can be used to exchange data on the connection.

Normally if the call returns successfully then the connection has been fully established. Special rules apply if the socket is in non-blocking mode, though. The same is true if certain socket options like TCPOptions::setFastOpenConnect() are enabled.

After a successful return the ownership of the socket file descriptor is transferred to the connection instance, and the original client socket will no longer be valid for use.

See also: Socket::connect

Definition at line 79 of file TCPClientSocket.hxx.

                                                              {
                Socket::connect(addr);
                auto ret = TCPConnectionT<FAMILY>{this->m_fd};
                this->m_fd.reset();
                return ret;
        }

◆ tcpOptions() [1/2]

template<SocketFamily FAMILY>

auto cosmos::TCPClientSocketT< FAMILY >::tcpOptions ( )

inline

Definition at line 40 of file TCPClientSocket.hxx.

                          {
                return TCPOptions{this->m_fd};
        }

◆ tcpOptions() [2/2]

template<SocketFamily FAMILY>

auto cosmos::TCPClientSocketT< FAMILY >::tcpOptions ( ) const

inline

Definition at line 44 of file TCPClientSocket.hxx.

                                {
                return TCPOptions{this->m_fd};
        }

Member Data Documentation

◆ TYPE

template<SocketFamily FAMILY>

auto cosmos::TCPClientSocketT< FAMILY >::TYPE = SocketType::STREAM

inlinestaticconstexpr

Definition at line 32 of file TCPClientSocket.hxx.

The documentation for this class was generated from the following file:

include/net/TCPClientSocket.hxx

Public Types

Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Connection

◆ IPAddress

Constructor & Destructor Documentation

◆ TCPClientSocketT()

Member Function Documentation

◆ bind()

◆ connect()

◆ tcpOptions() [1/2]

◆ tcpOptions() [2/2]

Member Data Documentation

◆ TYPE