/******************************************************************************
 *
 *  Copyright (C) 1999-2012 Broadcom Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/

/******************************************************************************
 *
 *  This file contains main functions to support PAN profile
 *  commands and events.
 *
 ******************************************************************************/

#include <string.h>
#include "bt_target.h"
#if defined(PAN_INCLUDED) &&(PAN_INCLUDED == TRUE)
#include "bt_common.h"
#include "bt_types.h"
#include "bt_utils.h"
#include "bnep_api.h"
#include "pan_api.h"
#include "pan_int.h"
#include "sdp_api.h"
#include "sdpdefs.h"
#include "l2c_api.h"
#include "hcidefs.h"


#if PAN_DYNAMIC_MEMORY == FALSE
    tPAN_CB  pan_cb;
#endif

#define UUID_CONSTANT_PART  12
uint8_t constant_pan_uuid[UUID_CONSTANT_PART] = {0, 0, 0x10, 0, 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb};


/*******************************************************************************
**
** Function         pan_register_with_bnep
**
** Description      This function registers PAN profile with BNEP
**
** Parameters:      none
**
** Returns          none
**
*******************************************************************************/
void pan_register_with_bnep(void)
{
    tBNEP_REGISTER      reg_info;
    wm_memset(&reg_info, 0, sizeof(tBNEP_REGISTER));
    reg_info.p_conn_ind_cb      = pan_conn_ind_cb;
    reg_info.p_conn_state_cb    = pan_connect_state_cb;
    reg_info.p_data_buf_cb      = pan_data_buf_ind_cb;
    reg_info.p_data_ind_cb      = NULL;
    reg_info.p_tx_data_flow_cb  = pan_tx_data_flow_cb;
    reg_info.p_filter_ind_cb    = pan_proto_filt_ind_cb;
    reg_info.p_mfilter_ind_cb   = pan_mcast_filt_ind_cb;
    BNEP_Register(&reg_info);
}


