/*
 * Copyright (c) 2017-2018, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  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.
 *
 * *  Neither the name of Texas Instruments Incorporated 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 OWNER 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 files                                                             */
/*****************************************************************************/

/* Global includes                                                           */
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

#include <ti/net/slnetif.h>
#include <ti/net/slneterr.h>

/*****************************************************************************/
/* Macro declarations                                                        */
/*****************************************************************************/

#define SLNETIF_NORMALIZE_NEEDED 0
#if SLNETIF_NORMALIZE_NEEDED
    #define SLNETIF_NORMALIZE_RET_VAL(retVal,err)   ((retVal < 0)?(retVal = err):(retVal))
#else
    #define SLNETIF_NORMALIZE_RET_VAL(retVal,err)
#endif

/* Interface maximum priority                                               */
#define SLNETIF_MAX_PRIORITY                        (15)

/* The 32bit interface flags structure:
   Bits  0-3 : interface priority
   Bit     4 : Interface state
   Bits 5-31 : Reserved
*/
#define IF_PRIORITY_BITS                            (0x000f)
#define IF_STATE_BIT                                (0x0010)

/* this macro returns the priority of the interface                          */
#define GET_IF_PRIORITY(netIf)                      ((netIf).flags & IF_PRIORITY_BITS)

/* this macro reset the priority of the interface                            */
#define RESET_IF_PRIORITY(netIf)                    ((netIf).flags &= ~IF_PRIORITY_BITS)

/* this macro set the priority of the interface                              */
#define SET_IF_PRIORITY(netIf, priority)            ((netIf).flags |= ((int32_t)priority))

/* this macro returns the state of the interface                             */
#define GET_IF_STATE(netIf)                         (((netIf).flags & IF_STATE_BIT)?SLNETIF_STATE_ENABLE:SLNETIF_STATE_DISABLE)

/* this macro set the interface to enable state                              */
#define SET_IF_STATE_ENABLE(netIf)                  ((netIf).flags |= IF_STATE_BIT)

/* this macro set the interface to disable state                             */
#define SET_IF_STATE_DISABLE(netIf)                 ((netIf).flags &= ~IF_STATE_BIT)

/* Check if the state bit is set                                             */
#define IS_STATE_BIT_SET(queryBitmap)               (0 != (queryBitmap & SLNETIF_QUERY_IF_STATE_BIT))

/* Check if the connection status bit is set                                 */
#define IS_CONNECTION_STATUS_BIT_SET(queryBitmap)   (0 != (queryBitmap & SLNETIF_QUERY_IF_CONNECTION_STATUS_BIT))

/* Return last found netIf, if none of the existing interfaces answers
   the query                                                                 */
#define IS_ALLOW_PARTIAL_MATCH_BIT_SET(queryBitmap) (0 != (queryBitmap & SLNETIF_QUERY_IF_ALLOW_PARTIAL_MATCH_BIT))

/*****************************************************************************/
/* Structure/Enum declarations                                               */
/*****************************************************************************/


/* Interface Node */
typedef struct SlNetIf_Node_t
{
    SlNetIf_t              netIf;
    struct SlNetIf_Node_t *next;
} SlNetIf_Node_t;

/*****************************************************************************/
/* Global declarations                                                       */
/*****************************************************************************/

static SlNetIf_Node_t * SlNetIf_listHead = NULL;

/*****************************************************************************/
/* Function prototypes                                                       */
/*****************************************************************************/

static int32_t SlNetIf_configCheck(const SlNetIf_Config_t *ifConf);

//*****************************************************************************
//
// SlNetIf_configCheck - Checks that all mandatory configuration exists
//
//*****************************************************************************

static int32_t SlNetIf_configCheck(const SlNetIf_Config_t *ifConf)
{
    /* Check if the mandatory configuration exists
       This configuration needs to be updated when new mandatory is added    */
    if ((NULL != ifConf) &&
        (NULL != ifConf->sockCreate)   &&
        (NULL != ifConf->sockClose)    &&
        (NULL != ifConf->sockSelect)   &&
        (NULL != ifConf->sockSetOpt)   &&
        (NULL != ifConf->sockGetOpt)   &&
        (NULL != ifConf->sockRecvFrom) &&
        (NULL != ifConf->sockSendTo)   &&
        (NULL != ifConf->ifGetIPAddr)  &&
        (NULL != ifConf->ifGetConnectionStatus) )
    {
        /* All mandatory configuration exists - return success               */
        return SLNETERR_RET_CODE_OK;
    }
    else
    {
        /* Not all mandatory configuration exists - return error code        */
        return SLNETERR_INVALPARAM;
    }

}

