posix-io/socket.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2015-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
#ifndef CMSIS_PLUS_POSIX_IO_SOCKET_H_
#define CMSIS_PLUS_POSIX_IO_SOCKET_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/posix-io/io.h>
#include <cmsis-plus/posix/sys/socket.h>
#include <cmsis-plus/utils/lists.h>
 
#include <mutex>
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace posix
  {
    // ------------------------------------------------------------------------
 
    class socket;
    class socket_impl;
    class net_stack;
 
    // ------------------------------------------------------------------------
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#pragma GCC diagnostic ignored "-Wsuggest-final-types"
#endif
    class socket : public io
    {
      // ----------------------------------------------------------------------
    public:
      socket (socket_impl& impl, /* class */ net_stack& ns);
 
      // The rule of five.
      socket (const socket&) = delete;
      socket (socket&&) = delete;
      socket&
      operator= (const socket&)
          = delete;
      socket&
      operator= (socket&&)
          = delete;
 
      virtual ~socket () override;
 
      // ----------------------------------------------------------------------
    public:
      virtual /* class */ socket*
      accept (/* struct */ sockaddr* address, socklen_t* address_len);
 
      virtual int
      bind (const /* struct */ sockaddr* address, socklen_t address_len);
 
      virtual int
      connect (const /* struct */ sockaddr* address, socklen_t address_len);
 
      virtual int
      getpeername (/* struct */ sockaddr* address, socklen_t* address_len);
 
      virtual int
      getsockname (/* struct */ 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,
                /* struct */ sockaddr* address, socklen_t* address_len);
 
      virtual ssize_t
      recvmsg (/* struct */ msghdr* message, int flags);
 
      virtual ssize_t
      send (const void* buffer, size_t length, int flags);
 
      virtual ssize_t
      sendmsg (const /* struct */ msghdr* message, int flags);
 
      virtual ssize_t
      sendto (const void* message, size_t length, int flags,
              const /* struct */ 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);
 
      // ----------------------------------------------------------------------
      // Support functions.
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wredundant-tags"
#endif
 
      class net_stack*
      net_stack (void);
 
#pragma GCC diagnostic pop
 
      socket_impl&
      impl (void) const;
 
      // ----------------------------------------------------------------------
    public:
      // Intrusive node used to link this socket to the deferred
      // deallocation list. Must be public.
      utils::double_list_links deferred_links_;
 
      // ----------------------------------------------------------------------
    protected:
      class net_stack* net_stack_;
 
    };
#pragma GCC diagnostic pop
 
    // ========================================================================
 
    class socket_impl : public io_impl
    {
      // ----------------------------------------------------------------------
 
      friend class socket;
 
      // ----------------------------------------------------------------------
    public:
      socket_impl (void);
 
      // The rule of five.
      socket_impl (const socket_impl&) = delete;
      socket_impl (socket_impl&&) = delete;
      socket_impl&
      operator= (const socket_impl&)
          = delete;
      socket_impl&
      operator= (socket_impl&&)
          = delete;
 
      virtual ~socket_impl () override;
 
      // ----------------------------------------------------------------------
    public:
      virtual /* class */ socket*
      do_accept (/* struct */ sockaddr* address, socklen_t* address_len)
          = 0;
 
      virtual int
      do_bind (const /* struct */ sockaddr* address, socklen_t address_len)
          = 0;
 
      virtual int
      do_connect (const /* struct */ sockaddr* address, socklen_t address_len)
          = 0;
 
      virtual int
      do_getpeername (/* struct */ sockaddr* address, socklen_t* address_len)
          = 0;
 
      virtual int
      do_getsockname (/* struct */ sockaddr* address, socklen_t* address_len)
          = 0;
 
      virtual int
      do_getsockopt (int level, int option_name, void* option_value,
                     socklen_t* option_len)
          = 0;
 
      virtual int
      do_listen (int backlog)
          = 0;
 
      virtual ssize_t
      do_recv (void* buffer, size_t length, int flags)
          = 0;
 
      virtual ssize_t
      do_recvfrom (void* buffer, size_t length, int flags,
                   /* struct */ sockaddr* address, socklen_t* address_len)
          = 0;
 
      virtual ssize_t
      do_recvmsg (/* struct */ msghdr* message, int flags)
          = 0;
 
      virtual ssize_t
      do_send (const void* buffer, size_t length, int flags)
          = 0;
 
      virtual ssize_t
      do_sendmsg (const /* struct */ msghdr* message, int flags)
          = 0;
 
      virtual ssize_t
      do_sendto (const void* message, size_t length, int flags,
                 const /* struct */ sockaddr* dest_addr, socklen_t dest_len)
          = 0;
 
      virtual int
      do_setsockopt (int level, int option_name, const void* option_value,
                     socklen_t option_len)
          = 0;
 
      virtual int
      do_shutdown (int how)
          = 0;
 
      virtual int
      do_sockatmark (void)
          = 0;
 
    };
 
    // ========================================================================
 
    template <typename T>
    class socket_implementable : public socket
    {
      // ----------------------------------------------------------------------
 
    public:
      using value_type = T;
 
      // ---------------------------------------------------------------------
 
    public:
      socket_implementable (class net_stack& ns);
 
      // The rule of five.
      socket_implementable (const socket_implementable&) = delete;
      socket_implementable (socket_implementable&&) = delete;
      socket_implementable&
      operator= (const socket_implementable&)
          = delete;
      socket_implementable&
      operator= (socket_implementable&&)
          = delete;
 
      virtual ~socket_implementable ();
 
      // ----------------------------------------------------------------------
    public:
      // Support functions.
 
      value_type&
      impl (void) const;
 
      // ----------------------------------------------------------------------
    protected:
      value_type impl_instance_;
 
    };
 
    // ========================================================================
 
    template <typename T, typename L>
    class socket_lockable : public socket
    {
      // ----------------------------------------------------------------------
 
    public:
      using value_type = T;
      using lockable_type = L;
 
      // ----------------------------------------------------------------------
 
    public:
      socket_lockable (class net_stack& ns, lockable_type& locker);
 
      // The rule of five.
      socket_lockable (const socket_lockable&) = delete;
      socket_lockable (socket_lockable&&) = delete;
      socket_lockable&
      operator= (const socket_lockable&)
          = delete;
      socket_lockable&
      operator= (socket_lockable&&)
          = delete;
 
      virtual ~socket_lockable ();
 
      // ----------------------------------------------------------------------
    public:
      virtual int
      close (void) override;
 
      virtual class socket*
      accept (/* struct */ sockaddr* address, socklen_t* address_len) override;
 
      virtual int
      bind (const /* struct */ sockaddr* address,
            socklen_t address_len) override;
 
      virtual int
      connect (const /* struct */ sockaddr* address,
               socklen_t address_len) override;
 
      virtual int
      getpeername (/* struct */ sockaddr* address,
                   socklen_t* address_len) override;
 
      virtual int
      getsockname (/* struct */ 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,
                /* struct */ sockaddr* address,
                socklen_t* address_len) override;
 
      virtual ssize_t
      recvmsg (/* struct */ msghdr* message, int flags) override;
 
      virtual ssize_t
      send (const void* buffer, size_t length, int flags) override;
 
      virtual ssize_t
      sendmsg (const /* struct */ msghdr* message, int flags) override;
 
      virtual ssize_t
      sendto (const void* message, size_t length, int flags,
              const /* struct */ 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;
 
      // ----------------------------------------------------------------------
      // Support functions.
 
      value_type&
      impl (void) const;
 
      // ----------------------------------------------------------------------
    protected:
      value_type impl_instance_;
 
      lockable_type& locker_;
 
    };
 
    // ========================================================================
  } /* namespace posix */
} /* namespace os */
 