/*******************************************************************************
**
** Function         pan_conn_ind_cb
**
** Description      This function is registered with BNEP as connection indication
**                  callback. BNEP will call this when there is connection
**                  request from the peer. PAN should call BNEP_ConnectResp to
**                  indicate whether to accept the connection or reject
**
** Parameters:      handle          - handle for the connection
**                  p_bda           - BD Addr of the peer requesting the connection
**                  remote_uuid     - UUID of the source role (peer device role)
**                  local_uuid      - UUID of the destination role (local device role)
**                  is_role_change  - Flag to indicate that it is a role change
**
** Returns          none
**
*******************************************************************************/
void pan_conn_ind_cb(uint16_t handle,
                     BD_ADDR p_bda,
                     tBT_UUID *remote_uuid,
                     tBT_UUID *local_uuid,
                     uint8_t is_role_change)
{
    tPAN_CONN       *pcb;
    uint8_t           req_role;
    uint8_t         wrong_uuid;
    /*
    ** If we are in GN or NAP role and have one or more
    ** active connections and the received connection is
    ** for user role reject it.
    ** If we are in user role with one connection active
    ** reject the connection.
    ** Allocate PCB and store the parameters
    ** Make bridge request to the host system if connection
    ** is for NAP
    */
    wrong_uuid = FALSE;

    if(remote_uuid->len == 16)
    {
        /*
        ** If the UUID is 16 bytes forst two bytes should be zeros
        ** and last 12 bytes should match the spec defined constant value
        */
        if(memcmp(constant_pan_uuid, remote_uuid->uu.uuid128 + 4, UUID_CONSTANT_PART))
        {
            wrong_uuid = TRUE;
        }

        if(remote_uuid->uu.uuid128[0] || remote_uuid->uu.uuid128[1])
        {
            wrong_uuid = TRUE;
        }

        /* Extract the 16 bit equivalent of the UUID */
        remote_uuid->uu.uuid16 = (uint16_t)((remote_uuid->uu.uuid128[2] << 8) | remote_uuid->uu.uuid128[3]);
        remote_uuid->len = 2;
    }

    if(remote_uuid->len == 4)
    {
        /* First two bytes should be zeros */
        if(remote_uuid->uu.uuid32 & 0xFFFF0000)
        {
            wrong_uuid = TRUE;
        }

        remote_uuid->uu.uuid16 = (uint16_t)remote_uuid->uu.uuid32;
        remote_uuid->len = 2;
    }

    if(wrong_uuid)
    {
        PAN_TRACE_ERROR("PAN Connection failed because of wrong remote UUID ");
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED_SRC_UUID);
        return;
    }

    wrong_uuid = FALSE;

    if(local_uuid->len == 16)
    {
        /*
        ** If the UUID is 16 bytes forst two bytes should be zeros
        ** and last 12 bytes should match the spec defined constant value
        */
        if(memcmp(constant_pan_uuid, local_uuid->uu.uuid128 + 4, UUID_CONSTANT_PART))
        {
            wrong_uuid = TRUE;
        }

        if(local_uuid->uu.uuid128[0] || local_uuid->uu.uuid128[1])
        {
            wrong_uuid = TRUE;
        }

        /* Extract the 16 bit equivalent of the UUID */
        local_uuid->uu.uuid16 = (uint16_t)((local_uuid->uu.uuid128[2] << 8) | local_uuid->uu.uuid128[3]);
        local_uuid->len = 2;
    }

    if(local_uuid->len == 4)
    {
        /* First two bytes should be zeros */
        if(local_uuid->uu.uuid32 & 0xFFFF0000)
        {
            wrong_uuid = TRUE;
        }

        local_uuid->uu.uuid16 = (uint16_t)local_uuid->uu.uuid32;
        local_uuid->len = 2;
    }

    if(wrong_uuid)
    {
        PAN_TRACE_ERROR("PAN Connection failed because of wrong local UUID ");
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED_DST_UUID);
        return;
    }

    PAN_TRACE_EVENT("pan_conn_ind_cb - for handle %d, current role %d, dst uuid 0x%x, src uuid 0x%x, role change %s",
                    handle, pan_cb.role, local_uuid->uu.uuid16, remote_uuid->uu.uuid16, is_role_change ? "YES" : "NO");

    /* The acceptable UUID size is only 2 */
    if(remote_uuid->len != 2)
    {
        PAN_TRACE_ERROR("PAN Connection failed because of wrong UUID size %d", remote_uuid->len);
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED_UUID_SIZE);
        return;
    }

    /* Check if the source UUID is a valid one */
    if(remote_uuid->uu.uuid16 != UUID_SERVCLASS_PANU &&
            remote_uuid->uu.uuid16 != UUID_SERVCLASS_NAP &&
            remote_uuid->uu.uuid16 != UUID_SERVCLASS_GN)
    {
        PAN_TRACE_ERROR("Src UUID 0x%x is not valid", remote_uuid->uu.uuid16);
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED_SRC_UUID);
        return;
    }

    /* Check if the destination UUID is a valid one */
    if(local_uuid->uu.uuid16 != UUID_SERVCLASS_PANU &&
            local_uuid->uu.uuid16 != UUID_SERVCLASS_NAP &&
            local_uuid->uu.uuid16 != UUID_SERVCLASS_GN)
    {
        PAN_TRACE_ERROR("Dst UUID 0x%x is not valid", remote_uuid->uu.uuid16);
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED_DST_UUID);
        return;
    }

    /* Check if currently we support the destination role requested */
    if(((!(pan_cb.role & UUID_SERVCLASS_PANU))
            && local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU) ||
            ((!(pan_cb.role & UUID_SERVCLASS_GN))
             && local_uuid->uu.uuid16 == UUID_SERVCLASS_GN) ||
            ((!(pan_cb.role & UUID_SERVCLASS_NAP))
             && local_uuid->uu.uuid16 == UUID_SERVCLASS_NAP))
    {
        PAN_TRACE_ERROR("PAN Connection failed because of unsupported destination UUID 0x%x", local_uuid->uu.uuid16);
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED_DST_UUID);
        return;
    }

    /* Requested destination role is */
    if(local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU)
    {
        req_role = PAN_ROLE_CLIENT;
    }
    else
        if(local_uuid->uu.uuid16 == UUID_SERVCLASS_GN)
        {
            req_role = PAN_ROLE_GN_SERVER;
        }
        else
        {
            req_role = PAN_ROLE_NAP_SERVER;
        }

    /* If the connection indication is for the existing connection
    ** Check if the new destination role is acceptable
    */
    pcb = pan_get_pcb_by_handle(handle);

    if(pcb)
    {
        if(pan_cb.num_conns > 1 && local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU)
        {
            /* There are connections other than this one
            ** so we cann't accept PANU role. Reject
            */
            PAN_TRACE_ERROR("Dst UUID should be either GN or NAP only because there are other connections");
            BNEP_ConnectResp(handle, BNEP_CONN_FAILED_DST_UUID);
            return;
        }

        /* If it is already in connected state check for bridging status */
        if(pcb->con_state == PAN_STATE_CONNECTED)
        {
            PAN_TRACE_EVENT("PAN Role changing New Src 0x%x Dst 0x%x",
                            remote_uuid->uu.uuid16, local_uuid->uu.uuid16);
            pcb->prv_src_uuid = pcb->src_uuid;
            pcb->prv_dst_uuid = pcb->dst_uuid;

            if(pcb->src_uuid == UUID_SERVCLASS_NAP &&
                    local_uuid->uu.uuid16 != UUID_SERVCLASS_NAP)
            {
                /* Remove bridging */
                if(pan_cb.pan_bridge_req_cb)
                {
                    (*pan_cb.pan_bridge_req_cb)(pcb->rem_bda, FALSE);
                }
            }
        }

        /* Set the latest active PAN role */
        pan_cb.active_role = req_role;
        pcb->src_uuid = local_uuid->uu.uuid16;
        pcb->dst_uuid = remote_uuid->uu.uuid16;
        BNEP_ConnectResp(handle, BNEP_SUCCESS);
        return;
    }
    else
    {
        /* If this a new connection and destination is PANU role and
        ** we already have a connection then reject the request.
        ** If we have a connection in PANU role then reject it
        */
        if(pan_cb.num_conns &&
                (local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU ||
                 pan_cb.active_role == PAN_ROLE_CLIENT))
        {
            PAN_TRACE_ERROR("PAN already have a connection and can't be user");
            BNEP_ConnectResp(handle, BNEP_CONN_FAILED_DST_UUID);
            return;
        }
    }

    /* This is a new connection */
    PAN_TRACE_DEBUG("New connection indication for handle %d", handle);
    pcb = pan_allocate_pcb(p_bda, handle);

    if(!pcb)
    {
        PAN_TRACE_ERROR("PAN no control block for new connection");
        BNEP_ConnectResp(handle, BNEP_CONN_FAILED);
        return;
    }

    PAN_TRACE_EVENT("PAN connection destination UUID is 0x%x", local_uuid->uu.uuid16);
    /* Set the latest active PAN role */
    pan_cb.active_role = req_role;
    pcb->src_uuid = local_uuid->uu.uuid16;
    pcb->dst_uuid = remote_uuid->uu.uuid16;
    pcb->con_state = PAN_STATE_CONN_START;
    pan_cb.num_conns++;
    BNEP_ConnectResp(handle, BNEP_SUCCESS);
    return;
}


