Socket-Private_.h

/*
 * Copyright(c) Sophist Solutions, Inc. 1990-2026.  All rights reserved
 */
#ifndef _Stroika_Foundation_IO_Network_Socket_Private_h_
#define _Stroika_Foundation_IO_Network_Socket_Private_h_ 1
 
#include "Stroika/Foundation/StroikaPreComp.h"
 
// ONLY INCLUDED BY Network-Socket CPP implementation code. Do not include directly
 
#include <cstdlib>
#include <sys/types.h>
 
#if qStroika_Platform_POSIX
#include <netdb.h>
#include <poll.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <unistd.h>
#elif qStroika_Platform_Windows
#include <winsock2.h>
 
#include <io.h>
#include <ws2tcpip.h>
 
#include <Mstcpip.h>
#endif
#if qStroika_Platform_Linux
#include <netinet/in.h>
#include <netinet/tcp.h>
#endif
 
#include "Stroika/Foundation/Debug/AssertExternallySynchronizedChecker.h"
#include "Stroika/Foundation/Debug/Trace.h"
#include "Stroika/Foundation/Execution/OperationNotSupportedException.h"
#if qStroika_Platform_Windows
#include "Stroika/Foundation/Execution/Platform/Windows/Exception.h"
#include "Stroika/Foundation/IO/Network/Platform/Windows/WinSock.h"
#endif
 
#include "Stroika/Foundation/IO/Network/Socket.h"
 
/*
 ********************************************************************************
 ***************************** Implementation Details ***************************
 ********************************************************************************
 */
namespace Stroika::Foundation::IO::Network {
 
    namespace PRIVATE_ {
        using namespace Stroika::Foundation;
        using namespace Stroika::Foundation::Characters;
        using namespace Stroika::Foundation::Execution;
        using namespace Stroika::Foundation::Memory;
        using namespace Stroika::Foundation::IO;
        using namespace Stroika::Foundation::IO::Network;
 
        using Debug::AssertExternallySynchronizedChecker;
 
#if qStroika_Platform_POSIX
        /*
         *  Internally we use this -1 value to mean invalid socket, but keep that a private implementation
         *  detail, since I'm not sure it will be good for all socket implementations?
         */
        constexpr Socket::PlatformNativeHandle kINVALID_NATIVE_HANDLE_ = -1; // right value??
#elif qStroika_Platform_Windows
        constexpr Socket::PlatformNativeHandle kINVALID_NATIVE_HANDLE_ = INVALID_SOCKET;
#endif
 
        template <typename T>
        void BreakWriteIntoParts_ (span<const T> data, size_t maxSendAtATime, const function<size_t (span<const T>)>& writeFunc)
        {
#if USE_NOISY_TRACE_IN_THIS_MODULE_
            Debug::TraceContextBumper ctx{Stroika_Foundation_Debug_OptionalizeTraceArgs ("{}::BreakWriteIntoParts_", "n={}"_f, data.size ())};
#endif
            ptrdiff_t amountToSend          = data.size ();
            ptrdiff_t amountRemainingToSend = amountToSend;
            const T*  remainingSendFrom     = data.data ();
            while (amountRemainingToSend > 0) {
                size_t amountToSendThisIteration = min<size_t> (maxSendAtATime, amountRemainingToSend);
                size_t amountSent                = writeFunc (span{remainingSendFrom, amountToSendThisIteration});
                Assert (amountSent <= amountToSendThisIteration);
                Assert (static_cast<size_t> (amountRemainingToSend) >= amountSent);
                amountRemainingToSend -= amountSent;
                remainingSendFrom += amountSent;
#if USE_NOISY_TRACE_IN_THIS_MODULE_
                if (amountSent < amountToSendThisIteration) {
                    DbgTrace (
                        L"write broken into parts - amountSent=%lld out of amountToSendThisIteration=%lld, amountRemainingToSend=%lld",
                        static_cast<long long> (amountSent), static_cast<long long> (amountToSendThisIteration),
                        static_cast<long long> (amountRemainingToSend));
                }
#endif
            }
        }
 