// ===== Inline & template implementations ====================================
 
namespace os
{
  namespace posix
  {
    // ========================================================================
 
    inline net_stack*
    socket::net_stack (void)
    {
      return net_stack_;
    }
 
    inline socket_impl&
    socket::impl (void) const
    {
      return static_cast<socket_impl&> (impl_);
    }
 
    // ========================================================================
 
    template <typename T>
    socket_implementable<T>::socket_implementable (class net_stack& ns)
        : socket{ impl_instance_, ns }
    {
#if defined(OS_TRACE_POSIX_IO_SOCKET)
      trace::printf ("socket_implementable::%s()=@%p\n", __func__, this);
#endif
    }
 
    template <typename T>
    socket_implementable<T>::~socket_implementable ()
    {
#if defined(OS_TRACE_POSIX_IO_SOCKET)
      trace::printf ("socket_implementable::%s() @%p\n", __func__, this);
#endif
    }
 
    template <typename T>
    typename socket_implementable<T>::value_type&
    socket_implementable<T>::impl (void) const
    {
      return static_cast<value_type&> (impl_);
    }
 
    // ========================================================================
 
    template <typename T, typename L>
    socket_lockable<T, L>::socket_lockable (class net_stack& ns,
                                            lockable_type& locker)
        : socket{ impl_instance_, ns }, //
          locker_ (locker)
    {
#if defined(OS_TRACE_POSIX_IO_SOCKET)
      trace::printf ("socket_lockable::%s()=@%p\n", __func__, this);
#endif
    }
 
