os::posix::socket_implementable< T > Class Template Reference

#include <socket.h>

Inheritance diagram for os::posix::socket_implementable< T >:

Public Types
using	value_type = T
Types & Constants
enum class	type : type_t {   unknown = 0 ,   not_set = 1 << 0 ,   char_device = 1 << 1 ,   block_device = 1 << 2 ,   tty = 1 << 3 ,   file = 1 << 4 ,   socket = 1 << 5 }
using	type_t = unsigned int

Public Member Functions
Constructors & Destructor
	socket_implementable (class net_stack &ns)
virtual	~socket_implementable ()
Public Member Functions
value_type &	impl (void) const
Public Member Functions
virtual socket *	accept (sockaddr *address, socklen_t *address_len)
virtual int	bind (const sockaddr *address, socklen_t address_len)
virtual int	connect (const sockaddr *address, socklen_t address_len)
virtual int	getpeername (sockaddr *address, socklen_t *address_len)
virtual int	getsockname (sockaddr *address, socklen_t *address_len)
virtual int	getsockopt (int level, int option_name, void *option_value, socklen_t *option_len)
virtual int	listen (int backlog)
virtual ssize_t	recv (void *buffer, size_t length, int flags)
virtual ssize_t	recvfrom (void *buffer, size_t length, int flags, sockaddr *address, socklen_t *address_len)
virtual ssize_t	recvmsg (msghdr *message, int flags)
virtual ssize_t	send (const void *buffer, size_t length, int flags)
virtual ssize_t	sendmsg (const msghdr *message, int flags)
virtual ssize_t	sendto (const void *message, size_t length, int flags, const sockaddr *dest_addr, socklen_t dest_len)
virtual int	setsockopt (int level, int option_name, const void *option_value, socklen_t option_len)
virtual int	shutdown (int how)
virtual int	sockatmark (void)
class net_stack *	net_stack (void)
Public Member Functions
virtual int	close (void)
virtual ssize_t	read (void *buf, std::size_t nbyte)
virtual ssize_t	write (const void *buf, std::size_t nbyte)
virtual ssize_t	writev (const iovec *iov, int iovcnt)
int	fcntl (int cmd,...)
virtual int	vfcntl (int cmd, std::va_list args)
int	isatty (void)
virtual int	fstat (struct stat *buf)
virtual off_t	lseek (off_t offset, int whence)
type_t	get_type (void) const
file_descriptor_t	file_descriptor (void) const
bool	is_opened (void)

Protected Member Functions
Private Member Functions
void	file_descriptor (file_descriptor_t fildes)
void	clear_file_descriptor (void)
io *	alloc_file_descriptor (void)

Detailed Description

template<typename T>
class os::posix::socket_implementable< T >

Definition at line 337 of file posix-io/socket.h.

Member Typedef Documentation

type_t

using os::posix::io::type_t = unsigned int

inherited

Definition at line 125 of file io.h.

value_type

template<typename T >

using os::posix::socket_implementable< T >::value_type = T

Definition at line 342 of file posix-io/socket.h.

Member Enumeration Documentation

type

enum class os::posix::io::type : type_t

stronginherited

Enumerator
unknown
not_set
char_device
block_device
tty
file
socket

Definition at line 126 of file io.h.

      {
        unknown = 0,
        not_set = 1 << 0,
        char_device = 1 << 1,
        block_device = 1 << 2,
        tty = 1 << 3,
        file = 1 << 4,
        socket = 1 << 5
      };

Constructor & Destructor Documentation

socket_implementable()

template<typename T >

os::posix::socket_implementable< T >::socket_implementable

(

class net_stack &

ns

)

Definition at line 572 of file posix-io/socket.h.

        : socket{ impl_instance_, ns }
    {
#if defined(OS_TRACE_POSIX_IO_SOCKET)
      trace::printf ("socket_implementable::%s()=@%p\n", __func__, this);
#endif
    }

References os::trace::printf().

~socket_implementable()

template<typename T >

os::posix::socket_implementable< T >::~socket_implementable

virtual

Definition at line 581 of file posix-io/socket.h.

    {
#if defined(OS_TRACE_POSIX_IO_SOCKET)
      trace::printf ("socket_implementable::%s() @%p\n", __func__, this);
#endif
    }