/*******************************************************************************
**
** Function         pan_connect_state_cb
**
** Description      This function is registered with BNEP as connection state
**                  change callback. BNEP will call this when the connection
**                  is established successfully or terminated
**
** Parameters:      handle      - handle for the connection given in the connection
**                                      indication callback
**                  rem_bda     - remote device bd addr
**                  result      - indicates whether the connection is up or down
**                                      BNEP_SUCCESS if the connection is up
**                                      all other values indicates appropriate errors
**                  is_role_change - flag to indicate that it is a role change
**
** Returns          none
**
*******************************************************************************/
void pan_connect_state_cb(uint16_t handle, BD_ADDR rem_bda, tBNEP_RESULT result, uint8_t is_role_change)
{
    tPAN_CONN       *pcb;
    uint8_t            peer_role;
    UNUSED(rem_bda);
    PAN_TRACE_EVENT("pan_connect_state_cb - for handle %d, result %d", handle, result);
    pcb = pan_get_pcb_by_handle(handle);

    if(!pcb)
    {
        PAN_TRACE_ERROR("PAN State change indication for wrong handle %d", handle);
        return;
    }

    /* If the connection is getting terminated remove bridging */
    if(result != BNEP_SUCCESS)
    {
        /* Inform the application that connection is down */
        if(pan_cb.pan_conn_state_cb)
        {
            (*pan_cb.pan_conn_state_cb)(pcb->handle, pcb->rem_bda, result, is_role_change, PAN_ROLE_INACTIVE, PAN_ROLE_INACTIVE);
        }

        /* Check if this failure is for role change only */
        if(pcb->con_state != PAN_STATE_CONNECTED &&
                (pcb->con_flags & PAN_FLAGS_CONN_COMPLETED))
        {
            /* restore the original values */
            PAN_TRACE_EVENT("restoring the connection state to active");
            pcb->con_state = PAN_STATE_CONNECTED;
            pcb->con_flags &= (~PAN_FLAGS_CONN_COMPLETED);
            pcb->src_uuid = pcb->prv_src_uuid;
            pcb->dst_uuid = pcb->prv_dst_uuid;
            pan_cb.active_role = pan_cb.prv_active_role;

            if((pcb->src_uuid == UUID_SERVCLASS_NAP) && pan_cb.pan_bridge_req_cb)
            {
                (*pan_cb.pan_bridge_req_cb)(pcb->rem_bda, TRUE);
            }

            return;
        }

        if(pcb->con_state == PAN_STATE_CONNECTED)
        {
            /* If the connections destination role is NAP remove bridging */
            if((pcb->src_uuid == UUID_SERVCLASS_NAP) && pan_cb.pan_bridge_req_cb)
            {
                (*pan_cb.pan_bridge_req_cb)(pcb->rem_bda, FALSE);
            }
        }

        pan_cb.num_conns--;
        pan_release_pcb(pcb);
        return;
    }

    /* Requested destination role is */
    if(pcb->src_uuid == UUID_SERVCLASS_PANU)
    {
        pan_cb.active_role = PAN_ROLE_CLIENT;
    }
    else
        if(pcb->src_uuid == UUID_SERVCLASS_GN)
        {
            pan_cb.active_role = PAN_ROLE_GN_SERVER;
        }
        else
        {
            pan_cb.active_role = PAN_ROLE_NAP_SERVER;
        }

    if(pcb->dst_uuid == UUID_SERVCLASS_PANU)
    {
        peer_role = PAN_ROLE_CLIENT;
    }
    else
        if(pcb->dst_uuid == UUID_SERVCLASS_GN)
        {
            peer_role = PAN_ROLE_GN_SERVER;
        }
        else
        {
            peer_role = PAN_ROLE_NAP_SERVER;
        }

    pcb->con_state = PAN_STATE_CONNECTED;

    /* Inform the application that connection is down */
    if(pan_cb.pan_conn_state_cb)
    {
        (*pan_cb.pan_conn_state_cb)(pcb->handle, pcb->rem_bda, PAN_SUCCESS, is_role_change, pan_cb.active_role, peer_role);
    }

    /* Create bridge if the destination role is NAP */
    if(pan_cb.pan_bridge_req_cb && pcb->src_uuid == UUID_SERVCLASS_NAP)
    {
        PAN_TRACE_EVENT("PAN requesting for bridge");
        (*pan_cb.pan_bridge_req_cb)(pcb->rem_bda, TRUE);
    }
}


