/*
 * Copyright 2023, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Augustin Cavalier <waddlesplash>
 *              Axel Dörfler, axeld@pinc-software.de
 *              Sean Brady, swangeon@gmail.com
 */

#include <new>
#include <string.h>

#include <fs/select_sync_pool.h>
#include <fs/devfs.h>
#include <util/AutoLock.h>
#include <util/Random.h>

#include <net_buffer.h>
#include <net_device.h>
#include <net_stack.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_media.h>
#include <net/if_types.h>
#include <net/if_tun.h>
#include <netinet/in.h>
#include <ethernet.h>


//#define TRACE_TUNNEL
#ifdef TRACE_TUNNEL
#       define TRACE(x...) dprintf("network/tunnel: " x)
#else
#   define TRACE(x...)
#endif

#define CALLED(x...)                    TRACE("CALLED %s\n", __PRETTY_FUNCTION__)
#define TRACE_ALWAYS(x...)              dprintf("network/tunnel: " x)


struct tunnel_device : net_device {
        bool                            is_tap;

        net_fifo                        send_queue, receive_queue;

        int32                           open_count;

        mutex                           select_lock;
        select_sync_pool*       select_pool;
};

#define TUNNEL_QUEUE_MAX (ETHER_MAX_FRAME_SIZE * 32)


struct net_buffer_module_info* gBufferModule;
static net_stack_module_info* gStackModule;


//      #pragma mark - devices array


static tunnel_device* gDevices[10] = {};
static mutex gDevicesLock = MUTEX_INITIALIZER("tunnel devices");


static tunnel_device*
find_tunnel_device(const char* name)
{
        ASSERT_LOCKED_MUTEX(&gDevicesLock);
        for (size_t i = 0; i < B_COUNT_OF(gDevices); i++) {
                if (gDevices[i] == NULL)
                        continue;

                if (strcmp(gDevices[i]->name, name) == 0)
                        return gDevices[i];
        }
        return NULL;
}


//      #pragma mark - devfs device


struct tunnel_cookie {
        tunnel_device*  device;
        uint32          flags;
};


status_t
tunnel_open(const char* name, uint32 flags, void** _cookie)
{
        MutexLocker devicesLocker(gDevicesLock);
        tunnel_device* device = find_tunnel_device(name);
        if (device == NULL)
                return ENODEV;
        if (atomic_or(&device->open_count, 1) != 0)
                return EBUSY;

        tunnel_cookie* cookie = new(std::nothrow) tunnel_cookie;
        if (cookie == NULL)
                return B_NO_MEMORY;

        cookie->device = device;
        cookie->flags = flags;

        *_cookie = cookie;
        return B_OK;
}


status_t
tunnel_close(void* _cookie)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;

        // Wake up the send queue, so that any threads waiting to read return at once.
        release_sem_etc(cookie->device->send_queue.notify, B_INTERRUPTED, B_RELEASE_ALL);

        return B_OK;
}


status_t
tunnel_free(void* _cookie)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;
        atomic_and(&cookie->device->open_count, 0);
        delete cookie;
        return B_OK;
}


status_t
tunnel_control(void* _cookie, uint32 op, void* data, size_t len)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;

        switch (op) {
                case B_SET_NONBLOCKING_IO:
                        cookie->flags |= O_NONBLOCK;
                        return B_OK;
                case B_SET_BLOCKING_IO:
                        cookie->flags &= ~O_NONBLOCK;
                        return B_OK;
        }

        return B_DEV_INVALID_IOCTL;
}


status_t
tunnel_read(void* _cookie, off_t position, void* data, size_t* _length)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;

        net_buffer* buffer = NULL;
        status_t status = gStackModule->fifo_dequeue_buffer(
                &cookie->device->send_queue, 0, B_INFINITE_TIMEOUT, &buffer);
        if (status != B_OK)
                return status;

        const size_t length = min_c(*_length, buffer->size);
        status = gBufferModule->read(buffer, 0, data, length);
        if (status != B_OK)
                return status;
        *_length = length;

        gBufferModule->free(buffer);
        return B_OK;
}


