/*
 * Copyright 2011, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include <DatagramSocket.h>

#include <errno.h>


//#define TRACE_SOCKET
#ifdef TRACE_SOCKET
#       define TRACE(x...) printf(x)
#else
#       define TRACE(x...) ;
#endif


BDatagramSocket::BDatagramSocket()
{
}


BDatagramSocket::BDatagramSocket(const BNetworkAddress& peer, bigtime_t timeout)
{
        Connect(peer, timeout);
}


BDatagramSocket::BDatagramSocket(const BDatagramSocket& other)
        :
        BAbstractSocket(other)
{
}


BDatagramSocket::~BDatagramSocket()
{
}


status_t
BDatagramSocket::Bind(const BNetworkAddress& local, bool reuseAddr)
{
        return BAbstractSocket::Bind(local, reuseAddr, SOCK_DGRAM);
}


status_t
BDatagramSocket::Accept(BAbstractSocket*& _socket)
{
        return B_NOT_SUPPORTED;
}


status_t
BDatagramSocket::Connect(const BNetworkAddress& peer, bigtime_t timeout)
{
        return BAbstractSocket::Connect(peer, SOCK_DGRAM, timeout);
}


status_t
BDatagramSocket::SetBroadcast(bool broadcast)
{
        int value = broadcast ? 1 : 0;
        if (setsockopt(fSocket, SOL_SOCKET, SO_BROADCAST, &value, sizeof(value))
                        != 0)
                return errno;

        return B_OK;
}


void
BDatagramSocket::SetPeer(const BNetworkAddress& peer)
{
        fPeer = peer;
}


size_t
BDatagramSocket::MaxTransmissionSize() const
{
        // TODO: might vary on family!
        return 32768;
}


ssize_t
BDatagramSocket::SendTo(const BNetworkAddress& address, const void* buffer,
        size_t size)
{
        ssize_t bytesSent = sendto(fSocket, buffer, size, 0, address,
                address.Length());
        if (bytesSent < 0)
                return errno;

        return bytesSent;
}


ssize_t
BDatagramSocket::ReceiveFrom(void* buffer, size_t bufferSize,
        BNetworkAddress& from)
{
        socklen_t fromLength = sizeof(sockaddr_storage);
        ssize_t bytesReceived = recvfrom(fSocket, buffer, bufferSize, 0,
                from, &fromLength);
        if (bytesReceived < 0)
                return errno;

        return bytesReceived;
}


//      #pragma mark - BDataIO implementation


ssize_t
BDatagramSocket::Read(void* buffer, size_t size)
{
        ssize_t bytesReceived = recv(Socket(), buffer, size, 0);
        if (bytesReceived < 0) {
                TRACE("%p: BSocket::Read() error: %s\n", this, strerror(errno));
                return errno;
        }

        return bytesReceived;
}


ssize_t
BDatagramSocket::Write(const void* buffer, size_t size)
{
        ssize_t bytesSent;

        if (!fIsConnected)
                bytesSent = sendto(Socket(), buffer, size, 0, fPeer, fPeer.Length());
        else
                bytesSent = send(Socket(), buffer, size, 0);

        if (bytesSent < 0) {
                TRACE("%p: BDatagramSocket::Write() error: %s\n", this,
                        strerror(errno));
                return errno;
        }

        return bytesSent;
}