    template <typename T, typename L>
    socket_lockable<T, L>::~socket_lockable ()
    {
#if defined(OS_TRACE_POSIX_IO_SOCKET)
      trace::printf ("socket_lockable::%s() @%p\n", __func__, this);
#endif
    }
 
    // ------------------------------------------------------------------------
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::close (void)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::close ();
    }
 
    template <typename T, typename L>
    /* class */ socket*
    socket_lockable<T, L>::accept (/* struct */ sockaddr* address,
                                   socklen_t* address_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::accept (address, address_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::bind (const /* struct */ sockaddr* address,
                                 socklen_t address_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::bind (address, address_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::connect (const /* struct */ sockaddr* address,
                                    socklen_t address_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::connect (address, address_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::getpeername (/* struct */ sockaddr* address,
                                        socklen_t* address_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::getpeername (address, address_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::getsockname (/* struct */ sockaddr* address,
                                        socklen_t* address_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::getsockname (address, address_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::getsockopt (int level, int option_name,
                                       void* option_value,
                                       socklen_t* option_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::getsockopt (level, option_name, option_value, option_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::listen (int backlog)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::listen (backlog);
    }
 
    template <typename T, typename L>
    ssize_t
    socket_lockable<T, L>::recv (void* buffer, size_t length, int flags)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::recv (buffer, length, flags);
    }
 
    template <typename T, typename L>
    ssize_t
    socket_lockable<T, L>::recvfrom (void* buffer, size_t length, int flags,
                                     /* struct */ sockaddr* address,
                                     socklen_t* address_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::recvfrom (buffer, length, flags, address, address_len);
    }
 
    template <typename T, typename L>
    ssize_t
    socket_lockable<T, L>::recvmsg (/* struct */ msghdr* message, int flags)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::recvmsg (message, flags);
    }
 
    template <typename T, typename L>
    ssize_t
    socket_lockable<T, L>::send (const void* buffer, size_t length, int flags)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::send (buffer, length, flags);
    }
 
    template <typename T, typename L>
    ssize_t
    socket_lockable<T, L>::sendmsg (const /* struct */ msghdr* message,
                                    int flags)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::sendmsg (message, flags);
    }
 
    template <typename T, typename L>
    ssize_t
    socket_lockable<T, L>::sendto (const void* message, size_t length,
                                   int flags,
                                   const /* struct */ sockaddr* dest_addr,
                                   socklen_t dest_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::sendto (message, length, flags, dest_addr, dest_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::setsockopt (int level, int option_name,
                                       const void* option_value,
                                       socklen_t option_len)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::setsockopt (level, option_name, option_value, option_len);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::shutdown (int how)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::shutdown (how);
    }
 
    template <typename T, typename L>
    int
    socket_lockable<T, L>::sockatmark (void)
    {
      std::lock_guard<L> lock{ locker_ };
 
      return socket::sockatmark ();
    }
 
    template <typename T, typename L>
    typename socket_lockable<T, L>::value_type&
    socket_lockable<T, L>::impl (void) const
    {
      return static_cast<value_type&> (impl_);
    }
 
    // ========================================================================
  } /* namespace posix */
} /* namespace os */
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
#endif /* __cplusplus */
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_POSIX_IO_SOCKET_H_ */