status_t
tunnel_write(void* _cookie, off_t position, const void* data, size_t* _length)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;

        net_buffer* buffer = gBufferModule->create(256);
        if (buffer == NULL)
                return B_NO_MEMORY;

        status_t status = gBufferModule->append(buffer, data, *_length);
        if (status != B_OK) {
                gBufferModule->free(buffer);
                return status;
        }

        if (!cookie->device->is_tap) {
                // TUN: Detect packet type.
                uint8 version;
                status = gBufferModule->read(buffer, 0, &version, 1);
                if (status != B_OK) {
                        gBufferModule->free(buffer);
                        return status;
                }

                version = (version & 0xF0) >> 4;
                if (version != 4 && version != 6) {
                        // Not any IP packet we recognize.
                        gBufferModule->free(buffer);
                        return B_BAD_DATA;
                }
                buffer->type = (version == 6) ? B_NET_FRAME_TYPE_IPV6
                        : B_NET_FRAME_TYPE_IPV4;

                struct sockaddr_in& src = *(struct sockaddr_in*)buffer->source;
                struct sockaddr_in& dst = *(struct sockaddr_in*)buffer->destination;
                src.sin_len             = dst.sin_len           = sizeof(sockaddr_in);
                src.sin_family  = dst.sin_family        = (version == 6) ? AF_INET6 : AF_INET;
                src.sin_port    = dst.sin_port          = 0;
                src.sin_addr.s_addr = dst.sin_addr.s_addr = 0;
        }

        // We use a queue and the receive_data() hook instead of device_enqueue_buffer()
        // for two reasons: 1. listeners (e.g. packet capture) are only processed by the
        // reader thread that calls receive_data(), and 2. device_enqueue_buffer() has
        // to look up the device interface every time, which is inefficient.
        status = gStackModule->fifo_enqueue_buffer(&cookie->device->receive_queue, buffer);
        if (status != B_OK)
                gBufferModule->free(buffer);

        return status;
}


status_t
tunnel_select(void* _cookie, uint8 event, uint32 ref, selectsync* sync)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;

        if (event != B_SELECT_READ && event != B_SELECT_WRITE)
                return B_BAD_VALUE;

        MutexLocker selectLocker(cookie->device->select_lock);
        status_t status = add_select_sync_pool_entry(&cookie->device->select_pool, sync, event);
        if (status != B_OK)
                return B_BAD_VALUE;
        selectLocker.Unlock();

        MutexLocker fifoLocker(cookie->device->send_queue.lock);
        if (event == B_SELECT_READ && cookie->device->send_queue.current_bytes != 0)
                notify_select_event(sync, event);
        if (event == B_SELECT_WRITE)
                notify_select_event(sync, event);

        return B_OK;
}


status_t
tunnel_deselect(void* _cookie, uint8 event, selectsync* sync)
{
        tunnel_cookie* cookie = (tunnel_cookie*)_cookie;

        MutexLocker selectLocker(cookie->device->select_lock);
        if (event != B_SELECT_READ && event != B_SELECT_WRITE)
                return B_BAD_VALUE;
        return remove_select_sync_pool_entry(&cookie->device->select_pool, sync, event);
}


static device_hooks sDeviceHooks = {
        tunnel_open,
        tunnel_close,
        tunnel_free,
        tunnel_control,
        tunnel_read,
        tunnel_write,
        tunnel_select,
        tunnel_deselect,
};


//      #pragma mark - network stack device


status_t
tunnel_init(const char* name, net_device** _device)
{
        const bool isTAP = strncmp(name, "tap/", 4) == 0;
        if (!isTAP && strncmp(name, "tun/", 4) != 0)
                return B_BAD_VALUE;
        if (strlen(name) >= sizeof(tunnel_device::name))
                return ENAMETOOLONG;

        // Make sure this device doesn't already exist.
        MutexLocker devicesLocker(gDevicesLock);
        if (find_tunnel_device(name) != NULL)
                return EEXIST;

        tunnel_device* device = new(std::nothrow) tunnel_device;
        if (device == NULL)
                return B_NO_MEMORY;

        ssize_t index = -1;
        for (size_t i = 0; i < B_COUNT_OF(gDevices); i++) {
                if (gDevices[i] != NULL)
                        continue;

                gDevices[i] = device;
                index = i;
                break;
        }
        if (index < 0) {
                delete device;
                return ENOSPC;
        }
        devicesLocker.Unlock();

        memset(device, 0, sizeof(tunnel_device));
        strcpy(device->name, name);

        device->mtu = ETHER_MAX_FRAME_SIZE;
        device->media = IFM_ACTIVE;

        device->is_tap = isTAP;
        if (device->is_tap) {
                device->flags = IFF_BROADCAST | IFF_ALLMULTI | IFF_LINK;
                device->type = IFT_ETHER;

                // Generate a random MAC address.
                for (int i = 0; i < ETHER_ADDRESS_LENGTH; i++)
                        device->address.data[i] = secure_get_random<uint8>();
                device->address.data[0] &= 0xFE; // multicast
                device->address.data[0] |= 0x02; // local assignment

                device->address.length = ETHER_ADDRESS_LENGTH;
        } else {
                device->flags = IFF_POINTOPOINT | IFF_LINK;
                device->type = IFT_TUNNEL;
        }

        status_t status = gStackModule->init_fifo(&device->send_queue,
                "tunnel send queue", TUNNEL_QUEUE_MAX);
        if (status != B_OK) {
                delete device;
                return status;
        }

        status = gStackModule->init_fifo(&device->receive_queue,
                "tunnel receive queue", TUNNEL_QUEUE_MAX);
        if (status != B_OK) {
                gStackModule->uninit_fifo(&device->send_queue);
                delete device;
                return status;
        }

        mutex_init(&device->select_lock, "tunnel select lock");

        status = devfs_publish_device(name, &sDeviceHooks);
        if (status != B_OK) {
                gStackModule->uninit_fifo(&device->send_queue);
                gStackModule->uninit_fifo(&device->receive_queue);
                delete device;
                return status;
        }

        *_device = device;
        return B_OK;
}