/*******************************************************************************
**
** Function         pan_data_ind_cb
**
** Description      This function is registered with BNEP as data indication
**                  callback. BNEP will call this when the peer sends any data
**                  on this connection
**
** Parameters:      handle      - handle for the connection
**                  src         - source BD Addr
**                  dst         - destination BD Addr
**                  protocol    - Network protocol of the Eth packet
**                  p_data      - pointer to the data
**                  len         - length of the data
**                  fw_ext_present - to indicate whether the data contains any
**                                         extension headers before the payload
**
** Returns          none
**
*******************************************************************************/
void pan_data_ind_cb(uint16_t handle,
                     uint8_t *src,
                     uint8_t *dst,
                     uint16_t protocol,
                     uint8_t *p_data,
                     uint16_t len,
                     uint8_t ext)
{
    tPAN_CONN       *pcb;
    uint16_t          i;
    uint8_t         forward;
    /*
    ** Check the connection status
    ** If the destination address is MAC broadcast send on all links
    ** except on the one received
    ** If the destination uuid is for NAP send to host system also
    ** If the destination address is one of the devices connected
    ** send the packet to over that link
    ** If the destination address is unknown and destination uuid is NAP
    ** send it to the host system
    */
    PAN_TRACE_EVENT("pan_data_ind_cb - for handle %d", handle);
    pcb = pan_get_pcb_by_handle(handle);

    if(!pcb)
    {
        PAN_TRACE_ERROR("PAN Data indication for wrong handle %d", handle);
        return;
    }

    if(pcb->con_state != PAN_STATE_CONNECTED)
    {
        PAN_TRACE_ERROR("PAN Data indication in wrong state %d for handle %d",
                        pcb->con_state, handle);
        return;
    }

    /* Check if it is broadcast packet */
    if(dst[0] & 0x01)
    {
        PAN_TRACE_DEBUG("PAN received broadcast packet on handle %d, src uuid 0x%x",
                        handle, pcb->src_uuid);

        for(i = 0; i < MAX_PAN_CONNS; i++)
        {
            if(pan_cb.pcb[i].con_state == PAN_STATE_CONNECTED &&
                    pan_cb.pcb[i].handle != handle &&
                    pcb->src_uuid == pan_cb.pcb[i].src_uuid)
            {
                BNEP_Write(pan_cb.pcb[i].handle, dst, p_data, len, protocol, src, ext);
            }
        }

        if(pan_cb.pan_data_ind_cb)
        {
            (*pan_cb.pan_data_ind_cb)(pcb->handle, src, dst, protocol, p_data, len, ext, TRUE);
        }

        return;
    }

    /* Check if it is for any other PAN connection */
    for(i = 0; i < MAX_PAN_CONNS; i++)
    {
        if(pan_cb.pcb[i].con_state == PAN_STATE_CONNECTED &&
                pcb->src_uuid == pan_cb.pcb[i].src_uuid)
        {
            if(memcmp(pan_cb.pcb[i].rem_bda, dst, BD_ADDR_LEN) == 0)
            {
                BNEP_Write(pan_cb.pcb[i].handle, dst, p_data, len, protocol, src, ext);
                return;
            }
        }
    }

    if(pcb->src_uuid == UUID_SERVCLASS_NAP)
    {
        forward = TRUE;
    }
    else
    {
        forward = FALSE;
    }

    /* Send it over the LAN or give it to host software */
    if(pan_cb.pan_data_ind_cb)
    {
        (*pan_cb.pan_data_ind_cb)(pcb->handle, src, dst, protocol, p_data, len, ext, forward);
    }

    return;
}


