/*
 * FreeRTOS+TCP <DEVELOPMENT BRANCH>
 * Copyright (C) 2022 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * http://aws.amazon.com/freertos
 * http://www.FreeRTOS.org
 */

/**
 * @file FreeRTOS_IPv6_Sockets.c
 * @brief Implements the Sockets API based on Berkeley sockets for the FreeRTOS+TCP network stack.
 *        Sockets are used by the application processes to interact with the IP-task which in turn
 *        interacts with the hardware.
 */

/* Standard includes. */
#include <stdint.h>
#include <stdio.h>

/* FreeRTOS includes. */
#include "FreeRTOS.h"

/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_IPv6_Sockets.h"

/* *INDENT-OFF* */
#if( ipconfigUSE_IPv6 != 0 )
/* *INDENT-ON* */

#if ( ipconfigUSE_TCP == 1 )

/**
 * @brief Called by pxTCPSocketLookup(), this function will check if a socket
 *        is connected to a remote IP-address. It will be called from a loop
 *        iterating through all sockets.
 * @param[in] pxSocket The socket to be inspected.
 * @param[in] pxAddress The IPv4/IPv6 address.
 * @return The socket in case it is connected to the remote IP-address.
 */
    FreeRTOS_Socket_t * pxTCPSocketLookup_IPv6( FreeRTOS_Socket_t * pxSocket,
                                                const IPv46_Address_t * pxAddress )
    {
        FreeRTOS_Socket_t * pxResult = NULL;

        if( ( pxSocket != NULL ) && ( pxAddress != NULL ) )
        {
            if( pxSocket->bits.bIsIPv6 != pdFALSE_UNSIGNED )
            {
                if( pxAddress->xIs_IPv6 != pdFALSE )
                {
                    if( memcmp( pxSocket->u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, pxAddress->xIPAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) == 0 )
                    {
                        /* For sockets not in listening mode, find a match with
                         * uxLocalPort, ulRemoteIP AND uxRemotePort. */
                        pxResult = pxSocket;
                    }
                }
            }
            else
            {
                if( pxAddress->xIs_IPv6 == pdFALSE )
                {
                    if( pxSocket->u.xTCP.xRemoteIP.ulIP_IPv4 == pxAddress->xIPAddress.ulIP_IPv4 )
                    {
                        /* For sockets not in listening mode, find a match with
                         * uxLocalPort, ulRemoteIP AND uxRemotePort. */
                        pxResult = pxSocket;
                    }
                }
            }
        }

        return pxResult;
    }

#endif /* if ( ( ipconfigUSE_TCP == 1 ) */

/**
 * @brief Called by prvSendUDPPacket(), this function will UDP packet
 *        fields and IPv6 address for the packet to be send.
 * @param[in] pxNetworkBuffer  The packet to be sent.
 * @param[in] pxDestinationAddress The IPv4 socket address.
 * @return  Returns NULL, always.
 */