        template <typename BASE_REP>
        struct BackSocketImpl_ : public BASE_REP {
            Socket::PlatformNativeHandle fSD_;
            BackSocketImpl_ (Socket::PlatformNativeHandle sd)
                : fSD_{sd}
            {
            }
            ~BackSocketImpl_ ()
            {
                if (fSD_ != kINVALID_NATIVE_HANDLE_) {
                    Close ();
                }
            }
            virtual Socket::PlatformNativeHandle Detach () override
            {
                Debug::AssertExternallySynchronizedChecker::WriteContext declareContext{fThisAssertExternallySynchronized};
                Socket::PlatformNativeHandle                             h = fSD_;
                fSD_                                                       = kINVALID_NATIVE_HANDLE_;
                return h;
            }
            virtual void Shutdown (Socket::ShutdownTarget shutdownTarget) override
            {
                Debug::AssertExternallySynchronizedChecker::WriteContext declareContext{fThisAssertExternallySynchronized};
                if (fSD_ != kINVALID_NATIVE_HANDLE_) {
                    // Intentionally ignore shutdown results because in most cases there is nothing todo (maybe in some cases we should log?)
                    switch (shutdownTarget) {
                        case Socket::ShutdownTarget::eReads:
#if qStroika_Platform_POSIX
                            ::shutdown (fSD_, SHUT_RD);
#elif qStroika_Platform_Windows
                            ::shutdown (fSD_, SD_RECEIVE);
#endif
                            break;
                        case Socket::ShutdownTarget::eWrites:
// I believe this triggers TCP FIN
#if qStroika_Platform_POSIX
                            ::shutdown (fSD_, SHUT_WR);
#elif qStroika_Platform_Windows
                            ::shutdown (fSD_, SD_SEND);
#endif
                            break;
                        case Socket::ShutdownTarget::eBoth:
#if qStroika_Platform_POSIX
                            ::shutdown (fSD_, SHUT_RDWR);
#elif qStroika_Platform_Windows
                            ::shutdown (fSD_, SD_BOTH);
#endif
                            break;
                        default:
                            RequireNotReached ();
                    }
                }
            }
            virtual void Close () override
            {
                Debug::AssertExternallySynchronizedChecker::WriteContext declareContext{fThisAssertExternallySynchronized};
                if (fSD_ != kINVALID_NATIVE_HANDLE_) {
#if qStroika_Platform_POSIX
                    ::close (fSD_);
#elif qStroika_Platform_Windows
                    ::closesocket (fSD_);
#else
                    AssertNotImplemented ();
#endif
                    fSD_ = kINVALID_NATIVE_HANDLE_;
                }
            }
            virtual optional<IO::Network::SocketAddress> GetLocalAddress () const override
            {
                Debug::AssertExternallySynchronizedChecker::ReadContext declareContext{fThisAssertExternallySynchronized};
                struct sockaddr_storage                                 radr;
                socklen_t                                               len = sizeof (radr);
                if (::getsockname (fSD_, reinterpret_cast<struct sockaddr*> (&radr), &len) == 0) {
                    IO::Network::SocketAddress sa{radr};
                    return sa;
                }
                return nullopt;
            }
            virtual SocketAddress::FamilyType GetAddressFamily () const override
            {
                Debug::AssertExternallySynchronizedChecker::ReadContext declareContext{fThisAssertExternallySynchronized};
#if defined(SO_DOMAIN)
                return static_cast<SocketAddress::FamilyType> (getsockopt<int> (SOL_SOCKET, SO_DOMAIN)); // an int, per socket(7)
#elif qStroika_Platform_Windows
                // getsockname cannot stand in here: Windows fails it (WSAEINVAL) on a socket not yet bound
                WSAPROTOCOL_INFOW info{};
                socklen_t         infoLen = sizeof (info);
                getsockopt (SOL_SOCKET, SO_PROTOCOL_INFOW, &info, &infoLen);
                return static_cast<SocketAddress::FamilyType> (info.iAddressFamily);
#else
                // No SO_DOMAIN (macOS, as of macOS 26): getsockname reports the family. POSIX leaves its result unspecified for
                // a socket not yet bound, but macOS fills in the family then too.
                sockaddr_storage radr{};
                socklen_t        len = sizeof (radr);
                ThrowPOSIXErrNoIfNegative (::getsockname (fSD_, reinterpret_cast<sockaddr*> (&radr), &len));
                return static_cast<SocketAddress::FamilyType> (radr.ss_family);
#endif
            }
            virtual Socket::PlatformNativeHandle GetNativeSocket () const override
            {
                Debug::AssertExternallySynchronizedChecker::ReadContext declareContext{fThisAssertExternallySynchronized};
                return fSD_;
            }
            virtual void getsockopt (int level, int optname, void* optval, socklen_t* optvallen) const override
            {
                Debug::AssertExternallySynchronizedChecker::ReadContext declareContext{fThisAssertExternallySynchronized};
                // According to http://linux.die.net/man/2/getsockopt cannot return EINTR, so no need to retry
                RequireNotNull (optval);
#if qStroika_Platform_POSIX
                ThrowPOSIXErrNoIfNegative (::getsockopt (fSD_, level, optname, reinterpret_cast<char*> (optval), optvallen));
#elif qStroika_Platform_Windows
                ThrowWSASystemErrorIfSOCKET_ERROR (::getsockopt (fSD_, level, optname, reinterpret_cast<char*> (optval), optvallen));
#else
                AssertNotImplemented ();
#endif
            }
            template <typename RESULT_TYPE>
            inline RESULT_TYPE getsockopt (int level, int optname) const
            {
                Debug::AssertExternallySynchronizedChecker::ReadContext declareContext{fThisAssertExternallySynchronized};
                RESULT_TYPE                                             r{};
                socklen_t                                               roptlen = sizeof (r);
                this->getsockopt (level, optname, &r, &roptlen);
                return r;
            }
            virtual void setsockopt (int level, int optname, const void* optval, socklen_t optvallen) override
            {
                Debug::AssertExternallySynchronizedChecker::WriteContext declareContext{fThisAssertExternallySynchronized};
                // According to http://linux.die.net/man/2/setsockopt cannot return EINTR, so no need to retry
                RequireNotNull (optval);
#if qStroika_Platform_POSIX
                ThrowPOSIXErrNoIfNegative (::setsockopt (fSD_, level, optname, optval, optvallen));
#elif qStroika_Platform_Windows
                ThrowWSASystemErrorIfSOCKET_ERROR (::setsockopt (fSD_, level, optname, reinterpret_cast<const char*> (optval), optvallen));
#else
                AssertNotImplemented ();
#endif
            }
            template <typename ARG_TYPE>
            inline void setsockopt (int level, int optname, ARG_TYPE arg)
            {
                socklen_t optvallen = sizeof (arg);
                this->setsockopt (level, optname, &arg, optvallen);
            }
            Stroika_ATTRIBUTE_NO_UNIQUE_ADDRESS_VCFORCE Debug::AssertExternallySynchronizedChecker fThisAssertExternallySynchronized;
        };
    }
 
}
 
#endif /*_Stroika_Foundation_IO_Network_Socket_Private_h_*/