/*******************************************************************************
**
** Function         pan_data_buf_ind_cb
**
** Description      This function is registered with BNEP as data buffer indication
**                  callback. BNEP will call this when the peer sends any data
**                  on this connection. PAN is responsible to release the buffer
**
** Parameters:      handle      - handle for the connection
**                  src         - source BD Addr
**                  dst         - destination BD Addr
**                  protocol    - Network protocol of the Eth packet
**                  p_buf       - pointer to the data buffer
**                  ext         - to indicate whether the data contains any
**                                         extension headers before the payload
**
** Returns          none
**
*******************************************************************************/
void pan_data_buf_ind_cb(uint16_t handle,
                         uint8_t *src,
                         uint8_t *dst,
                         uint16_t protocol,
                         BT_HDR *p_buf,
                         uint8_t ext)
{
    tPAN_CONN       *pcb, *dst_pcb;
    tBNEP_RESULT    result;
    uint16_t          i, len;
    uint8_t           *p_data;
    uint8_t         forward = FALSE;
    /* Check if the connection is in right state */
    pcb = pan_get_pcb_by_handle(handle);

    if(!pcb)
    {
        PAN_TRACE_ERROR("PAN Data buffer indication for wrong handle %d", handle);
        GKI_freebuf(p_buf);
        return;
    }

    if(pcb->con_state != PAN_STATE_CONNECTED)
    {
        PAN_TRACE_ERROR("PAN Data indication in wrong state %d for handle %d",
                        pcb->con_state, handle);
        GKI_freebuf(p_buf);
        return;
    }

    p_data = (uint8_t *)(p_buf + 1) + p_buf->offset;
    len    = p_buf->len;
    PAN_TRACE_EVENT("pan_data_buf_ind_cb - for handle %d, protocol 0x%x, length %d, ext %d",
                    handle, protocol, len, ext);

    if(pcb->src_uuid == UUID_SERVCLASS_NAP)
    {
        forward = TRUE;
    }
    else
    {
        forward = FALSE;
    }

    /* Check if it is broadcast or multicast packet */
    if(pcb->src_uuid != UUID_SERVCLASS_PANU)
    {
        if(dst[0] & 0x01)
        {
            PAN_TRACE_DEBUG("PAN received broadcast packet on handle %d, src uuid 0x%x",
                            handle, pcb->src_uuid);

            for(i = 0; i < MAX_PAN_CONNS; i++)
            {
                if(pan_cb.pcb[i].con_state == PAN_STATE_CONNECTED &&
                        pan_cb.pcb[i].handle != handle &&
                        pcb->src_uuid == pan_cb.pcb[i].src_uuid)
                {
                    BNEP_Write(pan_cb.pcb[i].handle, dst, p_data, len, protocol, src, ext);
                }
            }

            if(pan_cb.pan_data_buf_ind_cb)
            {
                (*pan_cb.pan_data_buf_ind_cb)(pcb->handle, src, dst, protocol, p_buf, ext, forward);
            }
            else
                if(pan_cb.pan_data_ind_cb)
                {
                    (*pan_cb.pan_data_ind_cb)(pcb->handle, src, dst, protocol, p_data, len, ext, forward);
                    GKI_freebuf(p_buf);
                }

            return;
        }

        /* Check if it is for any other PAN connection */
        dst_pcb = pan_get_pcb_by_addr(dst);

        if(dst_pcb)
        {
            PAN_TRACE_EVENT("%s - destination PANU found on handle %d and sending data, len: %d",
                            __func__, dst_pcb->handle, len);
            result = BNEP_Write(dst_pcb->handle, dst, p_data, len, protocol, src, ext);

            if(result != BNEP_SUCCESS && result != BNEP_IGNORE_CMD)
            {
                PAN_TRACE_ERROR("Failed to write data for PAN connection handle %d", dst_pcb->handle);
            }

            GKI_freebuf(p_buf);
            return;
        }
    }

    /* Send it over the LAN or give it to host software */
    if(pan_cb.pan_data_buf_ind_cb)
    {
        (*pan_cb.pan_data_buf_ind_cb)(pcb->handle, src, dst, protocol, p_buf, ext, forward);
    }
    else
        if(pan_cb.pan_data_ind_cb)
        {
            (*pan_cb.pan_data_ind_cb)(pcb->handle, src, dst, protocol, p_data, len, ext, forward);
            GKI_freebuf(p_buf);
        }
        else
        {
            GKI_freebuf(p_buf);
        }

    return;
}