//*****************************************************************************
//
// SlNetIf_init - Initialize the SlNetIf module
//
//*****************************************************************************
int32_t SlNetIf_init(int32_t flags)
{
    return SLNETERR_RET_CODE_OK;
}


//*****************************************************************************
//
// SlNetIf_add - Adding new interface
//
//*****************************************************************************
int32_t SlNetIf_add(uint16_t ifID, char *ifName, const SlNetIf_Config_t *ifConf, uint8_t priority)
{
    SlNetIf_Node_t *ifNode    = SlNetIf_listHead;
    SlNetIf_Node_t *prvNode   = NULL;
    char           *allocName = NULL;
    int16_t         strLen;
    int32_t         retVal;

    /* Check if ifID is a valid input - Only one bit is set (Pow of 2) or if
       the priority isn't a valid input                                      */
    if ( (false == ONLY_ONE_BIT_IS_SET(ifID)) || (priority > SLNETIF_MAX_PRIORITY) )
    {
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }

    /* Run over the interface list until finding the required ifID or Until
       reaching the end of the list                                          */
    while (NULL != ifNode)
    {
        /* Check if the identifier of the interface is equal to the input    */
        if ((ifNode->netIf).ifID == ifID)
        {
            /* Required interface found, ifID cannot be used again           */
            return SLNETERR_RET_CODE_INVALID_INPUT;
        }
        /* Check if the identifier of the interface is equal to the input    */
        if ((GET_IF_PRIORITY(ifNode->netIf)) > priority)
        {
            /* Higher priority interface found, save location                */
            prvNode = ifNode;
        }
        else
        {
            break;
        }
        ifNode = ifNode->next;
    }


    /* Check if all required configuration exists                            */
    retVal = SlNetIf_configCheck(ifConf);

    /* Check retVal in order to continue with adding the interface           */
    if (SLNETERR_RET_CODE_OK == retVal)
    {
        /* Interface node memory allocation                                  */
        /* Allocate memory for new interface node for the interface list     */
        ifNode = malloc(sizeof(SlNetIf_Node_t));

        /* Check if the memory allocated successfully                        */
        if (NULL == ifNode)
        {
            /* Allocation failed, return error code                          */
            return SLNETERR_RET_CODE_MALLOC_ERROR;
        }

        /* Interface name memory allocation                                  */
        /* Check if memory allocation for the name of the string is required */
        if (NULL != ifName)
        {
            /* Store the length of the interface name                        */
            strLen = strlen(ifName);

            /* Allocate memory that will store the name of the interface     */
            allocName = malloc(strLen + 1);

            /* Check if the memory allocated successfully                    */
            if (NULL == allocName)
            {
                /* Allocation failed, free ifNode before returning from
                   function                                                  */
                free(ifNode);
                return SLNETERR_RET_CODE_MALLOC_ERROR;
            }
            /* Copy the input name into the allocated memory                 */
            strncpy(allocName, ifName, strLen + 1);
        }

        /* Fill the allocated interface node with the input parameters       */

        /* Copy the interface ID                                             */
        (ifNode->netIf).ifID   = ifID;
        /* Connect the string allocated memory into the allocated interface  */
        (ifNode->netIf).ifName = allocName;
        /* Copy the interface configuration                                  */
        (ifNode->netIf).ifConf = (SlNetIf_Config_t *)ifConf;
        /* Reset the flags, set state to ENABLE and set the priority         */
        (ifNode->netIf).flags  = 0;
        SET_IF_PRIORITY(ifNode->netIf, priority);
        SET_IF_STATE_ENABLE(ifNode->netIf);

        /* Check if CreateContext function exists                            */
        if (NULL != ifConf->ifCreateContext)
        {
            /* Function exists, run it and fill the context                  */
            retVal = ifConf->ifCreateContext(ifID, allocName, &((ifNode->netIf).ifContext));
        }

        /* Check retVal before continuing                                    */
        if (SLNETERR_RET_CODE_OK == retVal)
        {
            /* After creating and filling the interface, add it to the right
               place in the list according to its priority                   */

            /* Check if there isn't any higher priority node                 */
            if (NULL == prvNode)
            {
                /* there isn't any higher priority node so check if list is
                   empty                                                     */
                if (NULL != SlNetIf_listHead)
                {
                    /* List isn't empty, so use the new allocated interface
                       as the new head and connect the old list head as the
                       following node                                        */
                    ifNode->next = SlNetIf_listHead;
                }
                else
                {
                    /* List is empty, so the new allocated interface will be
                       the head list                                         */
                    ifNode->next = NULL;
                }
                SlNetIf_listHead = ifNode;
            }
            else
            {
                /* Higher priority exists, connect the allocated node after
                   the prvNode and the next node (if exists) of prvNode to
                   the next of the node                                      */
                ifNode->next  = prvNode->next;
                prvNode->next = ifNode;
            }
        }
    }

    return retVal;
}


