os::posix::socket_lockable< T, L > Class Template Reference

#include <socket.h>

Inheritance diagram for os::posix::socket_lockable< T, L >:

Public Types
using	lockable_type = L
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_lockable (class net_stack &ns, lockable_type &locker)
virtual	~socket_lockable ()
Public Member Functions
virtual int	close (void) override
virtual class socket *	accept (sockaddr *address, socklen_t *address_len) override
virtual int	bind (const sockaddr *address, socklen_t address_len) override
virtual int	connect (const sockaddr *address, socklen_t address_len) override
virtual int	getpeername (sockaddr *address, socklen_t *address_len) override
virtual int	getsockname (sockaddr *address, socklen_t *address_len) override
virtual int	getsockopt (int level, int option_name, void *option_value, socklen_t *option_len) override
virtual int	listen (int backlog) override
virtual ssize_t	recv (void *buffer, size_t length, int flags) override
virtual ssize_t	recvfrom (void *buffer, size_t length, int flags, sockaddr *address, socklen_t *address_len) override
virtual ssize_t	recvmsg (msghdr *message, int flags) override
virtual ssize_t	send (const void *buffer, size_t length, int flags) override
virtual ssize_t	sendmsg (const msghdr *message, int flags) override
virtual ssize_t	sendto (const void *message, size_t length, int flags, const sockaddr *dest_addr, socklen_t dest_len) override
virtual int	setsockopt (int level, int option_name, const void *option_value, socklen_t option_len) override
virtual int	shutdown (int how) override
virtual int	sockatmark (void) override
value_type &	impl (void) const
Public Member Functions
class net_stack *	net_stack (void)
Public Member Functions
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, typename L>
class os::posix::socket_lockable< T, L >

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

Member Typedef Documentation

lockable_type

template<typename T , typename L >

using os::posix::socket_lockable< T, L >::lockable_type = L

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

type_t

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

inherited

Definition at line 125 of file io.h.

value_type

template<typename T , typename L >

using os::posix::socket_lockable< T, L >::value_type = T

Definition at line 415 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_lockable()

template<typename T , typename L >

os::posix::socket_lockable< T, L >::socket_lockable	(	class net_stack &	ns,
		lockable_type &	locker
	)

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

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

References os::trace::printf().

~socket_lockable()

template<typename T , typename L >

os::posix::socket_lockable< T, L >::~socket_lockable

virtual

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

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

References os::trace::printf().

Member Function Documentation

accept()

template<typename T , typename L >

socket * os::posix::socket_lockable< T, L >::accept ( sockaddr *  address, socklen_t *  address_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::accept (address, address_len);
    }

References os::posix::socket::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()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::bind ( const sockaddr *  address, socklen_t  address_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::bind (address, address_len);
    }

References os::posix::socket::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()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::close ( void  )

overridevirtual

Reimplemented from os::posix::io.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::close ();
    }

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

connect()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::connect ( const sockaddr *  address, socklen_t  address_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::connect (address, address_len);
    }

References os::posix::socket::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()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::getpeername ( sockaddr *  address, socklen_t *  address_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::getpeername (address, address_len);
    }

References os::posix::socket::getpeername().

getsockname()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::getsockname ( sockaddr *  address, socklen_t *  address_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::getsockname (address, address_len);
    }

References os::posix::socket::getsockname().

getsockopt()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::getsockopt ( int  level, int  option_name, void *  option_value, socklen_t *  option_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::getsockopt (level, option_name, option_value, option_len);
    }

References os::posix::socket::getsockopt().

impl()

template<typename T , typename L >

socket_lockable< T, L >::value_type & os::posix::socket_lockable< T, L >::impl

(

void

)

const

Definition at line 788 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()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::listen ( int  backlog )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::listen (backlog);
    }

References os::posix::socket::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()

template<typename T , typename L >

ssize_t os::posix::socket_lockable< T, L >::recv ( void *  buffer, size_t  length, int  flags  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::recv (buffer, length, flags);
    }

References os::posix::socket::recv().

recvfrom()

template<typename T , typename L >

ssize_t os::posix::socket_lockable< T, L >::recvfrom ( void *  buffer, size_t  length, int  flags, sockaddr *  address, socklen_t *  address_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::recvfrom (buffer, length, flags, address, address_len);
    }

References os::posix::socket::recvfrom().

recvmsg()

template<typename T , typename L >

ssize_t os::posix::socket_lockable< T, L >::recvmsg ( msghdr *  message, int  flags  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::recvmsg (message, flags);
    }

References os::posix::socket::recvmsg().

send()

template<typename T , typename L >

ssize_t os::posix::socket_lockable< T, L >::send ( const void *  buffer, size_t  length, int  flags  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::send (buffer, length, flags);
    }

References os::posix::socket::send().

sendmsg()

template<typename T , typename L >

ssize_t os::posix::socket_lockable< T, L >::sendmsg ( const msghdr *  message, int  flags  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::sendmsg (message, flags);
    }

References os::posix::socket::sendmsg().

sendto()

template<typename T , typename L >

ssize_t os::posix::socket_lockable< T, L >::sendto ( const void *  message, size_t  length, int  flags, const sockaddr *  dest_addr, socklen_t  dest_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::sendto (message, length, flags, dest_addr, dest_len);
    }

References os::posix::socket::sendto().

setsockopt()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::setsockopt ( int  level, int  option_name, const void *  option_value, socklen_t  option_len  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::setsockopt (level, option_name, option_value, option_len);
    }

References os::posix::socket::setsockopt().

shutdown()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::shutdown ( int  how )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::shutdown (how);
    }

References os::posix::socket::shutdown().

sockatmark()

template<typename T , typename L >

int os::posix::socket_lockable< T, L >::sockatmark ( void  )

overridevirtual

Reimplemented from os::posix::socket.

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

    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::sockatmark ();
    }

References os::posix::socket::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