// InsecureConnection.cpp

// TODO: Asynchronous connecting on client side?

#include <new>

#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <ByteOrder.h>

#include "Compatibility.h"
#include "DebugSupport.h"
#include "InsecureChannel.h"
#include "InsecureConnection.h"
#include "NetAddress.h"
#include "NetFSDefs.h"

namespace InsecureConnectionDefs {

const int32 kProtocolVersion = 1;

const bigtime_t kAcceptingTimeout = 10000000;   // 10 s

// number of client up/down stream channels
const int32 kMinUpStreamChannels                = 1;
const int32 kMaxUpStreamChannels                = 10;
const int32 kDefaultUpStreamChannels    = 5;
const int32 kMinDownStreamChannels              = 1;
const int32 kMaxDownStreamChannels              = 5;
const int32 kDefaultDownStreamChannels  = 1;

} // namespace InsecureConnectionDefs

using namespace InsecureConnectionDefs;

// SocketCloser
struct SocketCloser {
        SocketCloser(int fd) : fFD(fd) {}
        ~SocketCloser()
        {
                if (fFD >= 0)
                        closesocket(fFD);
        }

        int Detach()
        {
                int fd = fFD;
                fFD = -1;
                return fd;
        }

private:
        int     fFD;
};


// #pragma mark -
// #pragma mark ----- InsecureConnection -----

// constructor
InsecureConnection::InsecureConnection()
{
}

// destructor
InsecureConnection::~InsecureConnection()
{
}

// Init (server side)
status_t
InsecureConnection::Init(int fd)
{
        status_t error = AbstractConnection::Init();
        if (error != B_OK) {
                closesocket(fd);
                return error;
        }
        // create the initial channel
        Channel* channel = new(std::nothrow) InsecureChannel(fd);
        if (!channel) {
                closesocket(fd);
                return B_NO_MEMORY;
        }
        // add it
        error = AddDownStreamChannel(channel);
        if (error != B_OK) {
                delete channel;
                return error;
        }
        return B_OK;
}

// Init (client side)
status_t
InsecureConnection::Init(const char* parameters)
{
PRINT(("InsecureConnection::Init\n"));
        if (!parameters)
                return B_BAD_VALUE;
        status_t error = AbstractConnection::Init();
        if (error != B_OK)
                return error;
        // parse the parameters to get a server name and a port we shall connect to
        // parameter format is "<server>[:port] [ <up> [ <down> ] ]"
        char server[256];
        uint16 port = kDefaultInsecureConnectionPort;
        int upStreamChannels = kDefaultUpStreamChannels;
        int downStreamChannels = kDefaultDownStreamChannels;
        if (strchr(parameters, ':')) {
                int result = sscanf(parameters, "%255[^:]:%hu %d %d", server, &port,
                        &upStreamChannels, &downStreamChannels);
                if (result < 2)
                        return B_BAD_VALUE;
        } else {
                int result = sscanf(parameters, "%255[^:] %d %d", server,
                        &upStreamChannels, &downStreamChannels);
                if (result < 1)
                        return B_BAD_VALUE;
        }
        // resolve server address
        NetAddress netAddress;
        error = NetAddressResolver().GetHostAddress(server, &netAddress);
        if (error != B_OK)
                return error;
        in_addr serverAddr = netAddress.GetAddress().sin_addr;
        // open the initial channel
        Channel* channel;
        error = _OpenClientChannel(serverAddr, port, &channel);
        if (error != B_OK)
                return error;
        error = AddUpStreamChannel(channel);
        if (error != B_OK) {
                delete channel;
                return error;
        }
        // send the server a connect request
        ConnectRequest request;
        request.protocolVersion = B_HOST_TO_BENDIAN_INT32(kProtocolVersion);
        request.serverAddress = serverAddr.s_addr;
        request.upStreamChannels = B_HOST_TO_BENDIAN_INT32(upStreamChannels);
        request.downStreamChannels = B_HOST_TO_BENDIAN_INT32(downStreamChannels);
        error = channel->Send(&request, sizeof(ConnectRequest));
        if (error != B_OK)
                return error;
        // get the server reply
        ConnectReply reply;
        error = channel->Receive(&reply, sizeof(ConnectReply));
        if (error != B_OK)
                return error;
        error = B_BENDIAN_TO_HOST_INT32(reply.error);
        if (error != B_OK)
                return error;
        upStreamChannels = B_BENDIAN_TO_HOST_INT32(reply.upStreamChannels);
        downStreamChannels = B_BENDIAN_TO_HOST_INT32(reply.downStreamChannels);
        port = B_BENDIAN_TO_HOST_INT16(reply.port);
        // open the remaining channels
        int32 allChannels = upStreamChannels + downStreamChannels;
        for (int32 i = 1; i < allChannels; i++) {
                PRINT("  creating channel %" B_PRId32 "\n", i);
                // open the channel
                error = _OpenClientChannel(serverAddr, port, &channel);
                if (error != B_OK)
                        RETURN_ERROR(error);
                // add it
                if (i < upStreamChannels)
                        error = AddUpStreamChannel(channel);
                else
                        error = AddDownStreamChannel(channel);
                if (error != B_OK) {
                        delete channel;
                        return error;
                }
        }
        return B_OK;
}