//*****************************************************************************
//
// SlNetIf_getIfByID - Get interface configuration from interface ID
//
//*****************************************************************************
SlNetIf_t * SlNetIf_getIfByID(uint16_t ifID)
{
    SlNetIf_Node_t *ifNode = SlNetIf_listHead;

    /* Check if ifID is a valid input - Only one bit is set (Pow of 2)       */
    if (false == ONLY_ONE_BIT_IS_SET(ifID))
    {
        return NULL;
    }

    /* Run over the interface list until finding the required ifID or Until
       reaching the end of the list                                          */
    while (NULL != ifNode)
    {
        /* Check if the identifier of the interface is equal to the input    */
        if ((ifNode->netIf).ifID == ifID)
        {
            /* Required interface found, return the interface pointer        */
            return &(ifNode->netIf);
        }
        ifNode = ifNode->next;
    }

    /* Interface identifier was not found                                    */
    return NULL;
}

//*****************************************************************************
//
// SlNetIf_queryIf - Get interface configuration with the highest priority
//                   from the provided interface bitmap
//                   Note: ifBitmap - 0 is not a valid input
//
//*****************************************************************************
SlNetIf_t * SlNetIf_queryIf(uint32_t ifBitmap, uint32_t queryBitmap)
{
    SlNetIf_Node_t *ifNode             = SlNetIf_listHead;
    SlNetIf_t      *bestPartialMatchIf = NULL;

    if (0 == ifBitmap)
    {
        return NULL;
    }

    /* Run over the interface list until finding the first ifID that is
       set in the ifBitmap or Until reaching the end of the list if no
       ifID were found                                                       */
    while (NULL != ifNode)
    {
        /* Check if the identifier of the interface is equal to the input    */
        if (((ifNode->netIf).ifID) & ifBitmap)
        {
            /* Save the netIf only at the first match                        */
            if (NULL == bestPartialMatchIf)
            {
                bestPartialMatchIf = &(ifNode->netIf);
            }
            /* Skip over Bitmap queries                                      */
            if ( 0 != queryBitmap)
            {
                /* Check if the state bit needs to be set and if it is       */
                if ( (true == IS_STATE_BIT_SET(queryBitmap)) &&
                     (SLNETIF_STATE_DISABLE == (GET_IF_STATE(ifNode->netIf))) )
                {
                    /* State is disabled when needed to be set, continue
                       to the next interface                                 */
                    ifNode = ifNode->next;
                    continue;
                }
                /* Check if the connection status bit needs to be set
                   and if it is                                              */
                if ( (true == IS_CONNECTION_STATUS_BIT_SET(queryBitmap)) &&
                     (SLNETIF_STATUS_DISCONNECTED == SlNetIf_getConnectionStatus((ifNode->netIf).ifID)) )
                {
                    /* Connection status is disconnected when needed to
                       be connected, continue to the next interface          */
                    ifNode = ifNode->next;
                    continue;
                }
            }
            /* Required interface found, return the interface pointer        */
            return &(ifNode->netIf);
        }
        ifNode = ifNode->next;
    }

    /* When bit is set, return the last interface found if there isn't
       an existing interface that answers the query return the last
       netIf that was found                                                  */
    if (true == IS_ALLOW_PARTIAL_MATCH_BIT_SET(queryBitmap))
    {
        return bestPartialMatchIf;
    }
    else
    {
        return NULL;
    }

}


