/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <stdio.h>
#include <sys/un.h>

#include <new>

#include <AutoDeleter.h>
#include <StackOrHeapArray.h>

#include <fs/fd.h>
#include <lock.h>
#include <util/AutoLock.h>
#include <vfs.h>

#include <net_buffer.h>
#include <net_protocol.h>
#include <net_socket.h>
#include <net_stack.h>

#include "unix.h"
#include "UnixAddressManager.h"
#include "UnixEndpoint.h"


#define UNIX_MODULE_DEBUG_LEVEL 0
#define UNIX_DEBUG_LEVEL                UNIX_MODULE_DEBUG_LEVEL
#include "UnixDebug.h"


extern net_protocol_module_info gUnixModule;
        // extern only for forwarding

net_stack_module_info *gStackModule;
net_socket_module_info *gSocketModule;
net_buffer_module_info *gBufferModule;
UnixAddressManager gAddressManager;

static struct net_domain *sDomain;


void
destroy_scm_rights_descriptors(const ancillary_data_header* header,
        void* data)
{
        int count = header->len / sizeof(file_descriptor*);
        file_descriptor** descriptors = (file_descriptor**)data;
        io_context* ioContext = get_current_io_context(!gStackModule->is_syscall());

        for (int i = 0; i < count; i++) {
                if (descriptors[i] != NULL) {
                        close_fd(ioContext, descriptors[i]);
                        put_fd(descriptors[i]);
                }
        }
}


void
clone_scm_rights_descriptors(const ancillary_data_header* header, void* data)
{
        int count = header->len / sizeof(file_descriptor*);
        file_descriptor** descriptors = (file_descriptor**)data;

        for (int i = 0; i < count; i++) {
                if (descriptors[i] != NULL) {
                        inc_fd_ref_count(descriptors[i]);
                        inc_fd_open_count(descriptors[i]);
                }
        }
}


// #pragma mark -


net_protocol *
unix_init_protocol(net_socket *socket)
{
        TRACE("[%" B_PRId32 "] unix_init_protocol(%p)\n", find_thread(NULL),
                socket);

        UnixEndpoint* endpoint;
        status_t error = UnixEndpoint::Create(socket, &endpoint);
        if (error != B_OK)
                return NULL;

        error = endpoint->Init();
        if (error != B_OK) {
                delete endpoint;
                return NULL;
        }

        return endpoint;
}


status_t
unix_uninit_protocol(net_protocol *_protocol)
{
        TRACE("[%" B_PRId32 "] unix_uninit_protocol(%p)\n", find_thread(NULL),
                _protocol);
        ((UnixEndpoint*)_protocol)->Uninit();
        return B_OK;
}


status_t
unix_open(net_protocol *_protocol)
{
        return ((UnixEndpoint*)_protocol)->Open();
}


status_t
unix_close(net_protocol *_protocol)
{
        return ((UnixEndpoint*)_protocol)->Close();
}


status_t
unix_free(net_protocol *_protocol)
{
        return ((UnixEndpoint*)_protocol)->Free();
}


status_t
unix_connect(net_protocol *_protocol, const struct sockaddr *address)
{
        return ((UnixEndpoint*)_protocol)->Connect(address);
}


status_t
unix_accept(net_protocol *_protocol, struct net_socket **_acceptedSocket)
{
        return ((UnixEndpoint*)_protocol)->Accept(_acceptedSocket);
}


status_t
unix_control(net_protocol *protocol, int level, int option, void *value,
        size_t *_length)
{
        return B_BAD_VALUE;
}


status_t
unix_getsockopt(net_protocol *protocol, int level, int option, void *value,
        int *_length)
{
        UnixEndpoint* endpoint = (UnixEndpoint*)protocol;

        if (level == SOL_SOCKET && option == SO_PEERCRED) {
                if (*_length < (int)sizeof(ucred))
                        return B_BAD_VALUE;

                *_length = sizeof(ucred);

                return endpoint->GetPeerCredentials((ucred*)value);
        }

        return gSocketModule->get_option(protocol->socket, level, option, value,
                _length);
}


status_t
unix_setsockopt(net_protocol *protocol, int level, int option,
        const void *_value, int length)
{
        UnixEndpoint* endpoint = (UnixEndpoint*)protocol;

        if (level == SOL_SOCKET) {
                if (option == SO_RCVBUF) {
                        if (length != sizeof(int))
                                return B_BAD_VALUE;

                        status_t error = endpoint->SetReceiveBufferSize(*(int*)_value);
                        if (error != B_OK)
                                return error;
                } else if (option == SO_SNDBUF) {
                        // We don't have a receive buffer, so silently ignore this one.
                }
        }

        return gSocketModule->set_option(protocol->socket, level, option,
                _value, length);
}


status_t
unix_bind(net_protocol *_protocol, const struct sockaddr *_address)
{
        return ((UnixEndpoint*)_protocol)->Bind(_address);
}


status_t
unix_unbind(net_protocol *_protocol, struct sockaddr *_address)
{
        return ((UnixEndpoint*)_protocol)->Unbind();
}