References os::trace::printf().

Member Function Documentation

accept()

class socket * os::posix::socket::accept ( sockaddr *  address, socklen_t *  address_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 58 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      class socket* new_socket = impl ().do_accept (address, address_len);
      if (new_socket == nullptr)
        {
          return nullptr;
        }
      new_socket->alloc_file_descriptor ();
      return new_socket;
    }

References os::posix::io::alloc_file_descriptor(), os::posix::socket_impl::do_accept(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::accept().

alloc_file_descriptor()

io * os::posix::io::alloc_file_descriptor ( void  )

protectedinherited

Definition at line 189 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s() @%p\n", __func__, this);
#endif
 
      int fd = file_descriptors_manager::allocate (this);
      if (fd < 0)
        {
          // If allocation failed, close this object.
          impl ().do_close ();
          clear_file_descriptor ();
          return nullptr;
        }
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s() @%p fd=%d\n", __func__, this, fd);
#endif
 
      // Return a valid pointer to an object derived from `io`.
      return this;
    }

References os::posix::file_descriptors_manager::allocate(), os::posix::io::clear_file_descriptor(), os::posix::io_impl::do_close(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::socket::accept(), os::posix::socket(), os::posix::device::vopen(), and os::posix::file_system::vopen().

bind()

int os::posix::socket::bind ( const sockaddr *  address, socklen_t  address_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 73 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_bind (address, address_len);
    }

References os::posix::socket_impl::do_bind(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::bind().

clear_file_descriptor()

void os::posix::io::clear_file_descriptor ( void  )

inlineprotectedinherited

Definition at line 446 of file io.h.

    {
      file_descriptor_ = no_file_descriptor;
    }

References os::posix::no_file_descriptor.

Referenced by os::posix::io::alloc_file_descriptor().

close()

int os::posix::io::close ( void  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, os::posix::device, os::posix::file, os::posix::file_lockable< T, L >, and os::posix::socket_lockable< T, L >.

Definition at line 164 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s() @%p\n", __func__, this);
#endif
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      int ret = impl ().do_close ();
 
      // Remove this IO from the file descriptors registry.
      file_descriptors_manager::deallocate (file_descriptor_);
      file_descriptor_ = no_file_descriptor;
 
      return ret;
    }

References os::posix::file_descriptors_manager::deallocate(), os::posix::io_impl::do_close(), os::posix::io::impl(), os::posix::no_file_descriptor, and os::trace::printf().

Referenced by os::posix::device::close(), os::posix::file::close(), and os::posix::socket_lockable< T, L >::close().

connect()

int os::posix::socket::connect ( const sockaddr *  address, socklen_t  address_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 82 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_connect (address, address_len);
    }

References os::posix::socket_impl::do_connect(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::connect().

fcntl()

int os::posix::io::fcntl ( int  cmd,   ...  )

inherited

Definition at line 363 of file io.cpp.

    {
      // Forward to the variadic version of the function.
      std::va_list args;
      va_start (args, cmd);
      int ret = vfcntl (cmd, args);
      va_end (args);
 
      return ret;
    }

References os::posix::io::vfcntl().

file_descriptor() [1/2]

void os::posix::io::file_descriptor ( file_descriptor_t  fildes )

inlineprotectedinherited

Definition at line 440 of file io.h.

    {
      file_descriptor_ = fildes;
    }

file_descriptor() [2/2]

file_descriptor_t os::posix::io::file_descriptor ( void  ) const

inlineinherited

Definition at line 452 of file io.h.

    {
      return file_descriptor_;
    }

Referenced by os::posix::file_descriptors_manager::allocate(), os::posix::file_descriptors_manager::assign(), os::posix::device::vopen(), and os::posix::vopen().

fstat()

int os::posix::io::fstat ( struct stat *  buf )

virtualinherited

Reimplemented in os::posix::file_lockable< T, L >.

Definition at line 416 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(%p) @%p\n", __func__, buf, this);
#endif
 
      if (buf == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_fstat (buf);
    }

References os::posix::io_impl::do_fstat(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::file_lockable< T, L >::fstat().

get_type()

io::type_t os::posix::io::get_type ( void  ) const

inlineinherited

Definition at line 434 of file io.h.

    {
      return type_;
    }

Referenced by os::posix::file_descriptors_manager::socket().

getpeername()

int os::posix::socket::getpeername ( sockaddr *  address, socklen_t *  address_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 92 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_getpeername (address, address_len);
    }

References os::posix::socket_impl::do_getpeername(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::getpeername().

getsockname()

int os::posix::socket::getsockname ( sockaddr *  address, socklen_t *  address_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 102 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_getsockname (address, address_len);
    }

References os::posix::socket_impl::do_getsockname(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::getsockname().

getsockopt()

int os::posix::socket::getsockopt ( int  level, int  option_name, void *  option_value, socklen_t *  option_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 112 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_getsockopt (level, option_name, option_value,
                                    option_len);
    }

References os::posix::socket_impl::do_getsockopt(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::getsockopt().

impl()

template<typename T >

socket_implementable< T >::value_type & os::posix::socket_implementable< T >::impl

(

void

)

const

Definition at line 590 of file posix-io/socket.h.

    {
      return static_cast<value_type&> (impl_);
    }

is_opened()

bool os::posix::io::is_opened ( void  )

inlineinherited

Definition at line 458 of file io.h.

    {
      return impl ().do_is_opened ();
    }

References os::posix::io_impl::do_is_opened(), and os::posix::io::impl().

isatty()

int os::posix::io::isatty ( void  )

inherited

Definition at line 406 of file io.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_isatty ();
    }

References os::posix::io_impl::do_isatty(), and os::posix::io::impl().

listen()

int os::posix::socket::listen ( int  backlog )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 123 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_listen (backlog);
    }

References os::posix::socket_impl::do_listen(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::listen().

lseek()

off_t os::posix::io::lseek ( off_t  offset, int  whence  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 447 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(%d, %d) @%p\n", __func__, offset, whence, this);
#endif
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_lseek (offset, whence);
    }

References os::posix::io_impl::do_lseek(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::lseek(), and os::posix::file_lockable< T, L >::lseek().

net_stack()

net_stack * os::posix::socket::net_stack ( void  )

inlineinherited

Definition at line 558 of file posix-io/socket.h.

    {
      return net_stack_;
    }

read()

ssize_t os::posix::io::read ( void *  buf, std::size_t  nbyte  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 217 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p\n", __func__, buf, nbyte, this);
#endif
 
      if (buf == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // http://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html
      // Before any action described below is taken, and if nbyte is zero,
      // the read() function may detect and return errors as described below.
      // In the absence of errors, or if error detection is not performed,
      // the read() function shall return zero and have no other results.
      if (nbyte == 0)
        {
          return 0; // Nothing to do.
        }
 
      // Execute the implementation specific code.
      ssize_t ret = impl ().do_read (buf, nbyte);
      if (ret >= 0)
        {
          impl ().offset_ += ret;
        }
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p n=%d\n", __func__, buf, nbyte,
                     this, ret);
#endif
      return ret;
    }

References os::posix::io_impl::do_read(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::read(), and os::posix::file_lockable< T, L >::read().

recv()

ssize_t os::posix::socket::recv ( void *  buffer, size_t  length, int  flags  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 132 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_recv (buffer, length, flags);
    }

References os::posix::socket_impl::do_recv(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::recv().

recvfrom()

ssize_t os::posix::socket::recvfrom ( void *  buffer, size_t  length, int  flags, sockaddr *  address, socklen_t *  address_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 141 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_recvfrom (buffer, length, flags, address, address_len);
    }

References os::posix::socket_impl::do_recvfrom(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::recvfrom().

recvmsg()

ssize_t os::posix::socket::recvmsg ( msghdr *  message, int  flags  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 151 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_recvmsg (message, flags);
    }

References os::posix::socket_impl::do_recvmsg(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::recvmsg().

send()

ssize_t os::posix::socket::send ( const void *  buffer, size_t  length, int  flags  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 160 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_send (buffer, length, flags);
    }

References os::posix::socket_impl::do_send(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::send().

sendmsg()

ssize_t os::posix::socket::sendmsg ( const msghdr *  message, int  flags  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 169 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_sendmsg (message, flags);
    }

References os::posix::socket_impl::do_sendmsg(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::sendmsg().

sendto()

ssize_t os::posix::socket::sendto ( const void *  message, size_t  length, int  flags, const sockaddr *  dest_addr, socklen_t  dest_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 178 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_sendto (message, length, flags, dest_addr, dest_len);
    }

References os::posix::socket_impl::do_sendto(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::sendto().

setsockopt()

int os::posix::socket::setsockopt ( int  level, int  option_name, const void *  option_value, socklen_t  option_len  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 188 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_setsockopt (level, option_name, option_value,
                                    option_len);
    }

References os::posix::socket_impl::do_setsockopt(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::setsockopt().

shutdown()

int os::posix::socket::shutdown ( int  how )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 199 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_shutdown (how);
    }

References os::posix::socket_impl::do_shutdown(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::shutdown().

sockatmark()

int os::posix::socket::sockatmark ( void  )

virtualinherited

Reimplemented in os::posix::socket_lockable< T, L >.

Definition at line 208 of file socket.cpp.

    {
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_sockatmark ();
    }

References os::posix::socket_impl::do_sockatmark(), and os::posix::socket::impl().

Referenced by os::posix::socket_lockable< T, L >::sockatmark().

vfcntl()

int os::posix::io::vfcntl ( int  cmd, std::va_list  args  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 380 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(%d) @%p\n", __func__, cmd, this);
#endif
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      return impl ().do_vfcntl (cmd, args);
    }

References os::posix::io_impl::do_vfcntl(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::io::fcntl(), os::posix::block_device_lockable< T, L >::vfcntl(), and os::posix::file_lockable< T, L >::vfcntl().

write()

ssize_t os::posix::io::write ( const void *  buf, std::size_t  nbyte  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 268 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p\n", __func__, buf, nbyte, this);
#endif
 
      if (buf == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // http://pubs.opengroup.org/onlinepubs/9699919799/functions/pwrite.html
      // Before any action described below is taken, and if nbyte is zero
      // and the file is a regular file, the write() function may detect and
      // return errors as described below. In the absence of errors, or if
      // error detection is not performed, the write() function shall return
      // zero and have no other results. If nbyte is zero and the file is
      // not a regular file, the results are unspecified.
      if (nbyte == 0)
        {
          return 0; // Nothing to do.
        }
 
      // Execute the implementation specific code.
      ssize_t ret = impl ().do_write (buf, nbyte);
      if (ret >= 0)
        {
          impl ().offset_ += ret;
        }
 
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %u) @%p n=%d\n", __func__, buf, nbyte,
                     this, ret);
#endif
      return ret;
    }

References os::posix::io_impl::do_write(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::write(), and os::posix::file_lockable< T, L >::write().

writev()

ssize_t os::posix::io::writev ( const iovec *  iov, int  iovcnt  )

virtualinherited

Reimplemented in os::posix::block_device_lockable< T, L >, and os::posix::file_lockable< T, L >.

Definition at line 321 of file io.cpp.

    {
#if defined(OS_TRACE_POSIX_IO_IO)
      trace::printf ("io::%s(0x0%X, %d) @%p\n", __func__, iov, iovcnt, this);
#endif
 
      if (iov == nullptr)
        {
          errno = EFAULT;
          return -1;
        }
 
      if (iovcnt <= 0)
        {
          errno = EINVAL;
          return -1;
        }
 
      if (!impl ().do_is_opened ())
        {
          errno = EBADF; // Not opened.
          return -1;
        }
 
      if (!impl ().do_is_connected ())
        {
          errno = EIO; // Not opened.
          return -1;
        }
 
      errno = 0;
 
      // Execute the implementation specific code.
      ssize_t ret = impl ().do_writev (iov, iovcnt);
      if (ret >= 0)
        {
          impl ().offset_ += ret;
        }
      return ret;
    }

References os::posix::io_impl::do_writev(), os::posix::io::impl(), and os::trace::printf().

Referenced by os::posix::block_device_lockable< T, L >::writev(), and os::posix::file_lockable< T, L >::writev().

---

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

• posix-io/socket.h