//*****************************************************************************
//
// SlNetIf_getNameByID - Get interface Name from interface ID
//
//*****************************************************************************
const char * SlNetIf_getNameByID(uint16_t ifID)
{
    SlNetIf_t *netIf;

    /* Run validity check and find the requested interface                   */
    netIf = SlNetIf_getIfByID(ifID);

    /* Check if the requested interface exists or the function returned NULL */
    if (NULL == netIf)
    {
        /* Interface doesn't exists or invalid input, return NULL            */
        return NULL;
    }
    else
    {
        /* Interface exists, return the interface name                       */
        return netIf->ifName;
    }
}


//*****************************************************************************
//
// SlNetIf_getIDByName - Get interface ID from interface name
//
//*****************************************************************************
int32_t SlNetIf_getIDByName(char *ifName)
{
    SlNetIf_Node_t *ifNode = SlNetIf_listHead;

    /* Check if ifName is a valid input                                      */
    if (NULL == ifName)
    {
        return(SLNETERR_RET_CODE_INVALID_INPUT);
    }

    /* Run over the interface list until finding the required ifID or Until
       reaching the end of the list                                          */
    while (NULL != ifNode)
    {
        /* Check if the identifier of the interface is equal to the input    */
        if (strcmp((ifNode->netIf).ifName, ifName) == 0)
        {
            /* Required interface found, return the interface identifier     */
            return ((ifNode->netIf).ifID);
        }
        ifNode = ifNode->next;
    }

    /* Interface identifier was not found, return error code                 */
    return(SLNETERR_RET_CODE_INVALID_INPUT);
}


//*****************************************************************************
//
// SlNetIf_getPriority - Get interface priority
//
//*****************************************************************************
int32_t SlNetIf_getPriority(uint16_t ifID)
{
    SlNetIf_t *netIf;

    /* Run validity check and find the requested interface                   */
    netIf = SlNetIf_getIfByID(ifID);

    /* Check if the requested interface exists or the function returned NULL */
    if (NULL == netIf)
    {
        /* Interface doesn't exists or invalid input, return error code      */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }
    else
    {
        /* Interface exists, return interface priority                       */
        return GET_IF_PRIORITY(*netIf);
    }
}


