AuroraRuntime/Source/IO/Net/AuNetDatagramServer.Unix.cpp

/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: AuNetDatagramServer.Unix.cpp
    Date: 2022-8-26
    Author: Reece
***/
#include "Networking.hpp"
#include "AuNetDatagramServer.hpp"
#include "AuNetEndpoint.hpp"

namespace Aurora::IO::Net
{
    DatagramServerImpl::DatagramServerImpl(NetInterface *pInterface,
                                           NetWorker *pWorker,
                                           const AuSPtr<IDatagramDriver> &pDriver,
                                           AuUInt32 uDefaultPacketSize) :
        DatagramServer(pInterface,
                       pWorker,
                       pDriver,
                       uDefaultPacketSize),
        SocketServerImpl(pInterface, // struct NetInterface *pInterface
                         pWorker,     // struct NetWorker *pWorker
                         {},         // const AuSPtr<ISocketServerDriver> &pDriver
                         {},         // const AuSPtr<ISocketDriverFactory> &pFactory
                         4096,       // uMaxConnections
                         uDefaultPacketSize, // uDefaultInputStreamSize
                         true), // bMultiThreaded
        Socket(pInterface, pWorker, {}, -1)
    {
    }

    void DatagramServerImpl::DoPosixTick()
    {
        do
        {
            auto uLength = this->uDefaultInputStreamSize ? this->uDefaultInputStreamSize : kDefaultStreamSize;
            auto pBuffer = AuMakeShared<AuByteBuffer>(uLength);
            if (!pBuffer)
            {
                SysPushErrorMemory();
                return;
            }
            
            if (!pBuffer->IsValid())
            {
                SysPushErrorMemory();
                return;
            }

            NetEndpoint endpoint;

            socklen_t addressLength { sizeof(sockaddr_storage) };
            auto sRet = ::recvfrom(this->ToPlatformHandle(), pBuffer->writePtr, uLength, MSG_DONTWAIT, (struct sockaddr *)endpoint.hint, &addressLength);
            if (sRet <= 0)
            {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                {
                    break;
                }

                SysPushErrorNet("recvfrom: {}", sRet);
                // TODO: report and teardown if critical
                break;
            } 
            else
            {
                pBuffer->writePtr += sRet;

                DeoptimizeEndpoint(endpoint);
                endpoint.transportProtocol = ETransportProtocol::eProtocolUDP;

                if (this->pDriver_)
                {
                    try
                    {
                        this->pDriver_->OnPacket(endpoint, pBuffer);
                    }
                    catch (...)
                    {
                        SysPushErrorCatch();
                        
                        if (this->pDriver_)
                        {
                            this->pDriver_->OnError(AuNet::NetError(ENetworkError::eCatchException));
                        }
                    }
                }
            }
         
        }
        while (true);
    }
}