/*
 *  Copyright (c) 2016, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#include "precomp.h"
#include "address.tmh"

_IRQL_requires_max_(PASSIVE_LEVEL)
BOOLEAN 
otLwfOnAddressAdded(
    _In_ PMS_FILTER pFilter, 
    _In_ const otNetifAddress* Addr,
    _In_ BOOLEAN UpdateWindows
    )
{
    if (pFilter->otCachedAddrCount >= OT_MAX_ADDRESSES)
    {
        LogError(DRIVER_DEFAULT, "Failing to add new address as we have reached our max!");
        return FALSE;
    }

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! adding address: %!IPV6ADDR! (%u-bit prefix)", 
        &pFilter->InterfaceGuid, 
        (PIN6_ADDR)&Addr->mAddress,
        Addr->mPrefixLength
        );

    // Update local cache
    memcpy(pFilter->otCachedAddr + pFilter->otCachedAddrCount, Addr, sizeof(IN6_ADDR));
    pFilter->otCachedAddrCount++;

    // If this is link local, cache it as our link local address
    if (IN6_IS_ADDR_LINKLOCAL((PIN6_ADDR)&Addr->mAddress))
    {
        memcpy(&pFilter->otLinkLocalAddr, Addr, sizeof(IN6_ADDR));
    }
        
    // Update Windows if necessary
    if (UpdateWindows)
    {
        NTSTATUS status;
        MIB_UNICASTIPADDRESS_ROW newRow;
        MIB_IPFORWARD_ROW2 newRouteRow;
        COMPARTMENT_ID OriginalCompartmentID;
        InitializeUnicastIpAddressEntry(&newRow);
        InitializeIpForwardEntry(&newRouteRow); 

        newRow.InterfaceIndex = pFilter->InterfaceIndex;
        newRow.InterfaceLuid = pFilter->InterfaceLuid;
        newRow.Address.si_family = AF_INET6;
        newRow.Address.Ipv6.sin6_family = AF_INET6;
        
        static_assert(sizeof(IN6_ADDR) == sizeof(otIp6Address), "Windows and OpenThread IPv6 Addr Structs must be same size");

        memcpy(&newRow.Address.Ipv6.sin6_addr, &Addr->mAddress, sizeof(IN6_ADDR));
        newRow.OnLinkPrefixLength = Addr->mPrefixLength;
        newRow.PreferredLifetime = Addr->mPreferred ? 0xffffffff : 0;
        newRow.ValidLifetime = Addr->mValid ? 0xffffffff : 0;
        newRow.PrefixOrigin = IpPrefixOriginOther;  // Derived from network XPANID
        newRow.SkipAsSource = FALSE;                // Allow automatic binding to this address (default)

        if (IN6_IS_ADDR_LINKLOCAL(&newRow.Address.Ipv6.sin6_addr))
        {
            newRow.SuffixOrigin = IpSuffixOriginLinkLayerAddress;   // Derived from Extended MAC address
        }
        else
        {
            newRow.SuffixOrigin = IpSuffixOriginRandom;             // Was created randomly
        }

        // Make sure we are in the right compartment
        (VOID)otLwfSetCompartment(pFilter, &OriginalCompartmentID);

        status = CreateUnicastIpAddressEntry(&newRow);
        //NT_ASSERT(NT_SUCCESS(status));
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "CreateUnicastIpAddressEntry failed %!STATUS!", status);
        }

        newRouteRow.InterfaceIndex = pFilter->InterfaceIndex;
        newRouteRow.InterfaceLuid = pFilter->InterfaceLuid;
        newRouteRow.DestinationPrefix.Prefix.si_family = AF_INET6;
        newRouteRow.DestinationPrefix.PrefixLength = 0;

        status = CreateIpForwardEntry2(&newRouteRow);
        if (!NT_SUCCESS(status) && status != STATUS_DUPLICATE_OBJECTID)
        {
            LogVerbose(DRIVER_DEFAULT, "CreateIpForwardEntry2 failed %!STATUS!", status);
        }

        // Revert back to original compartment
        otLwfRevertCompartment(OriginalCompartmentID);
    }

    return TRUE;
}

_IRQL_requires_max_(PASSIVE_LEVEL)
VOID 
otLwfOnAddressRemoved(
    _In_ PMS_FILTER pFilter, 
    _In_ ULONG CachedIndex,
    _In_ BOOLEAN UpdateWindows
    )
{
    // Cache address before we delete local cache
    IN6_ADDR Addr = pFilter->otCachedAddr[CachedIndex];

    LogInfo(DRIVER_DEFAULT, "Interface %!GUID! removing address: %!IPV6ADDR!", &pFilter->InterfaceGuid, &Addr);
    
    NT_ASSERT(pFilter->otCachedAddrCount != 0);
    NT_ASSERT(CachedIndex < pFilter->otCachedAddrCount);

    // Remove the cached entry
    if (CachedIndex + 1 != pFilter->otCachedAddrCount)
        memmove(pFilter->otCachedAddr + CachedIndex, 
                pFilter->otCachedAddr + CachedIndex + 1, 
                (pFilter->otCachedAddrCount - CachedIndex - 1) * sizeof(IN6_ADDR)
                );
    pFilter->otCachedAddrCount--;

    // Update Windows if necessary
    if (UpdateWindows)
    {
        MIB_UNICASTIPADDRESS_ROW deleteRow;
        COMPARTMENT_ID OriginalCompartmentID;
        InitializeUnicastIpAddressEntry(&deleteRow);

        deleteRow.InterfaceIndex = pFilter->InterfaceIndex;
        deleteRow.InterfaceLuid = pFilter->InterfaceLuid;
        deleteRow.Address.si_family = AF_INET6;

        deleteRow.Address.Ipv6.sin6_addr = Addr;

        // Make sure we are in the right compartment
        (VOID)otLwfSetCompartment(pFilter, &OriginalCompartmentID);
    
        // Best effort remove address from TCPIP
        (VOID)DeleteUnicastIpAddressEntry(&deleteRow);

        // Revert back to original compartment
        otLwfRevertCompartment(OriginalCompartmentID);
    }
}

int 
otLwfFindCachedAddrIndex(
    _In_ PMS_FILTER pFilter, 
    _In_ PIN6_ADDR addr
    )
{
    for (ULONG i = 0; i < pFilter->otCachedAddrCount; i++)
        if (memcmp(pFilter->otCachedAddr + i, addr, sizeof(IN6_ADDR)) == 0)
            return (int)i;
    return -1;
}

_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS 
otLwfInitializeAddresses(
    _In_ PMS_FILTER pFilter
    )
{
    NTSTATUS                    status = STATUS_SUCCESS;
    
    PMIB_UNICASTIPADDRESS_TABLE pMibUnicastAddressTable = NULL;
    COMPARTMENT_ID              OriginalCompartmentID;

    LogFuncEntry(DRIVER_DEFAULT);
    
    pFilter->otCachedAddrCount = 0;

    // Make sure we are in the right compartment
    (VOID)otLwfSetCompartment(pFilter, &OriginalCompartmentID);

    // Query the table for the current compartment
    status = GetUnicastIpAddressTable(AF_INET6, &pMibUnicastAddressTable);

    // Revert the compartment, now that we have the table
    otLwfRevertCompartment(OriginalCompartmentID);

    if (!NT_SUCCESS(status))
    {
        LogError(DRIVER_DEFAULT, "GetUnicastIpAddressTable failed, %!STATUS!", status);
        goto error;
    }
    
    // Iterate through the addresses and delete (best effort) the ones for our interface
    for (ULONG Index = 0; Index < pMibUnicastAddressTable->NumEntries; Index++)
    {
        MIB_UNICASTIPADDRESS_ROW* row = &pMibUnicastAddressTable->Table[Index];

        if ((0 == memcmp(&row->InterfaceLuid, &pFilter->InterfaceLuid, sizeof(NET_LUID))))
        {
            LogInfo(DRIVER_DEFAULT, "Caching initial address: %!IPV6ADDR!", &row->Address.Ipv6.sin6_addr);
            memcpy(pFilter->otCachedAddr + pFilter->otCachedAddrCount, &row->Address.Ipv6.sin6_addr, sizeof(IN6_ADDR));
            pFilter->otCachedAddrCount++;
        }
    }

error:
    
    if (NULL != pMibUnicastAddressTable)
    {
        FreeMibTable(pMibUnicastAddressTable);
    }

    LogFuncExitNT(DRIVER_DEFAULT, status);

    return status;
}

// Callback from Windows TCPIP stack when an address change occurs
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID
NETIOAPI_API_ 
otLwfAddressChangeCallback(
    _In_ PVOID CallerContext,
    _In_opt_ PMIB_UNICASTIPADDRESS_ROW Row,
    _In_ MIB_NOTIFICATION_TYPE NotificationType
    )
{
    PMS_FILTER pFilter = (PMS_FILTER)CallerContext;
    if (Row == NULL || pFilter == NULL) return;

    // Ignore notifications that aren't for our interface
    if (Row->InterfaceIndex != pFilter->InterfaceIndex) return;

    LogFuncEntryMsg(DRIVER_DEFAULT, "%p (%u) %!IPV6ADDR!", pFilter, NotificationType, &Row->Address.Ipv6.sin6_addr);

    // Since we don't pass in the initial flag, we shouldn't get this type
    NT_ASSERT(NotificationType != MibInitialNotification);

    // Make sure we can reference the interface
    if (ExAcquireRundownProtection(&pFilter->ExternalRefs))
    {
        if (pFilter->DeviceStatus == OTLWF_DEVICE_STATUS_RADIO_MODE)
        {
            // Queue up the event for processing
            otLwfEventProcessingIndicateAddressChange(
                pFilter,
                NotificationType,
                &Row->Address.Ipv6.sin6_addr
                );
        }
        else
        {
            NT_ASSERT(FALSE); // Need to add support for this in tunnel mode
        }

        // Release reference on the interface
        ExReleaseRundownProtection(&pFilter->ExternalRefs);
    }

    LogFuncExit(DRIVER_DEFAULT);
}

// Callback on the OpenThread thread for processing an address change
_IRQL_requires_max_(PASSIVE_LEVEL)
VOID
otLwfEventProcessingAddressChanged(
    _In_ PMS_FILTER             pFilter,
    _In_ MIB_NOTIFICATION_TYPE  NotificationType,
    _In_ PIN6_ADDR              pAddr
    )
{
    LogFuncEntryMsg(DRIVER_DEFAULT, "%p (%u)", pFilter, NotificationType);

    if (NotificationType == MibAddInstance ||
        NotificationType == MibParameterNotification)
    {
        MIB_UNICASTIPADDRESS_ROW Row;
        InitializeUnicastIpAddressEntry(&Row);

        Row.Address.si_family = AF_INET6;
        Row.Address.Ipv6.sin6_addr = *pAddr;
        Row.InterfaceIndex = pFilter->InterfaceIndex;
        Row.InterfaceLuid = pFilter->InterfaceLuid;

        NTSTATUS status = GetUnicastIpAddressEntry(&Row);
        if (!NT_SUCCESS(status))
        {
            LogError(DRIVER_DEFAULT, "GetUnicastIpAddressEntry failed, %!STATUS!", status);
        }
        else
        {
            otNetifAddress otAddr = {0};
            memcpy(&otAddr.mAddress, pAddr, sizeof(IN6_ADDR));
            otAddr.mPreferred = Row.PreferredLifetime != 0;
            otAddr.mPrefixLength = Row.OnLinkPrefixLength;
            otAddr.mValid = Row.ValidLifetime != 0;

            BOOLEAN ShouldDelete = FALSE;
            BOOLEAN AddedToCache = FALSE;
            BOOLEAN IsCached = otLwfFindCachedAddrIndex(pFilter, pAddr) != -1;

            // Ignore link local addresses
            if (IN6_IS_ADDR_LINKLOCAL(pAddr) && !IsCached)
            {
                ShouldDelete = TRUE;
                goto add_complete;
            }

            // Add to the cache if this is a new address
            if (NotificationType == MibAddInstance && !IsCached)
            {
                AddedToCache = otLwfOnAddressAdded(pFilter, &otAddr, FALSE);
                if (AddedToCache == FALSE)
                {
                    ShouldDelete = TRUE;
                    goto add_complete;
                }
            }

            // Update OpenThread if we don't have this cached or it is being updated
            if (!IsCached/* || NotificationType == MibParameterNotification*/)
            {
                LogInfo(DRIVER_DEFAULT, "Filter %p trying to add/update address: %!IPV6ADDR!", pFilter, pAddr);

                // Add (or update) the address to OpenThread
                otError otError = otIp6AddUnicastAddress(pFilter->otCtx, &otAddr);
                if (otError != OT_ERROR_NONE)
                {
                    LogError(DRIVER_DEFAULT, "otIp6AddUnicastAddress failed, %!otError!", otError);
                    ShouldDelete = otError == OT_ERROR_NO_BUFS ? TRUE : FALSE;
                }
            }

        add_complete:

            // Remove it from TCPIP if necessary
            if (ShouldDelete)
            {
                LogInfo(DRIVER_DEFAULT, "Filter %p deleting recently added address: %!IPV6ADDR!", pFilter, pAddr);

                // Best effort remove address from TCPIP
                (VOID)DeleteUnicastIpAddressEntry(&Row);
            }
        }
    }
    else if (NotificationType == MibDeleteInstance)
    {
        // Look for the address in our cache
        int index = otLwfFindCachedAddrIndex(pFilter, pAddr);

        // If it's not already deleted from our cache, then Windows
        // is deleting the adddress and we need to update OpenThread.
        if (index != -1)
        {
            // Update our cache
            otLwfOnAddressRemoved(pFilter, (ULONG)index, FALSE);
            
            LogInfo(DRIVER_DEFAULT, "Filter %p trying to remove address: %!IPV6ADDR!", pFilter, pAddr);

            // Find the correct address from OpenThread to remove (best effort)
            (void)otIp6RemoveUnicastAddress(pFilter->otCtx, (otIp6Address*)pAddr);
        }
    }

    LogFuncExit(DRIVER_DEFAULT);
}