//*****************************************************************************
//
// SlNetIf_setPriority - Set interface priority
//
//*****************************************************************************
int32_t SlNetIf_setPriority(uint16_t ifID, uint8_t priority)
{
    SlNetIf_Node_t *ifListNode        = SlNetIf_listHead;
    SlNetIf_Node_t *prvIfListNode     = SlNetIf_listHead;
    SlNetIf_Node_t *reqIfListNode     = NULL;
    bool            connectAgain      = false;

    if (priority > SLNETIF_MAX_PRIORITY)
    {
        /* Run validity check and find the requested interface               */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }

    /* Find the location of required interface                               */
    while (NULL != ifListNode)
    {
        /* If the location of the required interface found, store the
           location                                                          */
        if ((ifListNode->netIf.ifID) == ifID)
        {
            reqIfListNode = ifListNode;
            /* Check if the required interface is the last node and needs
               lower priority than the previous node, only update of the
               priority is required for this node                            */
            if (NULL == ifListNode->next)
            {
                if (GET_IF_PRIORITY(prvIfListNode->netIf) >= priority)
                {
                    /* The required interface is the last node and needs
                       lower priority than the previous node, only update
                       of the priority is required for this node             */
                    break;
                }
                else
                {
                    /* The required interface is the last node but has
                       higher priority than the previous node, disconnect
                       the interface from the list. connect the previous node
                       to the end of the list
                       If this is not the only node in the list, find where 
                       it now belongs based on its new priority.            */
                    if (reqIfListNode != SlNetIf_listHead)
                    {
                        prvIfListNode->next = NULL;
                        connectAgain = true;
                        /* This is the end of the list, so stop looping      */
                        break;
                    }
                }
            }
            /* Check if the required interface is the first node in the list */
            else if (SlNetIf_listHead == ifListNode)
            {
                if ( (NULL == ifListNode->next) || ((GET_IF_PRIORITY(ifListNode->next->netIf)) <= priority) )
                {
                    /* The required interface is the first node and needs
                       higher priority than the following node, only update
                       of the priority is required for this node             */
                    break;
                }
                /* The required interface is the first node but doesn't need
                   higher priority than the following node so the following
                   node will be the first node of the list                   */
                else
                {
                    SlNetIf_listHead = ifListNode->next;
                    connectAgain = true;
                }
            }
            /* The required interface isn't the first or last node and needs
               priority change but is in the correct location, only update
               of the priority is required for this node                     */
            else if ( (GET_IF_PRIORITY(prvIfListNode->netIf) >= priority) && ((GET_IF_PRIORITY(ifListNode->next->netIf)) <= priority) )
            {
                break;
            }
            /* The required interface isn't the first or last node and needs
               priority change, disconnect it from the list. connect the
               previous node with the following node                         */
            else
            {
                prvIfListNode->next = prvIfListNode->next->next;
                connectAgain = true;
            }
        }
        else
        {
            prvIfListNode = ifListNode;
        }
        ifListNode = ifListNode->next;
    }

    /* When connectAgain is set, there's a need to find where to add back
       the required interface according to the priority                      */
    if (connectAgain == true)
    {
        ifListNode = SlNetIf_listHead;
        while (NULL != ifListNode)
        {
            /* If the incoming priority is higher than any present           */
            if ( (ifListNode == SlNetIf_listHead) )
            {
                if ((GET_IF_PRIORITY(ifListNode->netIf)) <= priority)
                {
                    reqIfListNode->next = ifListNode;
                    SlNetIf_listHead = reqIfListNode;
                    break;
                }
            }

            /* Check if the priority of the current interface is higher of
               the required priority, if so, store it as the previous
               interface and continue to search until finding interface with
               lower priority and than connect the required interface to the
               prior interface                                               */
            if ((GET_IF_PRIORITY(ifListNode->netIf)) > priority)
            {
                prvIfListNode = ifListNode;

            }
            else
            {
                reqIfListNode->next = prvIfListNode->next;
                prvIfListNode->next = reqIfListNode;
                break;
            }
            ifListNode = ifListNode->next;

            if (NULL == ifListNode)
            {
                /* All interfaces have higher priorities than reqIfListNode  */
                prvIfListNode->next = reqIfListNode;
                reqIfListNode->next = NULL;
                break;
            }
        }
    }

    if (NULL != reqIfListNode)
    {
        /* Interface exists, set the interface priority                          */
        RESET_IF_PRIORITY(reqIfListNode->netIf);
        SET_IF_PRIORITY(reqIfListNode->netIf, priority);
    }

    return SLNETERR_RET_CODE_OK;
}


//*****************************************************************************
//
// SlNetIf_setState - Set interface state
//
//*****************************************************************************
int32_t SlNetIf_setState(uint16_t ifID, SlNetIfState_e ifState)
{
    SlNetIf_t *netIf;

    /* Run validity check and find the requested interface                   */
    netIf = SlNetIf_getIfByID(ifID);

    /* Check if the requested interface exists or the function returned NULL */
    if (NULL == netIf)
    {
        /* Interface doesn't exists or invalid input, return error code      */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }
    else
    {
        /* Interface exists, set the interface state                         */
        if (ifState == SLNETIF_STATE_DISABLE)
        {
            /* Interface state - Disable                                     */
            SET_IF_STATE_DISABLE(*netIf);
        }
        else
        {
            /* Interface state - Enable                                      */
            SET_IF_STATE_ENABLE(*netIf);
        }
    }
    return SLNETERR_RET_CODE_OK;
}


//*****************************************************************************
//
// SlNetIf_getState - Get interface state
//
//*****************************************************************************
int32_t SlNetIf_getState(uint16_t ifID)
{
    SlNetIf_t *netIf;

    /* Run validity check and find the requested interface                   */
    netIf = SlNetIf_getIfByID(ifID);

    /* Check if the requested interface exists or the function returned NULL */
    if (NULL == netIf)
    {
        /* Interface doesn't exists or invalid input, return error code      */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }
    else
    {
        /* Interface exists, return interface state                          */
        return GET_IF_STATE(*netIf);
    }
}