/*******************************************************************************
**
** Function         pan_proto_filt_ind_cb
**
** Description      This function is registered with BNEP to receive tx data
**                  flow status
**
** Parameters:      handle      - handle for the connection
**                  event       - flow status
**
** Returns          none
**
*******************************************************************************/
void pan_tx_data_flow_cb(uint16_t handle,
                         tBNEP_RESULT  event)
{
    if(pan_cb.pan_tx_data_flow_cb)
    {
        (*pan_cb.pan_tx_data_flow_cb)(handle, event);
    }

    return;
}

/*******************************************************************************
**
** Function         pan_proto_filt_ind_cb
**
** Description      This function is registered with BNEP as proto filter indication
**                  callback. BNEP will call this when the peer sends any protocol
**                  filter set for the connection or to indicate the result of the
**                  protocol filter set by the local device
**
** Parameters:      handle      - handle for the connection
**                  indication  - TRUE if this is indication
**                                FALSE if it is called to give the result of local
**                                      device protocol filter set
**                  result      - This gives the result of the filter set operation
**                  num_filters - number of filters set by the peer device
**                  p_filters   - pointer to the filters set by the peer device
**
** Returns          none
**
*******************************************************************************/
void pan_proto_filt_ind_cb(uint16_t handle,
                           uint8_t indication,
                           tBNEP_RESULT result,
                           uint16_t num_filters,
                           uint8_t *p_filters)
{
    PAN_TRACE_EVENT("pan_proto_filt_ind_cb - called for handle %d with ind %d, result %d, num %d",
                    handle, indication, result, num_filters);

    if(pan_cb.pan_pfilt_ind_cb)
    {
        (*pan_cb.pan_pfilt_ind_cb)(handle, indication, result, num_filters, p_filters);
    }
}


/*******************************************************************************
**
** Function         pan_mcast_filt_ind_cb
**
** Description      This function is registered with BNEP as mcast filter indication
**                  callback. BNEP will call this when the peer sends any multicast
**                  filter set for the connection or to indicate the result of the
**                  multicast filter set by the local device
**
** Parameters:      handle      - handle for the connection
**                  indication  - TRUE if this is indication
**                                FALSE if it is called to give the result of local
**                                      device multicast filter set
**                  result      - This gives the result of the filter set operation
**                  num_filters - number of filters set by the peer device
**                  p_filters   - pointer to the filters set by the peer device
**
** Returns          none
**
*******************************************************************************/
void pan_mcast_filt_ind_cb(uint16_t handle,
                           uint8_t indication,
                           tBNEP_RESULT result,
                           uint16_t num_filters,
                           uint8_t *p_filters)
{
    PAN_TRACE_EVENT("pan_mcast_filt_ind_cb - called for handle %d with ind %d, result %d, num %d",
                    handle, indication, result, num_filters);

    if(pan_cb.pan_mfilt_ind_cb)
    {
        (*pan_cb.pan_mfilt_ind_cb)(handle, indication, result, num_filters, p_filters);
    }
}
#endif