_IRQL_requires_max_(PASSIVE_LEVEL)
VOID 
otLwfRadioAddressesUpdated(
    _In_ PMS_FILTER pFilter
    )
{
    LogFuncEntry(DRIVER_DEFAULT);

    ULONG FoundInOpenThread = 0; // Bit field
    ULONG OriginalCacheLength = pFilter->otCachedAddrCount;
    
    NT_ASSERT(pFilter->DeviceStatus == OTLWF_DEVICE_STATUS_RADIO_MODE);

    const otNetifAddress* addr = otIp6GetUnicastAddresses(pFilter->otCtx);

    // Process the addresses
    while (addr)
    {
        int index = otLwfFindCachedAddrIndex(pFilter, (PIN6_ADDR)&addr->mAddress);
        if (index == -1)
        {
            otLwfOnAddressAdded(pFilter, addr, TRUE);
        }
        else
        {
            NT_ASSERT(index < 8 * sizeof(FoundInOpenThread));
            FoundInOpenThread |= 1 << index;
        }
        addr = addr->mNext;
    }

    // Look for missing addresses and mark them as removed
    for (int i = OriginalCacheLength - 1; i >= 0; i--)
    {
        if ((FoundInOpenThread & (1 << i)) == 0)
        {
            otLwfOnAddressRemoved(pFilter, (ULONG)i, TRUE);
        }
    }
    
    LogFuncExit(DRIVER_DEFAULT);
}