//*****************************************************************************
//
// SlNetIf_getIPAddr - Get IP Address of specific interface
//
//*****************************************************************************
int32_t SlNetIf_getIPAddr(uint16_t ifID, SlNetIfAddressType_e addrType, uint16_t *addrConfig, uint32_t *ipAddr)
{
    SlNetIf_t *netIf;
    int32_t    retVal;

    /* Run validity check and find the requested interface                   */
    netIf = SlNetIf_getIfByID(ifID);

    /* Check if the requested interface exists or the function returned NULL */
    if (NULL == netIf)
    {
        /* Interface doesn't exists or invalid input, return NULL            */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }
    else
    {
        /* Interface exists, return interface IP address                     */
        retVal = (netIf->ifConf)->ifGetIPAddr(netIf->ifContext, addrType, addrConfig, ipAddr);
        SLNETIF_NORMALIZE_RET_VAL(retVal,SLNETIF_ERR_IFGETIPADDR_FAILED);

        /* Check retVal for error codes                                      */
        if (retVal < SLNETERR_RET_CODE_OK)
        {
            /* Return retVal, function error                                 */
            return retVal;
        }
        else
        {
            /* Return success                                                */
            return SLNETERR_RET_CODE_OK;
        }
    }
}


//*****************************************************************************
//
// SlNetIf_getConnectionStatus - Get interface connection status
//
//*****************************************************************************
int32_t SlNetIf_getConnectionStatus(uint16_t ifID)
{
    SlNetIf_t *netIf;
    int16_t    connectionStatus;

    /* Run validity check and find the requested interface                   */
    netIf = SlNetIf_getIfByID(ifID);

    /* Check if the requested interface exists or the function returned NULL */
    if (NULL == netIf)
    {
        /* Interface doesn't exists or invalid input, return NULL            */
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }
    else
    {
        /* Interface exists, return interface connection status              */
        connectionStatus = (netIf->ifConf)->ifGetConnectionStatus(netIf->ifContext);

        /* Interface exists, set the interface state                         */
        if (connectionStatus == SLNETIF_STATUS_DISCONNECTED)
        {
            /* Interface is disconnected                                     */
            return SLNETIF_STATUS_DISCONNECTED;
        }
        else if (connectionStatus > SLNETIF_STATUS_DISCONNECTED)
        {
            SLNETIF_NORMALIZE_RET_VAL(connectionStatus,SLNETIF_STATUS_CONNECTED);
        }
        else
        {
            SLNETIF_NORMALIZE_RET_VAL(connectionStatus,SLNETIF_ERR_IFGETCONNECTIONSTATUS_FAILED);
        }
        return connectionStatus;
    }
}


//*****************************************************************************
//
// SlNetIf_loadSecObj - Load secured buffer to the network stack
//
//*****************************************************************************
int32_t SlNetIf_loadSecObj(uint16_t objType, char *objName, int16_t objNameLen, uint8_t *objBuff, int16_t objBuffLen, uint32_t ifBitmap)
{
    SlNetIf_t *netIf;
    int32_t    retVal;
    uint32_t   ifIDIndex = 1;  /* Set value to highest bit in uint32_t       */
    uint32_t   maxIDIndex = (uint32_t)1 << SLNETIF_MAX_IF;

    if ((NULL == objName) || (NULL == objBuff))
    {
        return SLNETERR_RET_CODE_INVALID_INPUT;
    }

    /* bitmap 0 entered, load sec obj to all available interfaces            */
    if (0 == ifBitmap)
    {
        ifBitmap = ~ifBitmap;
    }

    while ( ifIDIndex < maxIDIndex )
    {
        /* Check if ifIDIndex is a required ifID from the ifBitmap           */
        if ( ifIDIndex & ifBitmap )
        {
            /* Run validity check and find the requested interface           */
            netIf = SlNetIf_getIfByID(ifIDIndex & ifBitmap);

            /* Check if the requested interface exists or the function
               returned NULL                                                 */
            if ( (NULL != netIf) && (NULL != (netIf->ifConf)->ifLoadSecObj) )
            {
                /* Interface exists, return interface IP address             */
                retVal = (netIf->ifConf)->ifLoadSecObj(netIf->ifContext, objType, objName, objNameLen, objBuff, objBuffLen);
                SLNETIF_NORMALIZE_RET_VAL(retVal,SLNETIF_ERR_IFLOADSECOBJ_FAILED);

                /* Check retVal for error codes                              */
                if (retVal < SLNETERR_RET_CODE_OK)
                {
                    /* Return retVal, function error                         */
                    return retVal;
                }
                else
                {
                    /* Return success                                        */
                    return SLNETERR_RET_CODE_OK;
                }
            }
        }
        ifIDIndex <<= 1;
    }
    /* Interface doesn't exists or invalid input, return error code          */
    return SLNETERR_RET_CODE_INVALID_INPUT;
}