status_t
unix_listen(net_protocol *_protocol, int count)
{
        return ((UnixEndpoint*)_protocol)->Listen(count);
}


status_t
unix_shutdown(net_protocol *_protocol, int direction)
{
        return ((UnixEndpoint*)_protocol)->Shutdown(direction);
}


status_t
unix_send_routed_data(net_protocol *_protocol, struct net_route *route,
        net_buffer *buffer)
{
        return B_ERROR;
}


status_t
unix_send_data(net_protocol *_protocol, net_buffer *buffer)
{
        return B_ERROR;
}


ssize_t
unix_send_avail(net_protocol *_protocol)
{
        return ((UnixEndpoint*)_protocol)->Sendable();
}


status_t
unix_read_data(net_protocol *_protocol, size_t numBytes, uint32 flags,
        net_buffer **_buffer)
{
        return B_ERROR;
}


ssize_t
unix_read_avail(net_protocol *_protocol)
{
        return ((UnixEndpoint*)_protocol)->Receivable();
}


struct net_domain *
unix_get_domain(net_protocol *protocol)
{
        return sDomain;
}


size_t
unix_get_mtu(net_protocol *protocol, const struct sockaddr *address)
{
        return UNIX_MAX_TRANSFER_UNIT;
}


status_t
unix_receive_data(net_buffer *buffer)
{
        return B_ERROR;
}


status_t
unix_deliver_data(net_protocol *_protocol, net_buffer *buffer)
{
        return B_ERROR;
}


status_t
unix_error_received(net_error error, net_error_data* errorData, net_buffer *data)
{
        return B_ERROR;
}


status_t
unix_error_reply(net_protocol *protocol, net_buffer *cause, net_error error,
        net_error_data *errorData)
{
        return B_ERROR;
}


status_t
unix_add_ancillary_data(net_protocol *self, ancillary_data_container *container,
        const cmsghdr *header)
{
        TRACE("[%" B_PRId32 "] unix_add_ancillary_data(%p, %p, %p (level: %d, type: %d, "
                "len: %" B_PRId32 "))\n", find_thread(NULL), self, container, header,
                header->cmsg_level, header->cmsg_type, header->cmsg_len);

        // we support only SCM_RIGHTS
        if (header->cmsg_level != SOL_SOCKET || header->cmsg_type != SCM_RIGHTS)
                return B_BAD_VALUE;

        int* fds = (int*)CMSG_DATA(header);
        int count = (header->cmsg_len - CMSG_LEN(0)) / sizeof(int);
        if (count == 0)
                return B_BAD_VALUE;

        BStackOrHeapArray<file_descriptor*, 8> descriptors(count);
        if (!descriptors.IsValid())
                return ENOBUFS;
        memset(descriptors, 0, sizeof(file_descriptor*) * count);

        // get the file descriptors
        io_context* ioContext = get_current_io_context(!gStackModule->is_syscall());

        status_t error = B_OK;
        for (int i = 0; i < count; i++) {
                descriptors[i] = get_open_fd(ioContext, fds[i]);
                if (descriptors[i] == NULL) {
                        error = EBADF;
                        break;
                }
        }

        // attach the ancillary data to the container
        if (error == B_OK) {
                ancillary_data_header header;
                header.level = SOL_SOCKET;
                header.type = SCM_RIGHTS;
                header.len = count * sizeof(file_descriptor*);

                TRACE("[%" B_PRId32 "] unix_add_ancillary_data(): adding %d FDs to "
                        "container\n", find_thread(NULL), count);

                error = gStackModule->add_ancillary_data(container, &header,
                        descriptors, destroy_scm_rights_descriptors, clone_scm_rights_descriptors, NULL);
        }

        // cleanup on error
        if (error != B_OK) {
                for (int i = 0; i < count; i++) {
                        if (descriptors[i] != NULL) {
                                close_fd(ioContext, descriptors[i]);
                                put_fd(descriptors[i]);
                        }
                }
        }

        return error;
}