_IRQL_requires_max_(PASSIVE_LEVEL)
VOID 
otLwfTunAddressesUpdated(
    _In_ PMS_FILTER pFilter,
    _In_reads_bytes_(value_data_len) const uint8_t* value_data_ptr,
    _In_ spinel_size_t value_data_len,
    _Out_ uint32_t *aNotifFlags
    )
{
    ULONG FoundInOpenThread = 0; // Bit field
    ULONG OriginalCacheLength = pFilter->otCachedAddrCount;

    LogFuncEntry(DRIVER_DEFAULT);
    
    NT_ASSERT (pFilter->DeviceStatus == OTLWF_DEVICE_STATUS_THREAD_MODE);

    *aNotifFlags = 0;

    while (value_data_len > 0)
    {
        const uint8_t *entry_ptr = NULL;
        spinel_size_t entry_len = 0;

        spinel_ssize_t len = spinel_datatype_unpack(value_data_ptr, value_data_len, "d", &entry_ptr, &entry_len);
        if (len < 1) break;

        {
            PIN6_ADDR pAddr = NULL;
            otNetifAddress addr = { { 0 }, 0, 1, 1, 0, 0, 0, NULL };
            uint32_t preferredLifetime = 0xFFFFFFFF;
            uint32_t validLifetime = 0xFFFFFFFF;

            spinel_datatype_unpack(
                entry_ptr, 
                entry_len, 
                "6CLL", 
                &pAddr, 
                &addr.mPrefixLength, 
                &validLifetime,
                &preferredLifetime);

            addr.mPreferred = preferredLifetime != 0;
            addr.mValid = validLifetime != 0;

            if (pAddr)
            {
                int index = otLwfFindCachedAddrIndex(pFilter, pAddr);
                if (index == -1)
                {
                    memcpy_s(&addr.mAddress, sizeof(addr.mAddress), pAddr, sizeof(IN6_ADDR));
                    otLwfOnAddressAdded(pFilter, &addr, TRUE);
                    *aNotifFlags |= OT_CHANGED_IP6_ADDRESS_ADDED;
                }
                else
                {
                    NT_ASSERT(index < 8 * sizeof(FoundInOpenThread));
                    FoundInOpenThread |= 1 << index;
                }
            }
        }

        value_data_len -= len;
        value_data_ptr += len;
    }

    // Look for missing addresses and mark them as removed
    for (int i = OriginalCacheLength - 1; i >= 0; i--)
    {
        if ((FoundInOpenThread & (1 << i)) == 0)
        {
            otLwfOnAddressRemoved(pFilter, (ULONG)i, TRUE);
            *aNotifFlags |= OT_CHANGED_IP6_ADDRESS_REMOVED;
        }
    }
    
    LogFuncExit(DRIVER_DEFAULT);
}