cosmos::UnixDatagramSocket Class Reference

Implementation of a UNIX domain datagram socket. More...

#include <UnixDatagramSocket.hxx>

Inheritance diagram for cosmos::UnixDatagramSocket:

Public Member Functions
	UnixDatagramSocket (const SocketFlags flags=SocketFlags{SocketFlag::CLOEXEC})
	UnixDatagramSocket (const FileDescriptor fd, const AutoCloseFD auto_close=AutoCloseFD{true})
auto	unixOptions ()
auto	unixOptions () const
void	bind (const UnixAddress &addr)
	Bind to the given UNIX address.
void	connect (const UnixAddress &addr)
	Connect to the given UNIX address.
std::pair< size_t, std::optional< UnixAddress > >	receiveFrom (void *buf, size_t length, const MessageFlags flags=MessageFlags{})
auto	sendTo (const void *buf, size_t length, const UnixAddress &addr, const MessageFlags flags=MessageFlags{})
auto	sendTo (const std::string_view data, const UnixAddress &addr, const MessageFlags flags=MessageFlags{})
void	sendMessage (SendMessageHeader &header)
void	sendMessageTo (SendMessageHeader &header, const UnixAddress &addr)
void	receiveMessage (ReceiveMessageHeader &header)
std::optional< UnixAddress >	receiveMessageFrom (ReceiveMessageHeader &header)
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	receive (void *buf, size_t length, const MessageFlags flags=MessageFlags{})
	Receive data from the socket, using specific receive flags.
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::DGRAM

Additional Inherited Members
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...
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

Implementation of a UNIX domain datagram socket.

A UNIX domain socket of type SocketType::DGRAM. It has similar properties to a UDP socket but is reliable and doesn't reorder.

Definition at line 18 of file UnixDatagramSocket.hxx.

Constructor & Destructor Documentation

UnixDatagramSocket() [1/2]

cosmos::UnixDatagramSocket::UnixDatagramSocket ( const SocketFlags flags = SocketFlags{SocketFlag::CLOEXEC} )

inlineexplicit

Definition at line 26 of file UnixDatagramSocket.hxx.

                                                                         {SocketFlag::CLOEXEC}) :
                        Socket{SocketFamily::UNIX, TYPE, flags} {
        }

UnixDatagramSocket() [2/2]

cosmos::UnixDatagramSocket::UnixDatagramSocket ( const FileDescriptor fd, const AutoCloseFD auto_close = AutoCloseFD{true} )

inlineexplicit

Definition at line 30 of file UnixDatagramSocket.hxx.

                                                                                                       {true}) :
                        Socket{fd, auto_close} {}

Member Function Documentation

bind()

void cosmos::UnixDatagramSocket::bind ( const UnixAddress & addr )

inline

Bind to the given UNIX address.

To receive packets, the UNIX socket can be bound to a local path or abstract name. If the socket is used without binding, or when binding to an empty path then the kernel will autobind to a random abstract name consisting of 5 bytes in the character set [0-9a-f].

See also

Socket::bind

Definition at line 50 of file UnixDatagramSocket.hxx.

                                           {
                return Socket::bind(addr);
        }

connect()

void cosmos::UnixDatagramSocket::connect ( const UnixAddress & addr )

inline

Connect to the given UNIX address.

By connecting a datagram socket a default destination is configured. After this is done a regular write() or send() can be used to send to this default destination.

The sendTo() method can still be used to send to a specific address.

See also

Socket::connect

Definition at line 65 of file UnixDatagramSocket.hxx.

                                              {
                return Socket::connect(addr);
        }

receive()

size_t cosmos::Socket::receive	(	void *	buf,
		size_t	length,
		const MessageFlags	flags = MessageFlags{} )

Receive data from the socket, using specific receive flags.

This is like a regular read() call but allows to specify socket specific MessageFlags to adjust various behaviour.

Definition at line 204 of file Socket.cxx.

                                                                         {
        const auto res = ::recv(to_integral(m_fd.raw()), buf, length, flags.raw());
        if (res < 0) {
                cosmos_throw(ApiError("recv()"));
        }
 
        return static_cast<size_t>(res);
}