status_t
tunnel_uninit(net_device* _device)
{
        tunnel_device* device = (tunnel_device*)_device;

        MutexLocker devicesLocker(gDevicesLock);
        if (atomic_get(&device->open_count) != 0)
                return EBUSY;

        for (size_t i = 0; i < B_COUNT_OF(gDevices); i++) {
                if (gDevices[i] != device)
                        continue;

                gDevices[i] = NULL;
                break;
        }
        status_t status = devfs_unpublish_device(device->name, false);
        if (status != B_OK)
                panic("devfs_unpublish_device failed: %" B_PRId32, status);

        gStackModule->uninit_fifo(&device->send_queue);
        gStackModule->uninit_fifo(&device->receive_queue);
        mutex_destroy(&device->select_lock);
        delete device;
        return B_OK;
}


status_t
tunnel_up(net_device* _device)
{
        return B_OK;
}


void
tunnel_down(net_device* _device)
{
        tunnel_device* device = (tunnel_device*)_device;

        // Wake up the receive queue, so that the reader thread returns at once.
        release_sem_etc(device->receive_queue.notify, B_INTERRUPTED, B_RELEASE_ALL);
}


status_t
tunnel_control(net_device* device, int32 op, void* argument, size_t length)
{
        return B_BAD_VALUE;
}


status_t
tunnel_send_data(net_device* _device, net_buffer* buffer)
{
        tunnel_device* device = (tunnel_device*)_device;

        status_t status = B_OK;
        if (!device->is_tap) {
                // Ensure this is an IP frame.
                struct sockaddr_in& dst = *(struct sockaddr_in*)buffer->destination;
                if (dst.sin_family != AF_INET && dst.sin_family != AF_INET6)
                        return B_BAD_DATA;
        }

        status = gStackModule->fifo_enqueue_buffer(
                &device->send_queue, buffer);
        if (status == B_OK) {
                MutexLocker selectLocker(device->select_lock);
                notify_select_event_pool(device->select_pool, B_SELECT_READ);
        }

        return status;
}


status_t
tunnel_receive_data(net_device* _device, net_buffer** _buffer)
{
        tunnel_device* device = (tunnel_device*)_device;
        return gStackModule->fifo_dequeue_buffer(&device->receive_queue,
                0, B_INFINITE_TIMEOUT, _buffer);
}


status_t
tunnel_set_mtu(net_device* device, size_t mtu)
{
        if (mtu > 65536 || mtu < 16)
                return B_BAD_VALUE;

        device->mtu = mtu;
        return B_OK;
}


status_t
tunnel_set_promiscuous(net_device* device, bool promiscuous)
{
        return EOPNOTSUPP;
}


status_t
tunnel_set_media(net_device* device, uint32 media)
{
        return EOPNOTSUPP;
}


status_t
tunnel_add_multicast(net_device* device, const sockaddr* address)
{
        return B_OK;
}


status_t
tunnel_remove_multicast(net_device* device, const sockaddr* address)
{
        return B_OK;
}


net_device_module_info sTunModule = {
        {
                "network/devices/tunnel/v1",
                0,
                NULL
        },
        tunnel_init,
        tunnel_uninit,
        tunnel_up,
        tunnel_down,
        tunnel_control,
        tunnel_send_data,
        tunnel_receive_data,
        tunnel_set_mtu,
        tunnel_set_promiscuous,
        tunnel_set_media,
        tunnel_add_multicast,
        tunnel_remove_multicast,
};

module_dependency module_dependencies[] = {
        {NET_STACK_MODULE_NAME, (module_info**)&gStackModule},
        {NET_BUFFER_MODULE_NAME, (module_info**)&gBufferModule},
        {}
};

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