ssize_t
unix_process_ancillary_data(net_protocol *self,
        const ancillary_data_container *container, void *buffer,
        size_t bufferSize, int flags)
{
        TRACE("[%" B_PRId32 "] unix_process_ancillary_data(%p, %p, %p, %p, %lu)\n",
                find_thread(NULL), self, container, buffer, bufferSize);

        int totalCount = 0;

        ancillary_data_header header;
        void* data = NULL;
        while ((data = gStackModule->next_ancillary_data(container, data, &header)) != NULL) {
                // we support only SCM_RIGHTS
                if (header.level != SOL_SOCKET || header.type != SCM_RIGHTS)
                        return B_BAD_VALUE;

                totalCount += header.len / sizeof(file_descriptor*);
        }

        // check if there's enough space in the buffer
        size_t neededBufferSpace = CMSG_SPACE(sizeof(int) * totalCount);
        if (bufferSize < neededBufferSpace)
                return B_BAD_VALUE;

        // init header
        cmsghdr* messageHeader = (cmsghdr*)buffer;
        messageHeader->cmsg_level = SOL_SOCKET;
        messageHeader->cmsg_type = SCM_RIGHTS;
        messageHeader->cmsg_len = CMSG_LEN(sizeof(int) * totalCount);

        // create FDs for the current process
        int* fds = (int*)CMSG_DATA(messageHeader);
        io_context* ioContext = get_current_io_context(!gStackModule->is_syscall());

        status_t error = B_OK;
        int i = 0;
        data = NULL;
        while ((data = gStackModule->next_ancillary_data(container, data, &header)) != NULL) {
                int count = header.len / sizeof(file_descriptor*);
                file_descriptor** descriptors = (file_descriptor**)data;

                for (int k = 0; k < count; k++, i++) {
                        // Get an additional reference which will go to the FD table index. The
                        // reference and open reference acquired in unix_add_ancillary_data()
                        // will be released when the container is destroyed.
                        inc_fd_ref_count(descriptors[k]);
                        fds[i] = new_fd(ioContext, descriptors[k]);

                        if (fds[i] < 0) {
                                error = fds[i];
                                put_fd(descriptors[k]);

                                // close FD indices
                                for (int j = i - 1; j >= 0; j--)
                                        close_fd_index(ioContext, fds[j]);
                                break;
                        }

                        WriteLocker locker(ioContext->lock);
                        if ((flags & MSG_CMSG_CLOEXEC) != 0)
                                fd_set_close_on_exec(ioContext, fds[i], true);
                        if ((flags & MSG_CMSG_CLOFORK) != 0)
                                fd_set_close_on_fork(ioContext, fds[i], true);
                }
                if (error != B_OK)
                        break;
        }

        return error == B_OK ? neededBufferSpace : error;
}


ssize_t
unix_send_data_no_buffer(net_protocol *_protocol, const iovec *vecs,
        size_t vecCount, ancillary_data_container *ancillaryData,
        const struct sockaddr *address, socklen_t addressLength, int flags)
{
        return ((UnixEndpoint*)_protocol)->Send(vecs, vecCount, ancillaryData,
                address, addressLength, flags);
}


ssize_t
unix_read_data_no_buffer(net_protocol *_protocol, const iovec *vecs,
        size_t vecCount, ancillary_data_container **_ancillaryData,
        struct sockaddr *_address, socklen_t *_addressLength, int flags)
{
        return ((UnixEndpoint*)_protocol)->Receive(vecs, vecCount, _ancillaryData,
                _address, _addressLength, flags);
}


// #pragma mark -


status_t
init_unix()
{
        new(&gAddressManager) UnixAddressManager;
        status_t error = gAddressManager.Init();
        if (error != B_OK)
                return error;

        error = gStackModule->register_domain_protocols(AF_UNIX, SOCK_STREAM, 0,
                "network/protocols/unix/v1", NULL);
        if (error == B_OK) {
                error = gStackModule->register_domain_protocols(AF_UNIX, SOCK_DGRAM, 0,
                        "network/protocols/unix/v1", NULL);
        }
        if (error == B_OK) {
                error = gStackModule->register_domain_protocols(AF_UNIX, SOCK_SEQPACKET, 0,
                        "network/protocols/unix/v1", NULL);
        }

        if (error != B_OK) {
                gAddressManager.~UnixAddressManager();
                return error;
        }

        error = gStackModule->register_domain(AF_UNIX, "unix", &gUnixModule,
                &gAddressModule, &sDomain);
        if (error != B_OK) {
                gAddressManager.~UnixAddressManager();
                return error;
        }

        return B_OK;
}


status_t
uninit_unix()
{
        gStackModule->unregister_domain(sDomain);

        gAddressManager.~UnixAddressManager();

        return B_OK;
}


static status_t
unix_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                        return init_unix();
                case B_MODULE_UNINIT:
                        return uninit_unix();

                default:
                        return B_ERROR;
        }
}


net_protocol_module_info gUnixModule = {
        {
                "network/protocols/unix/v1",
                0,
                unix_std_ops
        },
        0,      // NET_PROTOCOL_ATOMIC_MESSAGES,

        unix_init_protocol,
        unix_uninit_protocol,
        unix_open,
        unix_close,
        unix_free,
        unix_connect,
        unix_accept,
        unix_control,
        unix_getsockopt,
        unix_setsockopt,
        unix_bind,
        unix_unbind,
        unix_listen,
        unix_shutdown,
        unix_send_data,
        unix_send_routed_data,
        unix_send_avail,
        unix_read_data,
        unix_read_avail,
        unix_get_domain,
        unix_get_mtu,
        unix_receive_data,
        unix_deliver_data,
        unix_error_received,
        unix_error_reply,
        unix_add_ancillary_data,
        unix_process_ancillary_data,
        NULL,
        unix_send_data_no_buffer,
        unix_read_data_no_buffer
};

module_dependency module_dependencies[] = {
        {NET_STACK_MODULE_NAME, (module_info **)&gStackModule},
        {NET_BUFFER_MODULE_NAME, (module_info **)&gBufferModule},
//      {NET_DATALINK_MODULE_NAME, (module_info **)&sDatalinkModule},
        {NET_SOCKET_MODULE_NAME, (module_info **)&gSocketModule},
        {}
};

module_info *modules[] = {
        (module_info *)&gUnixModule,
        NULL
};