receiveFrom()

std::pair< size_t, std::optional< UnixAddress > > cosmos::UnixDatagramSocket::receiveFrom ( void * buf, size_t length, const MessageFlags flags = MessageFlags{} )

inline

Definition at line 69 of file UnixDatagramSocket.hxx.

                                                                                         {}) {
                UnixAddress addr;
                auto [len, filled] = Socket::receiveFrom(buf, length, addr, flags);
 
                return {len, filled ? std::optional<UnixAddress>{addr} : std::nullopt};
        }

receiveMessage()

void cosmos::UnixDatagramSocket::receiveMessage ( ReceiveMessageHeader & header )

inline

Definition at line 96 of file UnixDatagramSocket.hxx.

                                                          {
                (void)Socket::receiveMessage(header);
        }

receiveMessageFrom()

std::optional< UnixAddress > cosmos::UnixDatagramSocket::receiveMessageFrom ( ReceiveMessageHeader & header )

inline

Definition at line 100 of file UnixDatagramSocket.hxx.

                                                                                  {
                UnixAddress addr;
                auto filled = Socket::receiveMessage(header, &addr);
 
                return filled ? std::optional<UnixAddress>{addr} : std::nullopt;
        }

send() [1/2]

size_t cosmos::Socket::send ( const std::string_view data, const MessageFlags flags = MessageFlags{} )

inline

Variant of send() that takes a std::string_view container instead of a raw input buffer.

Definition at line 153 of file Socket.hxx.

                                                                                      {}) {
                return send(data.data(), data.size(), flags);
        }

send() [2/2]

size_t cosmos::Socket::send	(	const void *	buf,
		size_t	length,
		const MessageFlags	flags = MessageFlags{} )

Send the given data over the socket, using specific send flags.

This is like a regular write() call but allows to specify socket specific MessageFlags to adjust various behaviour.

Definition at line 150 of file Socket.cxx.

                                                                            {
        const auto res = ::send(to_integral(m_fd.raw()), buf, length, flags.raw());
        if (res < 0) {
                cosmos_throw(ApiError("send()"));
        }
 
        return static_cast<size_t>(res);
}

sendMessage()

void cosmos::UnixDatagramSocket::sendMessage ( SendMessageHeader & header )

inline

Definition at line 88 of file UnixDatagramSocket.hxx.

                                                    {
                return Socket::sendMessage(header);
        }

sendMessageTo()

void cosmos::UnixDatagramSocket::sendMessageTo ( SendMessageHeader & header, const UnixAddress & addr )

inline

Definition at line 92 of file UnixDatagramSocket.hxx.

                                                                               {
                return Socket::sendMessage(header, &addr);
        }

sendTo() [1/2]

auto cosmos::UnixDatagramSocket::sendTo ( const std::string_view data, const UnixAddress & addr, const MessageFlags flags = MessageFlags{} )

inline

Definition at line 81 of file UnixDatagramSocket.hxx.

                                                                                                               {}) {
                return sendTo(data.data(), data.size(), addr, flags);
        }

sendTo() [2/2]

auto cosmos::UnixDatagramSocket::sendTo ( const void * buf, size_t length, const UnixAddress & addr, const MessageFlags flags = MessageFlags{} )

inline

Definition at line 77 of file UnixDatagramSocket.hxx.

                                                                                                                    {}) {
                return Socket::sendTo(buf, length, addr, flags);
        }

unixOptions() [1/2]

auto cosmos::UnixDatagramSocket::unixOptions ( )

inline

Definition at line 33 of file UnixDatagramSocket.hxx.

                           {
                return UnixOptions{this->m_fd};
        }

unixOptions() [2/2]

auto cosmos::UnixDatagramSocket::unixOptions ( ) const

inline

Definition at line 37 of file UnixDatagramSocket.hxx.

                                 {
                return UnixOptions{this->m_fd};
        }

Member Data Documentation

TYPE

auto cosmos::UnixDatagramSocket::TYPE = SocketType::DGRAM

inlinestaticconstexpr

Definition at line 22 of file UnixDatagramSocket.hxx.

---

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

• include/net/UnixDatagramSocket.hxx