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

#include "UnixAddress.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <util/StringHash.h>

#include <net_datalink.h>
#include <NetUtilities.h>

#include "unix.h"


static const sockaddr_un kEmptyAddress = {
        4,                              // sun_len
        AF_UNIX,                // sun_family
        { '\0', '\0' }  // sun_path
};


char*
UnixAddress::ToString(char *buffer, size_t bufferSize) const
{
        if (!IsValid())
                strlcpy(buffer, "<empty>", bufferSize);
        else if (IsInternalAddress())
                snprintf(buffer, bufferSize, "<%05" B_PRIx32 ">", fInternalID);
        else {
                snprintf(buffer, bufferSize, "<%" B_PRIdDEV ", %" B_PRIdINO ">",
                        fVolumeID, fNodeID);
        }

        return buffer;
}


// #pragma mark -


static status_t
unix_copy_address(const sockaddr *from, sockaddr **to, bool replaceWithZeros,
        const sockaddr *mask)
{
        if (replaceWithZeros) {
                sockaddr_un* newAddress = (sockaddr_un*)malloc(kEmptyAddress.sun_len);
                if (newAddress == NULL)
                        return B_NO_MEMORY;

                memcpy(newAddress, &kEmptyAddress, kEmptyAddress.sun_len);

                *to = (sockaddr*)newAddress;
                return B_OK;
        } else {
                if (from->sa_family != AF_UNIX)
                        return B_MISMATCHED_VALUES;

                *to = (sockaddr*)malloc(from->sa_len);
                if (*to == NULL)
                        return B_NO_MEMORY;

                memcpy(*to, from, from->sa_len);

                return B_OK;
        }
}


static bool
unix_equal_addresses(const sockaddr *a, const sockaddr *b)
{
        // NOTE: We compare syntactically only. The real check would involve
        // looking up the node, if for FS addresses.
        if (a->sa_len != b->sa_len)
                return false;

        return memcmp(a, b, a->sa_len) == 0;
}


static bool
unix_equal_ports(const sockaddr *a, const sockaddr *b)
{
        // no ports
        return true;
}


static bool
unix_equal_addresses_and_ports(const sockaddr *a, const sockaddr *b)
{
        return unix_equal_addresses(a, b);
}


static bool
unix_equal_masked_addresses(const sockaddr *a, const sockaddr *b,
        const sockaddr *mask)
{
        // no masks
        return unix_equal_addresses(a, b);
}


static bool
unix_is_empty_address(const sockaddr *address, bool checkPort)
{
        return address == NULL || address->sa_len == 0
                || address->sa_family == AF_UNSPEC
                || (address->sa_len >= kEmptyAddress.sun_len
                        && memcmp(address, &kEmptyAddress, kEmptyAddress.sun_len) == 0);
}


static bool
unix_is_same_family(const sockaddr *address)
{
        if (address == NULL)
                return false;

        return address->sa_family == AF_UNIX;
}


static int32
unix_first_mask_bit(const sockaddr *mask)
{
        return 0;
}


static bool
unix_check_mask(const sockaddr *address)
{
        return false;
}


static status_t
unix_print_address_buffer(const sockaddr *_address, char *buffer,
        size_t bufferSize, bool printPort)
{
        if (!buffer)
                return B_BAD_VALUE;

        sockaddr_un* address = (sockaddr_un*)_address;

        if (address == NULL)
                strlcpy(buffer, "<none>", bufferSize);
        else if (address->sun_path[0] != '\0')
                strlcpy(buffer, address->sun_path, bufferSize);
        else if (address->sun_path[1] != '\0')
                snprintf(buffer, bufferSize, "<%.5s>", address->sun_path + 1);
        else
                strlcpy(buffer, "<empty>", bufferSize);

        return B_OK;
}


static status_t
unix_print_address(const sockaddr *address, char **_buffer, bool printPort)
{
        char buffer[128];
        status_t error = unix_print_address_buffer(address, buffer, sizeof(buffer),
                printPort);
        if (error != B_OK)
                return error;

        *_buffer = strdup(buffer);
        return *_buffer != NULL ? B_OK : B_NO_MEMORY;
}


static uint16
unix_get_port(const sockaddr *address)
{
        return 0;
}


static status_t
unix_set_port(sockaddr *address, uint16 port)
{
        return B_BAD_VALUE;
}


static status_t
unix_set_to(sockaddr *address, const sockaddr *from)
{
        if (address == NULL || from == NULL)
                return B_BAD_VALUE;

        if (from->sa_family != AF_UNIX)
                return B_MISMATCHED_VALUES;

        memcpy(address, from, from->sa_len);
        return B_OK;
}


static status_t
unix_set_to_empty_address(sockaddr *address)
{
        return unix_set_to(address, (sockaddr*)&kEmptyAddress);
}


static status_t
unix_mask_address(const sockaddr *address, const sockaddr *mask,
        sockaddr *result)
{
        // no masks
        return unix_set_to(result, address);
}


static status_t
unix_set_to_defaults(sockaddr *defaultMask, sockaddr *defaultBroadcast,
        const sockaddr *address, const sockaddr *netmask)
{
        if (address == NULL)
                return B_BAD_VALUE;

        status_t error = B_OK;
        if (defaultMask != NULL)
                error = unix_set_to_empty_address(defaultMask);
        if (error == B_OK && defaultBroadcast != NULL)
                error = unix_set_to_empty_address(defaultBroadcast);

        return error;
}


static status_t
unix_update_to(sockaddr *address, const sockaddr *from)
{
        if (address == NULL || from == NULL)
                return B_BAD_VALUE;

        if (unix_is_empty_address(from, false))
                return B_OK;

        return unix_set_to(address, from);
}


static uint32
unix_hash_address(const sockaddr* _address, bool includePort)
{
        sockaddr_un* address = (sockaddr_un*)_address;
        if (address == NULL)
                return 0;

        if (address->sun_path[0] == '\0') {
                char buffer[6];
                strlcpy(buffer, address->sun_path + 1, 6);
                return hash_hash_string(buffer);
        }

        return hash_hash_string(address->sun_path);
}


static uint32
unix_hash_address_pair(const sockaddr *ourAddress, const sockaddr *peerAddress)
{
        return unix_hash_address(ourAddress, false) * 17
                + unix_hash_address(peerAddress, false);
}


static status_t
unix_checksum_address(Checksum *checksum, const sockaddr *_address)
{
        if (checksum == NULL || _address == NULL)
                return B_BAD_VALUE;

        sockaddr_un* address = (sockaddr_un*)_address;
        int len = (char*)address + address->sun_len - address->sun_path;
        for (int i = 0; i < len; i++)
                (*checksum) << (uint8)address->sun_path[i];

        return B_OK;
}


net_address_module_info gAddressModule = {
        {
                NULL,
                0,
                NULL
        },
        NET_ADDRESS_MODULE_FLAG_BROADCAST_ADDRESS,
        unix_copy_address,
        unix_mask_address,
        unix_equal_addresses,
        unix_equal_ports,
        unix_equal_addresses_and_ports,
        unix_equal_masked_addresses,
        unix_is_empty_address,
        unix_is_same_family,
        unix_first_mask_bit,
        unix_check_mask,
        unix_print_address,
        unix_print_address_buffer,
        unix_get_port,
        unix_set_port,
        unix_set_to,
        unix_set_to_empty_address,
        unix_set_to_defaults,
        unix_update_to,
        unix_hash_address,
        unix_hash_address_pair,
        unix_checksum_address,
        NULL    // get_loopback_address
};