stack/pan/pan_main.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 1999-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This file contains main functions to support PAN profile
  22  *  commands and events.
  23  *
  24  ******************************************************************************/
  25
  26 #include <string.h>
  27 #include "bt_common.h"
  28 #include "bt_types.h"
  29 #include "bt_utils.h"
  30 #include "bnep_api.h"
  31 #include "pan_api.h"
  32 #include "pan_int.h"
  33 #include "sdp_api.h"
  34 #include "sdpdefs.h"
  35 #include "l2c_api.h"
  36 #include "hcidefs.h"
  37
  38
  39 #if PAN_DYNAMIC_MEMORY == FALSE
  40 tPAN_CB  pan_cb;
  41 #endif
  42
  43 #define UUID_CONSTANT_PART  12
  44 UINT8 constant_pan_uuid[UUID_CONSTANT_PART] = {0, 0, 0x10, 0, 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb};
  45
  46
  47 /*******************************************************************************
  48 **
  49 ** Function         pan_register_with_bnep
  50 **
  51 ** Description      This function registers PAN profile with BNEP
  52 **
  53 ** Parameters:      none
  54 **
  55 ** Returns          none
  56 **
  57 *******************************************************************************/
  58 void pan_register_with_bnep (void)
  59 {
  60     tBNEP_REGISTER      reg_info;
  61
  62     memset (&reg_info, 0, sizeof (tBNEP_REGISTER));
  63
  64     reg_info.p_conn_ind_cb      = pan_conn_ind_cb;
  65     reg_info.p_conn_state_cb    = pan_connect_state_cb;
  66     reg_info.p_data_buf_cb      = pan_data_buf_ind_cb;
  67     reg_info.p_data_ind_cb      = NULL;
  68     reg_info.p_tx_data_flow_cb  = pan_tx_data_flow_cb;
  69     reg_info.p_filter_ind_cb    = pan_proto_filt_ind_cb;
  70     reg_info.p_mfilter_ind_cb   = pan_mcast_filt_ind_cb;
  71
  72     BNEP_Register (&reg_info);
  73 }
  74
  75
  76 /*******************************************************************************
  77 **
  78 ** Function         pan_conn_ind_cb
  79 **
  80 ** Description      This function is registered with BNEP as connection indication
  81 **                  callback. BNEP will call this when there is connection
  82 **                  request from the peer. PAN should call BNEP_ConnectResp to
  83 **                  indicate whether to accept the connection or reject
  84 **
  85 ** Parameters:      handle          - handle for the connection
  86 **                  p_bda           - BD Addr of the peer requesting the connection
  87 **                  remote_uuid     - UUID of the source role (peer device role)
  88 **                  local_uuid      - UUID of the destination role (local device role)
  89 **                  is_role_change  - Flag to indicate that it is a role change
  90 **
  91 ** Returns          none
  92 **
  93 *******************************************************************************/
  94 void pan_conn_ind_cb (UINT16 handle,
  95                       BD_ADDR p_bda,
  96                       tBT_UUID *remote_uuid,
  97                       tBT_UUID *local_uuid,
  98                       BOOLEAN is_role_change)
  99 {
 100     tPAN_CONN       *pcb;
 101     UINT8           req_role;
 102     BOOLEAN         wrong_uuid;
 103
 104     /*
 105     ** If we are in GN or NAP role and have one or more
 106     ** active connections and the received connection is
 107     ** for user role reject it.
 108     ** If we are in user role with one connection active
 109     ** reject the connection.
 110     ** Allocate PCB and store the parameters
 111     ** Make bridge request to the host system if connection
 112     ** is for NAP
 113     */
 114     wrong_uuid = FALSE;
 115     if (remote_uuid->len == 16)
 116     {
 117         /*
 118         ** If the UUID is 16 bytes forst two bytes should be zeros
 119         ** and last 12 bytes should match the spec defined constant value
 120         */
 121         if (memcmp (constant_pan_uuid, remote_uuid->uu.uuid128 + 4, UUID_CONSTANT_PART))
 122             wrong_uuid = TRUE;
 123
 124         if (remote_uuid->uu.uuid128[0] || remote_uuid->uu.uuid128[1])
 125             wrong_uuid = TRUE;
 126
 127         /* Extract the 16 bit equivalent of the UUID */
 128         remote_uuid->uu.uuid16 = (UINT16)((remote_uuid->uu.uuid128[2] << 8) | remote_uuid->uu.uuid128[3]);
 129         remote_uuid->len = 2;
 130     }
 131     if (remote_uuid->len == 4)
 132     {
 133         /* First two bytes should be zeros */
 134         if (remote_uuid->uu.uuid32 & 0xFFFF0000)
 135             wrong_uuid = TRUE;
 136
 137         remote_uuid->uu.uuid16 = (UINT16)remote_uuid->uu.uuid32;
 138         remote_uuid->len = 2;
 139     }
 140
 141     if (wrong_uuid)
 142     {
 143         PAN_TRACE_ERROR ("PAN Connection failed because of wrong remote UUID ");
 144         BNEP_ConnectResp (handle, BNEP_CONN_FAILED_SRC_UUID);
 145         return;
 146     }
 147
 148     wrong_uuid = FALSE;
 149     if (local_uuid->len == 16)
 150     {
 151         /*
 152         ** If the UUID is 16 bytes forst two bytes should be zeros
 153         ** and last 12 bytes should match the spec defined constant value
 154         */
 155         if (memcmp (constant_pan_uuid, local_uuid->uu.uuid128 + 4, UUID_CONSTANT_PART))
 156             wrong_uuid = TRUE;
 157
 158         if (local_uuid->uu.uuid128[0] || local_uuid->uu.uuid128[1])
 159             wrong_uuid = TRUE;
 160
 161         /* Extract the 16 bit equivalent of the UUID */
 162         local_uuid->uu.uuid16 = (UINT16)((local_uuid->uu.uuid128[2] << 8) | local_uuid->uu.uuid128[3]);
 163         local_uuid->len = 2;
 164     }
 165     if (local_uuid->len == 4)
 166     {
 167         /* First two bytes should be zeros */
 168         if (local_uuid->uu.uuid32 & 0xFFFF0000)
 169             wrong_uuid = TRUE;
 170
 171         local_uuid->uu.uuid16 = (UINT16)local_uuid->uu.uuid32;
 172         local_uuid->len = 2;
 173     }
 174
 175     if (wrong_uuid)
 176     {
 177         PAN_TRACE_ERROR ("PAN Connection failed because of wrong local UUID ");
 178         BNEP_ConnectResp (handle, BNEP_CONN_FAILED_DST_UUID);
 179         return;
 180     }
 181
 182     PAN_TRACE_EVENT ("pan_conn_ind_cb - for handle %d, current role %d, dst uuid 0x%x, src uuid 0x%x, role change %s",
 183         handle, pan_cb.role, local_uuid->uu.uuid16, remote_uuid->uu.uuid16, is_role_change?"YES":"NO");
 184     /* The acceptable UUID size is only 2 */
 185     if (remote_uuid->len != 2)
 186     {
 187         PAN_TRACE_ERROR ("PAN Connection failed because of wrong UUID size %d", remote_uuid->len);
 188         BNEP_ConnectResp (handle, BNEP_CONN_FAILED_UUID_SIZE);
 189         return;
 190     }
 191
 192     /* Check if the source UUID is a valid one */
 193     if (remote_uuid->uu.uuid16 != UUID_SERVCLASS_PANU &&
 194         remote_uuid->uu.uuid16 != UUID_SERVCLASS_NAP &&
 195         remote_uuid->uu.uuid16 != UUID_SERVCLASS_GN)
 196     {
 197         PAN_TRACE_ERROR ("Src UUID 0x%x is not valid", remote_uuid->uu.uuid16);
 198         BNEP_ConnectResp (handle, BNEP_CONN_FAILED_SRC_UUID);
 199         return;
 200     }
 201
 202     /* Check if the destination UUID is a valid one */
 203     if (local_uuid->uu.uuid16 != UUID_SERVCLASS_PANU &&
 204         local_uuid->uu.uuid16 != UUID_SERVCLASS_NAP &&
 205         local_uuid->uu.uuid16 != UUID_SERVCLASS_GN)
 206     {
 207         PAN_TRACE_ERROR ("Dst UUID 0x%x is not valid", remote_uuid->uu.uuid16);
 208         BNEP_ConnectResp (handle, BNEP_CONN_FAILED_DST_UUID);
 209         return;
 210     }
 211
 212     /* Check if currently we support the destination role requested */
 213     if (((!(pan_cb.role & UUID_SERVCLASS_PANU))
 214         && local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU) ||
 215         ((!(pan_cb.role & UUID_SERVCLASS_GN))
 216         && local_uuid->uu.uuid16 == UUID_SERVCLASS_GN) ||
 217         ((!(pan_cb.role & UUID_SERVCLASS_NAP))
 218         && local_uuid->uu.uuid16 == UUID_SERVCLASS_NAP))
 219     {
 220         PAN_TRACE_ERROR ("PAN Connection failed because of unsupported destination UUID 0x%x", local_uuid->uu.uuid16);
 221         BNEP_ConnectResp (handle, BNEP_CONN_FAILED_DST_UUID);
 222         return;
 223     }
 224
 225     /* Requested destination role is */
 226     if (local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU)
 227         req_role = PAN_ROLE_CLIENT;
 228     else if (local_uuid->uu.uuid16 == UUID_SERVCLASS_GN)
 229         req_role = PAN_ROLE_GN_SERVER;
 230     else
 231         req_role = PAN_ROLE_NAP_SERVER;
 232
 233     /* If the connection indication is for the existing connection
 234     ** Check if the new destination role is acceptable
 235     */
 236     pcb = pan_get_pcb_by_handle (handle);
 237     if (pcb)
 238     {
 239         if (pan_cb.num_conns > 1 && local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU)
 240         {
 241             /* There are connections other than this one
 242             ** so we cann't accept PANU role. Reject
 243             */
 244             PAN_TRACE_ERROR ("Dst UUID should be either GN or NAP only because there are other connections");
 245             BNEP_ConnectResp (handle, BNEP_CONN_FAILED_DST_UUID);
 246             return;
 247         }
 248
 249         /* If it is already in connected state check for bridging status */
 250         if (pcb->con_state == PAN_STATE_CONNECTED)
 251         {
 252             PAN_TRACE_EVENT ("PAN Role changing New Src 0x%x Dst 0x%x",
 253                 remote_uuid->uu.uuid16, local_uuid->uu.uuid16);
 254
 255             pcb->prv_src_uuid = pcb->src_uuid;
 256             pcb->prv_dst_uuid = pcb->dst_uuid;
 257
 258             if (pcb->src_uuid == UUID_SERVCLASS_NAP &&
 259                 local_uuid->uu.uuid16 != UUID_SERVCLASS_NAP)
 260             {
 261                 /* Remove bridging */
 262                 if (pan_cb.pan_bridge_req_cb)
 263                     (*pan_cb.pan_bridge_req_cb) (pcb->rem_bda, FALSE);
 264             }
 265         }
 266         /* Set the latest active PAN role */
 267         pan_cb.active_role = req_role;
 268         pcb->src_uuid = local_uuid->uu.uuid16;
 269         pcb->dst_uuid = remote_uuid->uu.uuid16;
 270         BNEP_ConnectResp (handle, BNEP_SUCCESS);
 271         return;
 272     }
 273     else
 274     {
 275         /* If this a new connection and destination is PANU role and
 276         ** we already have a connection then reject the request.
 277         ** If we have a connection in PANU role then reject it
 278         */
 279         if (pan_cb.num_conns &&
 280             (local_uuid->uu.uuid16 == UUID_SERVCLASS_PANU ||
 281             pan_cb.active_role == PAN_ROLE_CLIENT))
 282         {
 283             PAN_TRACE_ERROR ("PAN already have a connection and can't be user");
 284             BNEP_ConnectResp (handle, BNEP_CONN_FAILED_DST_UUID);
 285             return;
 286         }
 287     }
 288
 289     /* This is a new connection */
 290     PAN_TRACE_DEBUG ("New connection indication for handle %d", handle);
 291     pcb = pan_allocate_pcb (p_bda, handle);
 292     if (!pcb)
 293     {
 294         PAN_TRACE_ERROR ("PAN no control block for new connection");
 295         BNEP_ConnectResp (handle, BNEP_CONN_FAILED);
 296         return;
 297     }
 298
 299     PAN_TRACE_EVENT ("PAN connection destination UUID is 0x%x", local_uuid->uu.uuid16);
 300     /* Set the latest active PAN role */
 301     pan_cb.active_role = req_role;
 302     pcb->src_uuid = local_uuid->uu.uuid16;
 303     pcb->dst_uuid = remote_uuid->uu.uuid16;
 304     pcb->con_state = PAN_STATE_CONN_START;
 305     pan_cb.num_conns++;
 306
 307     BNEP_ConnectResp (handle, BNEP_SUCCESS);
 308     return;
 309 }
 310
 311
 312 /*******************************************************************************
 313 **
 314 ** Function         pan_connect_state_cb
 315 **
 316 ** Description      This function is registered with BNEP as connection state
 317 **                  change callback. BNEP will call this when the connection
 318 **                  is established successfully or terminated
 319 **
 320 ** Parameters:      handle      - handle for the connection given in the connection
 321 **                                      indication callback
 322 **                  rem_bda     - remote device bd addr
 323 **                  result      - indicates whether the connection is up or down
 324 **                                      BNEP_SUCCESS if the connection is up
 325 **                                      all other values indicates appropriate errors
 326 **                  is_role_change - flag to indicate that it is a role change
 327 **
 328 ** Returns          none
 329 **
 330 *******************************************************************************/
 331 void pan_connect_state_cb (UINT16 handle, BD_ADDR rem_bda, tBNEP_RESULT result, BOOLEAN is_role_change)
 332 {
 333     tPAN_CONN       *pcb;
 334     UINT8            peer_role;
 335     UNUSED(rem_bda);
 336
 337     PAN_TRACE_EVENT ("pan_connect_state_cb - for handle %d, result %d", handle, result);
 338     pcb = pan_get_pcb_by_handle (handle);
 339     if (!pcb)
 340     {
 341         PAN_TRACE_ERROR ("PAN State change indication for wrong handle %d", handle);
 342         return;
 343     }
 344
 345     /* If the connection is getting terminated remove bridging */
 346     if (result != BNEP_SUCCESS)
 347     {
 348         /* Inform the application that connection is down */
 349         if (pan_cb.pan_conn_state_cb)
 350             (*pan_cb.pan_conn_state_cb) (pcb->handle, pcb->rem_bda, result, is_role_change, PAN_ROLE_INACTIVE, PAN_ROLE_INACTIVE);
 351
 352         /* Check if this failure is for role change only */
 353         if (pcb->con_state != PAN_STATE_CONNECTED &&
 354             (pcb->con_flags & PAN_FLAGS_CONN_COMPLETED))
 355         {
 356             /* restore the original values */
 357             PAN_TRACE_EVENT ("restoring the connection state to active");
 358             pcb->con_state = PAN_STATE_CONNECTED;
 359             pcb->con_flags &= (~PAN_FLAGS_CONN_COMPLETED);
 360
 361             pcb->src_uuid = pcb->prv_src_uuid;
 362             pcb->dst_uuid = pcb->prv_dst_uuid;
 363             pan_cb.active_role = pan_cb.prv_active_role;
 364
 365             if ((pcb->src_uuid == UUID_SERVCLASS_NAP) && pan_cb.pan_bridge_req_cb)
 366                 (*pan_cb.pan_bridge_req_cb) (pcb->rem_bda, TRUE);
 367
 368             return;
 369         }
 370
 371         if (pcb->con_state == PAN_STATE_CONNECTED)
 372         {
 373             /* If the connections destination role is NAP remove bridging */
 374             if ((pcb->src_uuid == UUID_SERVCLASS_NAP) && pan_cb.pan_bridge_req_cb)
 375                 (*pan_cb.pan_bridge_req_cb) (pcb->rem_bda, FALSE);
 376         }
 377
 378         pan_cb.num_conns--;
 379         pan_release_pcb (pcb);
 380         return;
 381     }
 382
 383     /* Requested destination role is */
 384     if (pcb->src_uuid == UUID_SERVCLASS_PANU)
 385         pan_cb.active_role = PAN_ROLE_CLIENT;
 386     else if (pcb->src_uuid == UUID_SERVCLASS_GN)
 387         pan_cb.active_role = PAN_ROLE_GN_SERVER;
 388     else
 389         pan_cb.active_role = PAN_ROLE_NAP_SERVER;
 390
 391     if (pcb->dst_uuid == UUID_SERVCLASS_PANU)
 392         peer_role = PAN_ROLE_CLIENT;
 393     else if (pcb->dst_uuid == UUID_SERVCLASS_GN)
 394         peer_role = PAN_ROLE_GN_SERVER;
 395     else
 396         peer_role = PAN_ROLE_NAP_SERVER;
 397
 398     pcb->con_state = PAN_STATE_CONNECTED;
 399
 400     /* Inform the application that connection is down */
 401     if (pan_cb.pan_conn_state_cb)
 402         (*pan_cb.pan_conn_state_cb) (pcb->handle, pcb->rem_bda, PAN_SUCCESS, is_role_change, pan_cb.active_role, peer_role);
 403
 404     /* Create bridge if the destination role is NAP */
 405     if (pan_cb.pan_bridge_req_cb && pcb->src_uuid == UUID_SERVCLASS_NAP)
 406     {
 407         PAN_TRACE_EVENT ("PAN requesting for bridge");
 408         (*pan_cb.pan_bridge_req_cb) (pcb->rem_bda, TRUE);
 409     }
 410 }
 411
 412
 413 /*******************************************************************************
 414 **
 415 ** Function         pan_data_ind_cb
 416 **
 417 ** Description      This function is registered with BNEP as data indication
 418 **                  callback. BNEP will call this when the peer sends any data
 419 **                  on this connection
 420 **
 421 ** Parameters:      handle      - handle for the connection
 422 **                  src         - source BD Addr
 423 **                  dst         - destination BD Addr
 424 **                  protocol    - Network protocol of the Eth packet
 425 **                  p_data      - pointer to the data
 426 **                  len         - length of the data
 427 **                  fw_ext_present - to indicate whether the data contains any
 428 **                                         extension headers before the payload
 429 **
 430 ** Returns          none
 431 **
 432 *******************************************************************************/
 433 void pan_data_ind_cb (UINT16 handle,
 434                       UINT8 *src,
 435                       UINT8 *dst,
 436                       UINT16 protocol,
 437                       UINT8 *p_data,
 438                       UINT16 len,
 439                       BOOLEAN ext)
 440 {
 441     tPAN_CONN       *pcb;
 442     UINT16          i;
 443     BOOLEAN         forward;
 444
 445     /*
 446     ** Check the connection status
 447     ** If the destination address is MAC broadcast send on all links
 448     ** except on the one received
 449     ** If the destination uuid is for NAP send to host system also
 450     ** If the destination address is one of the devices connected
 451     ** send the packet to over that link
 452     ** If the destination address is unknown and destination uuid is NAP
 453     ** send it to the host system
 454     */
 455
 456     PAN_TRACE_EVENT ("pan_data_ind_cb - for handle %d", handle);
 457     pcb = pan_get_pcb_by_handle (handle);
 458     if (!pcb)
 459     {
 460         PAN_TRACE_ERROR ("PAN Data indication for wrong handle %d", handle);
 461         return;
 462     }
 463
 464     if (pcb->con_state != PAN_STATE_CONNECTED)
 465     {
 466         PAN_TRACE_ERROR ("PAN Data indication in wrong state %d for handle %d",
 467             pcb->con_state, handle);
 468         return;
 469     }
 470
 471     /* Check if it is broadcast packet */
 472     if (dst[0] & 0x01)
 473     {
 474         PAN_TRACE_DEBUG ("PAN received broadcast packet on handle %d, src uuid 0x%x",
 475             handle, pcb->src_uuid);
 476         for (i=0; i<MAX_PAN_CONNS; i++)
 477         {
 478             if (pan_cb.pcb[i].con_state == PAN_STATE_CONNECTED &&
 479                 pan_cb.pcb[i].handle != handle &&
 480                 pcb->src_uuid == pan_cb.pcb[i].src_uuid)
 481             {
 482                 BNEP_Write (pan_cb.pcb[i].handle, dst, p_data, len, protocol, src, ext);
 483             }
 484         }
 485
 486         if (pan_cb.pan_data_ind_cb)
 487             (*pan_cb.pan_data_ind_cb) (pcb->handle, src, dst, protocol, p_data, len, ext, TRUE);
 488
 489         return;
 490     }
 491
 492     /* Check if it is for any other PAN connection */
 493     for (i=0; i<MAX_PAN_CONNS; i++)
 494     {
 495         if (pan_cb.pcb[i].con_state == PAN_STATE_CONNECTED &&
 496             pcb->src_uuid == pan_cb.pcb[i].src_uuid)
 497         {
 498             if (memcmp (pan_cb.pcb[i].rem_bda, dst, BD_ADDR_LEN) == 0)
 499             {
 500                 BNEP_Write (pan_cb.pcb[i].handle, dst, p_data, len, protocol, src, ext);
 501                 return;
 502             }
 503         }
 504     }
 505
 506    if (pcb->src_uuid == UUID_SERVCLASS_NAP)
 507        forward = TRUE;
 508    else
 509        forward = FALSE;
 510
 511     /* Send it over the LAN or give it to host software */
 512     if (pan_cb.pan_data_ind_cb)
 513         (*pan_cb.pan_data_ind_cb) (pcb->handle, src, dst, protocol, p_data, len, ext, forward);
 514
 515     return;
 516 }
 517
 518
 519 /*******************************************************************************
 520 **
 521 ** Function         pan_data_buf_ind_cb
 522 **
 523 ** Description      This function is registered with BNEP as data buffer indication
 524 **                  callback. BNEP will call this when the peer sends any data
 525 **                  on this connection. PAN is responsible to release the buffer
 526 **
 527 ** Parameters:      handle      - handle for the connection
 528 **                  src         - source BD Addr
 529 **                  dst         - destination BD Addr
 530 **                  protocol    - Network protocol of the Eth packet
 531 **                  p_buf       - pointer to the data buffer
 532 **                  ext         - to indicate whether the data contains any
 533 **                                         extension headers before the payload
 534 **
 535 ** Returns          none
 536 **
 537 *******************************************************************************/
 538 void pan_data_buf_ind_cb (UINT16 handle,
 539                           UINT8 *src,
 540                           UINT8 *dst,
 541                           UINT16 protocol,
 542                           BT_HDR *p_buf,
 543                           BOOLEAN ext)
 544 {
 545     tPAN_CONN       *pcb, *dst_pcb;
 546     tBNEP_RESULT    result;
 547     UINT16          i, len;
 548     UINT8           *p_data;
 549     BOOLEAN         forward = FALSE;
 550
 551     /* Check if the connection is in right state */
 552     pcb = pan_get_pcb_by_handle (handle);
 553     if (!pcb)
 554     {
 555         PAN_TRACE_ERROR ("PAN Data buffer indication for wrong handle %d", handle);
 556         osi_freebuf (p_buf);
 557         return;
 558     }
 559
 560     if (pcb->con_state != PAN_STATE_CONNECTED)
 561     {
 562         PAN_TRACE_ERROR ("PAN Data indication in wrong state %d for handle %d",
 563             pcb->con_state, handle);
 564         osi_freebuf (p_buf);
 565         return;
 566     }
 567
 568     p_data = (UINT8 *)(p_buf + 1) + p_buf->offset;
 569     len    = p_buf->len;
 570
 571     PAN_TRACE_EVENT ("pan_data_buf_ind_cb - for handle %d, protocol 0x%x, length %d, ext %d",
 572         handle, protocol, len, ext);
 573
 574    if (pcb->src_uuid == UUID_SERVCLASS_NAP)
 575        forward = TRUE;
 576    else
 577        forward = FALSE;
 578
 579     /* Check if it is broadcast or multicast packet */
 580     if (pcb->src_uuid != UUID_SERVCLASS_PANU)
 581     {
 582         if (dst[0] & 0x01)
 583         {
 584             PAN_TRACE_DEBUG ("PAN received broadcast packet on handle %d, src uuid 0x%x",
 585                 handle, pcb->src_uuid);
 586             for (i=0; i<MAX_PAN_CONNS; i++)
 587             {
 588                 if (pan_cb.pcb[i].con_state == PAN_STATE_CONNECTED &&
 589                     pan_cb.pcb[i].handle != handle &&
 590                     pcb->src_uuid == pan_cb.pcb[i].src_uuid)
 591                 {
 592                     BNEP_Write (pan_cb.pcb[i].handle, dst, p_data, len, protocol, src, ext);
 593                 }
 594             }
 595
 596             if (pan_cb.pan_data_buf_ind_cb)
 597                 (*pan_cb.pan_data_buf_ind_cb) (pcb->handle, src, dst, protocol, p_buf, ext, forward);
 598             else if (pan_cb.pan_data_ind_cb)
 599             {
 600                 (*pan_cb.pan_data_ind_cb) (pcb->handle, src, dst, protocol, p_data, len, ext, forward);
 601                 osi_freebuf (p_buf);
 602             }
 603
 604             return;
 605         }
 606
 607         /* Check if it is for any other PAN connection */
 608         dst_pcb = pan_get_pcb_by_addr (dst);
 609         if (dst_pcb)
 610         {
 611             PAN_TRACE_EVENT ("%s - destination PANU found on handle %d and sending data, len: %d",
 612                 __func__, dst_pcb->handle, len);
 613
 614             result = BNEP_Write (dst_pcb->handle, dst, p_data, len, protocol, src, ext);
 615             if (result != BNEP_SUCCESS && result != BNEP_IGNORE_CMD)
 616                 PAN_TRACE_ERROR ("Failed to write data for PAN connection handle %d", dst_pcb->handle);
 617             osi_freebuf (p_buf);
 618             return;
 619         }
 620     }
 621
 622     /* Send it over the LAN or give it to host software */
 623     if (pan_cb.pan_data_buf_ind_cb)
 624         (*pan_cb.pan_data_buf_ind_cb) (pcb->handle, src, dst, protocol, p_buf, ext, forward);
 625     else if (pan_cb.pan_data_ind_cb)
 626     {
 627         (*pan_cb.pan_data_ind_cb) (pcb->handle, src, dst, protocol, p_data, len, ext, forward);
 628         osi_freebuf (p_buf);
 629     }
 630     else
 631         osi_freebuf (p_buf);
 632
 633     return;
 634 }
 635
 636 /*******************************************************************************
 637 **
 638 ** Function         pan_proto_filt_ind_cb
 639 **
 640 ** Description      This function is registered with BNEP to receive tx data
 641 **                                      flow status
 642 **
 643 ** Parameters:      handle      - handle for the connection
 644 **                                      event       - flow status
 645 **
 646 ** Returns          none
 647 **
 648 *******************************************************************************/
 649 void pan_tx_data_flow_cb (UINT16 handle,
 650                             tBNEP_RESULT  event)
 651 {
 652
 653     if (pan_cb.pan_tx_data_flow_cb)
 654         (*pan_cb.pan_tx_data_flow_cb) (handle, event);
 655
 656     return;
 657 }
 658
 659 /*******************************************************************************
 660 **
 661 ** Function         pan_proto_filt_ind_cb
 662 **
 663 ** Description      This function is registered with BNEP as proto filter indication
 664 **                  callback. BNEP will call this when the peer sends any protocol
 665 **                  filter set for the connection or to indicate the result of the
 666 **                  protocol filter set by the local device
 667 **
 668 ** Parameters:      handle      - handle for the connection
 669 **                  indication  - TRUE if this is indication
 670 **                                FALSE if it is called to give the result of local
 671 **                                      device protocol filter set
 672 **                  result      - This gives the result of the filter set operation
 673 **                  num_filters - number of filters set by the peer device
 674 **                  p_filters   - pointer to the filters set by the peer device
 675 **
 676 ** Returns          none
 677 **
 678 *******************************************************************************/
 679 void pan_proto_filt_ind_cb (UINT16 handle,
 680                             BOOLEAN indication,
 681                             tBNEP_RESULT result,
 682                             UINT16 num_filters,
 683                             UINT8 *p_filters)
 684 {
 685     PAN_TRACE_EVENT ("pan_proto_filt_ind_cb - called for handle %d with ind %d, result %d, num %d",
 686                             handle, indication, result, num_filters);
 687
 688     if (pan_cb.pan_pfilt_ind_cb)
 689         (*pan_cb.pan_pfilt_ind_cb) (handle, indication, result, num_filters, p_filters);
 690 }
 691
 692
 693 /*******************************************************************************
 694 **
 695 ** Function         pan_mcast_filt_ind_cb
 696 **
 697 ** Description      This function is registered with BNEP as mcast filter indication
 698 **                  callback. BNEP will call this when the peer sends any multicast
 699 **                  filter set for the connection or to indicate the result of the
 700 **                  multicast filter set by the local device
 701 **
 702 ** Parameters:      handle      - handle for the connection
 703 **                  indication  - TRUE if this is indication
 704 **                                FALSE if it is called to give the result of local
 705 **                                      device multicast filter set
 706 **                  result      - This gives the result of the filter set operation
 707 **                  num_filters - number of filters set by the peer device
 708 **                  p_filters   - pointer to the filters set by the peer device
 709 **
 710 ** Returns          none
 711 **
 712 *******************************************************************************/
 713 void pan_mcast_filt_ind_cb (UINT16 handle,
 714                             BOOLEAN indication,
 715                             tBNEP_RESULT result,
 716                             UINT16 num_filters,
 717                             UINT8 *p_filters)
 718 {
 719     PAN_TRACE_EVENT ("pan_mcast_filt_ind_cb - called for handle %d with ind %d, result %d, num %d",
 720                             handle, indication, result, num_filters);
 721
 722     if (pan_cb.pan_mfilt_ind_cb)
 723         (*pan_cb.pan_mfilt_ind_cb) (handle, indication, result, num_filters, p_filters);
 724 }