void * xSend_UDP_Update_IPv6( NetworkBufferDescriptor_t * pxNetworkBuffer,
                              const struct freertos_sockaddr * pxDestinationAddress )
{
    /* MISRA Ref 11.3.1 [Misaligned access] */
    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
    /* coverity[misra_c_2012_rule_11_3_violation] */
    UDPPacket_IPv6_t * pxUDPPacket_IPv6 = ( ( UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );

    pxNetworkBuffer->xIPAddress.ulIP_IPv4 = 0U;

    configASSERT( pxDestinationAddress != NULL );
    ( void ) memcpy( pxUDPPacket_IPv6->xIPHeader.xDestinationAddress.ucBytes, pxDestinationAddress->sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
    ( void ) memcpy( pxNetworkBuffer->xIPAddress.xIP_IPv6.ucBytes, pxDestinationAddress->sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
    pxUDPPacket_IPv6->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;

    return NULL;
}

/**
 * @brief Called by FreeRTOS_recvfrom(), this function will update socket
 *        address with IPv6 address from the packet received.
 * @param[in] pxNetworkBuffer  The packet received.
 * @param[in] pxSourceAddress The IPv4 socket address.
 * @return The Payload Offset.
 */
size_t xRecv_Update_IPv6( const NetworkBufferDescriptor_t * pxNetworkBuffer,
                          struct freertos_sockaddr * pxSourceAddress )
{
    /* MISRA Ref 11.3.1 [Misaligned access] */
    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
    /* coverity[misra_c_2012_rule_11_3_violation] */
    const UDPPacket_IPv6_t * pxUDPPacketV6 = ( ( const UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
    size_t uxPayloadOffset = 0;

    if( pxUDPPacketV6->xEthernetHeader.usFrameType == ipIPv6_FRAME_TYPE )
    {
        if( pxSourceAddress != NULL )
        {
            ( void ) memcpy( ( void * ) pxSourceAddress->sin_address.xIP_IPv6.ucBytes,
                             ( const void * ) pxUDPPacketV6->xIPHeader.xSourceAddress.ucBytes,
                             ipSIZE_OF_IPv6_ADDRESS );
            pxSourceAddress->sin_family = ( uint8_t ) FREERTOS_AF_INET6;
            pxSourceAddress->sin_port = pxNetworkBuffer->usPort;
        }

        uxPayloadOffset = ipUDP_PAYLOAD_OFFSET_IPv6;
    }

    return uxPayloadOffset;
}


/**
 * @brief Converts a 4 bit (nibble) value to a readable hex character, e.g. 14 becomes 'e'.
 * @param usValue  The value to be converted, must be between 0 and 15.
 * @return The character, between '0' and '9', or between 'a' and 'f'.
 */
char cHexToChar( uint16_t usValue )
{
    char cReturn = '0';

    if( usValue <= 9U )
    {
        cReturn = ( char ) ( cReturn + usValue );
    }
    else if( usValue <= 15U )
    {
        cReturn = 'a';
        cReturn = ( char ) ( cReturn + ( usValue - ( uint16_t ) 10 ) );
    }
    else
    {
        /* The value passed to 'usValue' has been and-ed with 0x0f,
         * so this else clause should never be reached. */
        configASSERT( 0 == 1 );
    }

    return cReturn;
}

/*-----------------------------------------------------------*/

/**
 * @brief Convert a short numeric value to a hex string of at most 4 characters.
 *        The resulting string is **not** null-terminated. The resulting string
 *        will not have leading zero's, except when 'usValue' equals zero.
 * @param[in] pcBuffer  The buffer to which the string is written.
 * @param[in] uxBufferSize  The size of the buffer pointed to by 'pcBuffer'.
 * @param[in] usValue  The 16-bit value to be converted.
 * @return The number of bytes written to 'pcBuffer'.
 */
socklen_t uxHexPrintShort( char * pcBuffer,
                           size_t uxBufferSize,
                           uint16_t usValue )
{
    const size_t uxNibbleCount = 4U;
    size_t uxNibble;
    socklen_t uxIndex = 0U;
    uint16_t usShifter = usValue;
    BaseType_t xHadNonZero = pdFALSE;

    for( uxNibble = 0; uxNibble < uxNibbleCount; uxNibble++ )
    {
        uint16_t usNibble = ( usShifter >> 12 ) & 0x0FU;

        if( usNibble != 0U )
        {
            xHadNonZero = pdTRUE;
        }

        if( ( xHadNonZero != pdFALSE ) || ( uxNibble == ( uxNibbleCount - 1U ) ) )
        {
            if( uxIndex >= ( uxBufferSize - 1U ) )
            {
                break;
            }

            pcBuffer[ uxIndex ] = cHexToChar( usNibble );
            uxIndex++;
        }

        usShifter = ( uint16_t ) ( usShifter << 4 );
    }

    return uxIndex;
}
/*-----------------------------------------------------------*/

/**
 * @brief Scan the binary IPv6 address and find the longest train of consecutive zero's.
 *        The result of this search will be stored in 'xZeroStart' and 'xZeroLength'.
 * @param pxSet the set of parameters as used by FreeRTOS_inet_ntop6().
 */
void prv_ntop6_search_zeros( struct sNTOP6_Set * pxSet )
{
    BaseType_t xIndex = 0;            /* The index in the IPv6 address: 0..7. */
    BaseType_t xCurStart = 0;         /* The position of the first zero found so far. */
    BaseType_t xCurLength = 0;        /* The number of zero's seen so far. */
    const BaseType_t xShortCount = 8; /* An IPv6 address consists of 8 shorts. */

    /* Default: when xZeroStart is negative, it won't match with any xIndex. */
    pxSet->xZeroStart = -1;

    /* Look for the longest train of zero's 0:0:0:... */
    for( ; xIndex < xShortCount; xIndex++ )
    {
        uint16_t usValue = pxSet->pusAddress[ xIndex ];

        if( usValue == 0U )
        {
            if( xCurLength == 0 )
            {
                /* Remember the position of the first zero. */
                xCurStart = xIndex;
            }

            /* Count consecutive zeros. */
            xCurLength++;
        }

        if( ( usValue != 0U ) || ( xIndex == ( xShortCount - 1 ) ) )
        {
            /* Has a longer train of zero's been found? */
            if( ( xCurLength > 1 ) && ( pxSet->xZeroLength < xCurLength ) )
            {
                /* Remember the number of consecutive zeros. */
                pxSet->xZeroLength = xCurLength;
                /* Remember the index of the first zero found. */
                pxSet->xZeroStart = xCurStart;
            }

            /* Reset the counter of consecutive zeros. */
            xCurLength = 0;
        }
    }
}
/*-----------------------------------------------------------*/

/**
 * @brief The location is now at the longest train of zero's. Two colons have to
 *        be printed without a numeric value, e.g. "ff02::1".
 * @param pcDestination the output buffer where the colons will be printed.
 * @param uxSize the remaining length of the output buffer.
 * @param pxSet the set of parameters as used by FreeRTOS_inet_ntop6().
 * @return pdPASS in case the output buffer is big enough to contain the colons.
 * @note uxSize must be at least 2, enough to print "::". The string will get
 *       null-terminated later on.
 */
static BaseType_t prv_ntop6_write_zeros( char * pcDestination,
                                         size_t uxSize,
                                         struct sNTOP6_Set * pxSet )
{
    BaseType_t xReturn = pdPASS;
    const BaseType_t xShortCount = 8; /* An IPv6 address consists of 8 shorts. */

    if( pxSet->uxTargetIndex <= ( uxSize - 1U ) )
    {
        pcDestination[ pxSet->uxTargetIndex ] = ':';
        pxSet->uxTargetIndex++;

        if( ( pxSet->xIndex + pxSet->xZeroLength ) == xShortCount )
        {
            /* Reached the last index, write a second ":". */
            if( pxSet->uxTargetIndex <= ( uxSize - 1U ) )
            {
                pcDestination[ pxSet->uxTargetIndex ] = ':';
                pxSet->uxTargetIndex++;
            }
            else
            {
                /* Can not write the second colon. */
                xReturn = pdFAIL;
            }
        }
        else
        {
            /* Otherwise the function prv_ntop6_write_short() will places the second colon. */
        }
    }
    else
    {
        /* Can not write the first colon. */
        xReturn = pdFAIL;
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Write a short value, as a hex number with at most 4 characters. E.g. the
 *        value 15 will be printed as "f".
 * @param pcDestination the output buffer where the hex number is to be printed.
 * @param uxSize the remaining length of the output buffer.
 * @param pxSet the set of parameters as used by FreeRTOS_inet_ntop6().
 * @return pdPASS in case the output buffer is big enough to contain the string.
 * @note uxSize must be at least 4, enough to print "abcd". The string will get
 *       null-terminated later on.
 */
static BaseType_t prv_ntop6_write_short( char * pcDestination,
                                         size_t uxSize,
                                         struct sNTOP6_Set * pxSet )
{
    socklen_t uxLength;
    BaseType_t xReturn = pdPASS;
    const size_t uxBytesPerShortValue = 4U;

    if( pxSet->xIndex > 0 )
    {
        if( pxSet->uxTargetIndex >= ( uxSize - 1U ) )
        {
            xReturn = pdFAIL;
        }
        else
        {
            pcDestination[ pxSet->uxTargetIndex ] = ':';
            pxSet->uxTargetIndex++;
        }
    }

    if( xReturn == pdPASS )
    {
        /* If there is enough space to write a short. */
        if( pxSet->uxTargetIndex <= ( uxSize - uxBytesPerShortValue ) )
        {
            /* Write hex value of short. at most 4 + 1 bytes. */
            uxLength = uxHexPrintShort( &( pcDestination[ pxSet->uxTargetIndex ] ),
                                        uxBytesPerShortValue + 1U,
                                        FreeRTOS_ntohs( pxSet->pusAddress[ pxSet->xIndex ] ) );

            /* uxLength will be non zero and positive always. */
            pxSet->uxTargetIndex += uxLength;
        }
        else
        {
            xReturn = pdFAIL;
        }
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief This function converts a binary IPv6 address to a human readable notation.
 *
 * @param[in] pvSource The binary address, 16 bytes long..
 * @param[out] pcDestination The human-readable ( hexadecimal ) notation of the
 *                            address.
 * @param[in] uxSize The size of pvDestination. A value of 40 is recommended.
 *
 * @return pdPASS if the translation was successful or else pdFAIL.
 */
const char * FreeRTOS_inet_ntop6( const void * pvSource,
                                  char * pcDestination,
                                  socklen_t uxSize )
{
    const char * pcReturn;  /* The return value, which is either 'pcDestination' or NULL. */
    struct sNTOP6_Set xSet; /* A set of values for easy exchange with the helper functions prv_ntop6_xxx(). */

    ( void ) memset( &( xSet ), 0, sizeof( xSet ) );

    xSet.pusAddress = pvSource;

    if( uxSize < 3U )
    {
        /* Can not even print :: */
    }
    else
    {
        prv_ntop6_search_zeros( &( xSet ) );

        while( xSet.xIndex < 8 )
        {
            if( xSet.xIndex == xSet.xZeroStart )
            {
                if( prv_ntop6_write_zeros( pcDestination, uxSize, &( xSet ) ) == pdFAIL )
                {
                    break;
                }

                xSet.xIndex += xSet.xZeroLength;
            }
            else
            {
                if( prv_ntop6_write_short( pcDestination, uxSize, &( xSet ) ) == pdFAIL )
                {
                    break;
                }

                xSet.xIndex++;
            }
        }
    }

    if( xSet.xIndex < 8 )
    {
        /* Didn't reach the last nibble: clear the string. */
        pcReturn = NULL;
    }
    else
    {
        pcDestination[ xSet.uxTargetIndex ] = '\0';
        pcReturn = pcDestination;
    }

    return pcReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Converting a readable IPv6 address to its binary form, add one nibble.
 *
 * @param[in] pxSet  A set of variables describing the conversion.
 * @param[in] ucNew  The hex value, between 0 and 15
 * @param[in] ch  The character, such as '5', 'f', or ':'.
 *
 * @return pdTRUE when the nibble was added, otherwise pdFALSE.
 */
static BaseType_t prv_inet_pton6_add_nibble( struct sPTON6_Set * pxSet,
                                             uint8_t ucNew,
                                             char ch )
{
    BaseType_t xReturn = pdPASS;

    if( ucNew != ( uint8_t ) socketINVALID_HEX_CHAR )
    {
        /* Shift in 4 bits. */
        pxSet->ulValue <<= 4;
        pxSet->ulValue |= ( uint32_t ) ucNew;

        /* Remember that ulValue is valid now. */
        pxSet->xHadDigit = pdTRUE;

        /* Check if the number is not becoming larger than 16 bits. */
        if( pxSet->ulValue > 0xffffU )
        {
            /* The highest nibble has already been set,
             * an overflow would occur.  Break out of the for-loop. */
            xReturn = pdFAIL;
        }
    }
    else if( ch == ':' )
    {
        if( pxSet->xHadDigit == pdFALSE )
        {
            /* A "::" sequence has been received. Check if it is not a third colon. */
            if( pxSet->xColon >= 0 )
            {
                xReturn = pdFAIL;
            }
            else
            {
                /* Two or more zero's are expected, starting at position 'xColon'. */
                pxSet->xColon = pxSet->xTargetIndex;
            }
        }
        else
        {
            if( pxSet->xTargetIndex <= pxSet->xHighestIndex )
            {
                /* Store a short value at position 'xTargetIndex'. */
                pxSet->pucTarget[ pxSet->xTargetIndex ] = ( uint8_t ) ( ( pxSet->ulValue >> 8 ) & 0xffU );
                pxSet->pucTarget[ pxSet->xTargetIndex + 1 ] = ( uint8_t ) ( pxSet->ulValue & 0xffU );
                pxSet->xTargetIndex += 2;
                pxSet->xHadDigit = pdFALSE;
                pxSet->ulValue = 0U;
            }
            else
            {
                xReturn = pdFAIL;
            }
        }
    }
    else
    {
        /* When an IPv4 address or rubbish is provided, this statement will be reached. */
        xReturn = pdFAIL;
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

/**
 * @brief Convert an ASCII character to its corresponding hexadecimal value.
 *        A :: block was found, now fill in the zero's.
 * @param[in] pxSet  A set of variables describing the conversion.
 */
static void prv_inet_pton6_set_zeros( struct sPTON6_Set * pxSet )
{
    /* The number of bytes that were written after the :: */
    const BaseType_t xCount = pxSet->xTargetIndex - pxSet->xColon;
    const BaseType_t xTopIndex = ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS;
    BaseType_t xIndex;
    BaseType_t xTarget = xTopIndex - 1;
    BaseType_t xSource = pxSet->xColon + ( xCount - 1 );

    /* Inserting 'xCount' zero's. */
    for( xIndex = 0; xIndex < xCount; xIndex++ )
    {
        pxSet->pucTarget[ xTarget ] = pxSet->pucTarget[ xSource ];
        pxSet->pucTarget[ xSource ] = 0;
        xTarget--;
        xSource--;
    }

    pxSet->xTargetIndex = ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS;
}
/*-----------------------------------------------------------*/

/**
 * @brief Convert an IPv6 address in hexadecimal notation to a binary format of 16 bytes.
 *
 * @param[in] pcSource The address in hexadecimal notation.
 * @param[out] pvDestination The address in binary format, 16 bytes long.
 *
 * @return The 32-bit representation of IP(v4) address.
 */
BaseType_t FreeRTOS_inet_pton6( const char * pcSource,
                                void * pvDestination )
{
    char ch;
    uint8_t ucNew;
    BaseType_t xResult;
    struct sPTON6_Set xSet;

    const char * pcIterator = pcSource;

    ( void ) memset( &( xSet ), 0, sizeof( xSet ) );
    xSet.xColon = -1;
    xSet.pucTarget = pvDestination;

    ( void ) memset( xSet.pucTarget, 0, ipSIZE_OF_IPv6_ADDRESS );

    xResult = 0;

    /* Leading :: requires some special handling. */
    if( strcmp( pcIterator, "::" ) == 0 )
    {
        xResult = 1;
    }
    else
    {
        if( pcIterator[ 0 ] == ':' )
        {
            pcIterator++;
        }

        /* The last bytes will be written at position 14 and 15. */
        xSet.xHighestIndex = ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS;
        xSet.xHighestIndex -= ( BaseType_t ) sizeof( uint16_t );

        /* The value in ulValue is not yet valid. */
        xSet.xHadDigit = pdFALSE;
        xSet.ulValue = 0U;

        for( ; ; )
        {
            ch = *( pcIterator );
            pcIterator++;

            if( ch == ( char ) '\0' )
            {
                /* The string is parsed now.
                 * Store the last short, if present. */
                if( ( xSet.xHadDigit != pdFALSE ) &&
                    ( xSet.xTargetIndex <= xSet.xHighestIndex ) )
                {
                    /* Add the last value seen, network byte order ( MSB first ). */
                    xSet.pucTarget[ xSet.xTargetIndex ] = ( uint8_t ) ( ( xSet.ulValue >> 8 ) & 0xffU );
                    xSet.pucTarget[ xSet.xTargetIndex + 1 ] = ( uint8_t ) ( xSet.ulValue & 0xffU );
                    xSet.xTargetIndex += 2;
                }

                /* Break out of the for-ever loop. */
                break;
            }

            /* Convert from a readable character to a hex value. */
            ucNew = ucASCIIToHex( ch );
            /* See if this is a digit or a colon. */
            xResult = prv_inet_pton6_add_nibble( &( xSet ), ucNew, ch );

            if( xResult == pdFALSE )
            {
                /* The new character was not accepted. */
                break;
            }
        } /* for( ;; ) */

        if( xSet.xColon >= 0 )
        {
            /* The address contains a block of zero. */
            prv_inet_pton6_set_zeros( &( xSet ) );
        }

        if( xSet.xTargetIndex == ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS )
        {
            xResult = 1;
        }
    }

    if( xResult != 1 )
    {
        xSet.pucTarget = ( uint8_t * ) pvDestination;
        ( void ) memset( xSet.pucTarget, 0, ipSIZE_OF_IPv6_ADDRESS );
    }

    return xResult;
}

/*-----------------------------------------------------------*/
/* *INDENT-OFF* */
#endif /* ipconfigUSE_IPv6 != 0 */
/* *INDENT-ON* */