// FinishInitialization
status_t
InsecureConnection::FinishInitialization()
{
PRINT(("InsecureConnection::FinishInitialization()\n"));
        // get the down stream channel
        InsecureChannel* channel
                = dynamic_cast<InsecureChannel*>(DownStreamChannelAt(0));
        if (!channel)
                return B_BAD_VALUE;
        // receive the connect request
        ConnectRequest request;
        status_t error = channel->Receive(&request, sizeof(ConnectRequest));
        if (error != B_OK)
                return error;
        // check the protocol version
        int32 protocolVersion = B_BENDIAN_TO_HOST_INT32(request.protocolVersion);
        if (protocolVersion != kProtocolVersion) {
                _SendErrorReply(channel, B_ERROR);
                return B_ERROR;
        }
        // get our address (we need it for binding)
        in_addr serverAddr;
        serverAddr.s_addr = request.serverAddress;
        // check number of up and down stream channels
        int32 upStreamChannels = B_BENDIAN_TO_HOST_INT32(request.upStreamChannels);
        int32 downStreamChannels = B_BENDIAN_TO_HOST_INT32(
                request.downStreamChannels);
        if (upStreamChannels < kMinUpStreamChannels)
                upStreamChannels = kMinUpStreamChannels;
        else if (upStreamChannels > kMaxUpStreamChannels)
                upStreamChannels = kMaxUpStreamChannels;
        if (downStreamChannels < kMinDownStreamChannels)
                downStreamChannels = kMinDownStreamChannels;
        else if (downStreamChannels > kMaxDownStreamChannels)
                downStreamChannels = kMaxDownStreamChannels;
        // due to a bug on BONE we have a maximum of 2 working connections
        // accepted on one listener socket.
        NetAddress peerAddress;
        if (channel->GetPeerAddress(&peerAddress) == B_OK
                && peerAddress.IsLocal()) {
                upStreamChannels = 1;
                if (downStreamChannels > 2)
                        downStreamChannels = 2;
        }
        int32 allChannels = upStreamChannels + downStreamChannels;
        // create a listener socket
        int fd = socket(AF_INET, SOCK_STREAM, 0);
        if (fd < 0) {
                error = errno;
                _SendErrorReply(channel, error);
                return error;
        }
        SocketCloser _(fd);
        // bind it to some port
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = 0;
        addr.sin_addr = serverAddr;
        if (bind(fd, (sockaddr*)&addr, sizeof(addr)) < 0) {
                error = errno;
                _SendErrorReply(channel, error);
                return error;
        }
        // get the port
        socklen_t addrSize = sizeof(addr);
        if (getsockname(fd, (sockaddr*)&addr, &addrSize) < 0) {
                error = errno;
                _SendErrorReply(channel, error);
                return error;
        }
        // set socket to non-blocking
        int dontBlock = 1;
        if (setsockopt(fd, SOL_SOCKET, SO_NONBLOCK, &dontBlock, sizeof(int)) < 0) {
                error = errno;
                _SendErrorReply(channel, error);
                return error;
        }
        // start listening
        if (listen(fd, allChannels - 1) < 0) {
                error = errno;
                _SendErrorReply(channel, error);
                return error;
        }
        // send the reply
        ConnectReply reply;
        reply.error = B_HOST_TO_BENDIAN_INT32(B_OK);
        reply.upStreamChannels = B_HOST_TO_BENDIAN_INT32(upStreamChannels);
        reply.downStreamChannels = B_HOST_TO_BENDIAN_INT32(downStreamChannels);
        reply.port = addr.sin_port;
        error = channel->Send(&reply, sizeof(ConnectReply));
        if (error != B_OK)
                return error;
        // start accepting
        bigtime_t startAccepting = system_time();
        for (int32 i = 1; i < allChannels; ) {
                // accept a connection
                int channelFD = accept(fd, NULL, 0);
                if (channelFD < 0) {
                        error = errno;
                        if (error == B_INTERRUPTED) {
                                error = B_OK;
                                continue;
                        }
                        if (error == B_WOULD_BLOCK) {
                                bigtime_t now = system_time();
                                if (now - startAccepting > kAcceptingTimeout)
                                        RETURN_ERROR(B_TIMED_OUT);
                                snooze(10000);
                                continue;
                        }
                        RETURN_ERROR(error);
                }
                PRINT("  accepting channel %" B_PRId32 "\n", i);
                // create a channel
                channel = new(std::nothrow) InsecureChannel(channelFD);
                if (!channel) {
                        closesocket(channelFD);
                        return B_NO_MEMORY;
                }
                // add it
                if (i < upStreamChannels)       // inverse, since we are on server side
                        error = AddDownStreamChannel(channel);
                else
                        error = AddUpStreamChannel(channel);
                if (error != B_OK) {
                        delete channel;
                        return error;
                }
                i++;
                startAccepting = system_time();
        }
        return B_OK;
}

// _OpenClientChannel
status_t
InsecureConnection::_OpenClientChannel(in_addr serverAddr, uint16 port,
        Channel** _channel)
{
        // create a socket
        int fd = socket(AF_INET, SOCK_STREAM, 0);
        if (fd < 0)
                return errno;
        // connect
        sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr = serverAddr;
        if (connect(fd, (sockaddr*)&addr, sizeof(addr)) < 0) {
                status_t error = errno;
                closesocket(fd);
                RETURN_ERROR(error);
        }
        // create the channel
        Channel* channel = new(std::nothrow) InsecureChannel(fd);
        if (!channel) {
                closesocket(fd);
                return B_NO_MEMORY;
        }
        *_channel = channel;
        return B_OK;
}

// _SendErrorReply
status_t
InsecureConnection::_SendErrorReply(Channel* channel, status_t error)
{
        ConnectReply reply;
        reply.error = B_HOST_TO_BENDIAN_INT32(error);
        return channel->Send(&reply, sizeof(ConnectReply));
}