1 /****************************************************************************** 2 * 3 * Copyright (C) 2009-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 * Filename: btif_pan.c 22 * 23 * Description: PAN Profile Bluetooth Interface 24 * 25 * 26 ***********************************************************************************/ 27 #include <hardware/bluetooth.h> 28 #include <hardware/bt_pan.h> 29 #include <assert.h> 30 #include <signal.h> 31 #include <ctype.h> 32 #include <sys/select.h> 33 #include <sys/poll.h> 34 #include <sys/ioctl.h> 35 #include <netinet/in.h> 36 #include <netdb.h> 37 #include <stdio.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <sys/socket.h> 41 #include <sys/wait.h> 42 #include <net/if.h> 43 #include <linux/sockios.h> 44 #include <sys/prctl.h> 45 #include <linux/if.h> 46 #include <linux/if_tun.h> 47 #include <linux/if_ether.h> 48 49 #define LOG_TAG "BTIF_PAN" 50 #include "btif_common.h" 51 #include "btif_util.h" 52 #include "btm_api.h" 53 #include "bd.h" 54 55 #include "bta_api.h" 56 #include "bta_pan_api.h" 57 #include "btif_sock_thread.h" 58 #include "btif_sock_util.h" 59 #include "btif_pan_internal.h" 60 #include "gki.h" 61 62 #define FORWARD_IGNORE 1 63 #define FORWARD_SUCCESS 0 64 #define FORWARD_FAILURE (-1) 65 #define FORWARD_CONGEST (-2) 66 //#define PANU_DISABLED TRUE 67 68 #if (PAN_NAP_DISABLED == TRUE) && (PANU_DISABLED == TRUE) 69 #define BTPAN_LOCAL_ROLE BTPAN_ROLE_NONE 70 #elif PAN_NAP_DISABLED == TRUE 71 #define BTPAN_LOCAL_ROLE BTPAN_ROLE_PANU 72 #elif PANU_DISABLED == TRUE 73 #define BTPAN_LOCAL_ROLE BTPAN_ROLE_PANNAP 74 #else 75 #define BTPAN_LOCAL_ROLE (BTPAN_ROLE_PANU | BTPAN_ROLE_PANNAP) 76 #endif 77 78 #define asrt(s) if(!(s)) BTIF_TRACE_ERROR("btif_pan: ## %s assert %s failed at line:%d ##",__FUNCTION__, #s, __LINE__) 79 80 #define MIN(x, y) (((x) < (y)) ? (x) : (y)) 81 82 btpan_cb_t btpan_cb; 83 84 BD_ADDR local_addr; 85 static int jni_initialized, stack_initialized; 86 static bt_status_t btpan_jni_init(const btpan_callbacks_t* callbacks); 87 static void btpan_jni_cleanup(); 88 static bt_status_t btpan_connect(const bt_bdaddr_t *bd_addr, int local_role, int remote_role); 89 static bt_status_t btpan_disconnect(const bt_bdaddr_t *bd_addr); 90 static bt_status_t btpan_enable(int local_role); 91 static int btpan_get_local_role(void); 92 93 static void btpan_tap_fd_signaled(int fd, int type, int flags, uint32_t user_id); 94 static void btpan_cleanup_conn(btpan_conn_t* conn); 95 static void bta_pan_callback(tBTA_PAN_EVT event, tBTA_PAN *p_data); 96 static void btu_exec_tap_fd_read(void *p_param); 97 98 static btpan_interface_t pan_if = { 99 sizeof(pan_if), 100 btpan_jni_init, 101 btpan_enable, 102 btpan_get_local_role, 103 btpan_connect, 104 btpan_disconnect, 105 btpan_jni_cleanup 106 }; 107 108 btpan_interface_t *btif_pan_get_interface() 109 { 110 return &pan_if; 111 } 112 113 /******************************************************************************* 114 ** 115 ** Function btif_pan_init 116 ** 117 ** Description initializes the pan interface 118 ** 119 ** Returns bt_status_t 120 ** 121 *******************************************************************************/ 122 void btif_pan_init() 123 { 124 BTIF_TRACE_DEBUG("jni_initialized = %d, btpan_cb.enabled:%d", jni_initialized, btpan_cb.enabled); 125 stack_initialized = TRUE; 126 if (jni_initialized && !btpan_cb.enabled) 127 { 128 BTIF_TRACE_DEBUG("Enabling PAN...."); 129 memset(&btpan_cb, 0, sizeof(btpan_cb)); 130 btpan_cb.tap_fd = -1; 131 btpan_cb.flow = 1; 132 int i; 133 for(i = 0; i < MAX_PAN_CONNS; i++) 134 btpan_cleanup_conn(&btpan_cb.conns[i]); 135 BTA_PanEnable(bta_pan_callback); 136 btpan_cb.enabled = 1; 137 btpan_enable(BTPAN_LOCAL_ROLE); 138 } 139 } 140 141 static void pan_disable() 142 { 143 if(btpan_cb.enabled) 144 { 145 btpan_cb.enabled = 0; 146 BTA_PanDisable(); 147 if(btpan_cb.tap_fd != -1) 148 { 149 btpan_tap_close(btpan_cb.tap_fd); 150 btpan_cb.tap_fd = -1; 151 } 152 } 153 } 154 155 void btif_pan_cleanup() 156 { 157 if(stack_initialized) 158 { 159 //bt is shuting down, invalid all bta pan handles 160 int i; 161 for(i = 0; i < MAX_PAN_CONNS; i++) 162 btpan_cleanup_conn(&btpan_cb.conns[i]); 163 pan_disable(); 164 } 165 stack_initialized = FALSE; 166 } 167 168 static btpan_callbacks_t callback; 169 static bt_status_t btpan_jni_init(const btpan_callbacks_t* callbacks) 170 { 171 BTIF_TRACE_DEBUG("stack_initialized = %d, btpan_cb.enabled:%d", stack_initialized, btpan_cb.enabled); 172 jni_initialized = TRUE; 173 if(stack_initialized && !btpan_cb.enabled) 174 btif_pan_init(); 175 callback = *callbacks; 176 return BT_STATUS_SUCCESS; 177 } 178 179 static void btpan_jni_cleanup() 180 { 181 pan_disable(); 182 jni_initialized = FALSE; 183 } 184 185 static inline int bta_role_to_btpan(int bta_pan_role) 186 { 187 int btpan_role = 0; 188 BTIF_TRACE_DEBUG("bta_pan_role:0x%x", bta_pan_role); 189 if(bta_pan_role & PAN_ROLE_NAP_SERVER) 190 { 191 btpan_role |= BTPAN_ROLE_PANNAP; 192 } 193 if(bta_pan_role & PAN_ROLE_CLIENT) 194 { 195 btpan_role |= BTPAN_ROLE_PANU; 196 } 197 return btpan_role; 198 } 199 200 static inline int btpan_role_to_bta(int btpan_role) 201 { 202 int bta_pan_role = PAN_ROLE_INACTIVE; 203 BTIF_TRACE_DEBUG("btpan_role:0x%x", btpan_role); 204 if(btpan_role & BTPAN_ROLE_PANNAP) 205 { 206 bta_pan_role |= PAN_ROLE_NAP_SERVER; 207 } 208 if(btpan_role & BTPAN_ROLE_PANU) 209 { 210 bta_pan_role |= PAN_ROLE_CLIENT; 211 } 212 return bta_pan_role; 213 } 214 215 static volatile int btpan_dev_local_role; 216 static tBTA_PAN_ROLE_INFO bta_panu_info = {PANU_SERVICE_NAME, 0, PAN_SECURITY}; 217 static tBTA_PAN_ROLE_INFO bta_pan_nap_info = {PAN_NAP_SERVICE_NAME, 1, PAN_SECURITY}; 218 219 static bt_status_t btpan_enable(int local_role) 220 { 221 int bta_pan_role; 222 BTIF_TRACE_DEBUG("local_role:%d", local_role); 223 bta_pan_role = btpan_role_to_bta(local_role); 224 #if BTA_PAN_INCLUDED == TRUE 225 BTA_PanSetRole(bta_pan_role, &bta_panu_info, NULL, &bta_pan_nap_info); 226 btpan_dev_local_role = local_role; 227 return BT_STATUS_SUCCESS; 228 #else 229 return BT_STATUS_FAIL; 230 #endif 231 } 232 233 static int btpan_get_local_role() 234 { 235 BTIF_TRACE_DEBUG("btpan_dev_local_role:%d", btpan_dev_local_role); 236 return btpan_dev_local_role; 237 } 238 239 static bt_status_t btpan_connect(const bt_bdaddr_t *bd_addr, int local_role, int remote_role) 240 { 241 BTIF_TRACE_DEBUG("local_role:%d, remote_role:%d", local_role, remote_role); 242 int bta_local_role = btpan_role_to_bta(local_role); 243 int bta_remote_role = btpan_role_to_bta(remote_role); 244 btpan_new_conn(-1, bd_addr->address, bta_local_role, bta_remote_role); 245 BTA_PanOpen((UINT8*)bd_addr->address, bta_local_role, bta_remote_role); 246 return BT_STATUS_SUCCESS; 247 } 248 249 static void btif_in_pan_generic_evt(UINT16 event, char *p_param) 250 { 251 BTIF_TRACE_EVENT("%s: event=%d", __FUNCTION__, event); 252 switch (event) { 253 case BTIF_PAN_CB_DISCONNECTING: 254 { 255 bt_bdaddr_t *bd_addr = (bt_bdaddr_t*)p_param; 256 btpan_conn_t* conn = btpan_find_conn_addr(bd_addr->address); 257 int btpan_conn_local_role; 258 int btpan_remote_role; 259 asrt(conn != NULL); 260 if (conn) { 261 btpan_conn_local_role = bta_role_to_btpan(conn->local_role); 262 btpan_remote_role = bta_role_to_btpan(conn->remote_role); 263 callback.connection_state_cb(BTPAN_STATE_DISCONNECTING, BT_STATUS_SUCCESS, 264 (const bt_bdaddr_t*)conn->peer, btpan_conn_local_role, btpan_remote_role); 265 } 266 } break; 267 default: 268 { 269 BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __FUNCTION__, event); 270 } 271 break; 272 } 273 } 274 275 static bt_status_t btpan_disconnect(const bt_bdaddr_t *bd_addr) 276 { 277 btpan_conn_t* conn = btpan_find_conn_addr(bd_addr->address); 278 if(conn && conn->handle >= 0) 279 { 280 BTA_PanClose(conn->handle); 281 /* Inform the application that the disconnect has been initiated successfully */ 282 btif_transfer_context(btif_in_pan_generic_evt, BTIF_PAN_CB_DISCONNECTING, 283 (char *)bd_addr, sizeof(bt_bdaddr_t), NULL); 284 return BT_STATUS_SUCCESS; 285 } 286 return BT_STATUS_FAIL; 287 } 288 289 static int pan_pth = -1; 290 void create_tap_read_thread(int tap_fd) 291 { 292 if(pan_pth < 0) 293 pan_pth = btsock_thread_create(btpan_tap_fd_signaled, NULL); 294 if(pan_pth >= 0) 295 btsock_thread_add_fd(pan_pth, tap_fd, 0, SOCK_THREAD_FD_RD, 0); 296 } 297 298 void destroy_tap_read_thread(void) 299 { 300 if(pan_pth >= 0) 301 { 302 btsock_thread_exit(pan_pth); 303 pan_pth = -1; 304 } 305 } 306 307 static int tap_if_up(const char *devname, BD_ADDR addr) 308 { 309 struct ifreq ifr; 310 int sk, err; 311 312 sk = socket(AF_INET, SOCK_DGRAM, 0); 313 314 //set mac addr 315 memset(&ifr, 0, sizeof(ifr)); 316 strncpy(ifr.ifr_name, devname, IFNAMSIZ - 1); 317 err = ioctl(sk, SIOCGIFHWADDR, &ifr); 318 if(err < 0) 319 { 320 BTIF_TRACE_ERROR("Could not get network hardware for interface:%s, errno:%s", devname, strerror(errno)); 321 close(sk); 322 return -1; 323 } 324 /* debug("found mac address for interface:%s = %02x:%02x:%02x:%02x:%02x:%02x", devname, */ 325 /* ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], */ 326 /* ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]); */ 327 strncpy(ifr.ifr_name, devname, IFNAMSIZ - 1); 328 memcpy(ifr.ifr_hwaddr.sa_data, addr, 6); 329 /* debug("setting bt address for interface:%s = %02x:%02x:%02x:%02x:%02x:%02x", devname, */ 330 /* ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2], */ 331 /* ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]); */ 332 333 /* The IEEE has specified that the most significant bit of the most significant byte is used to 334 * determine a multicast address. If its a 1, that means multicast, 0 means unicast. 335 * Kernel returns an error if we try to set a multicast address for the tun-tap ethernet interface. 336 * Mask this bit to avoid any issue with auto generated address. 337 */ 338 if (ifr.ifr_hwaddr.sa_data[0] & 0x01) { 339 BTIF_TRACE_WARNING("Not a unicast MAC address, force multicast bit flipping"); 340 ifr.ifr_hwaddr.sa_data[0] &= ~0x01; 341 } 342 343 err = ioctl(sk, SIOCSIFHWADDR, (caddr_t)&ifr); 344 345 if (err < 0) { 346 BTIF_TRACE_ERROR("Could not set bt address for interface:%s, errno:%s", devname, strerror(errno)); 347 close(sk); 348 return -1; 349 } 350 351 //bring it up 352 memset(&ifr, 0, sizeof(ifr)); 353 strncpy(ifr.ifr_name, devname, IF_NAMESIZE - 1); 354 355 ifr.ifr_flags |= IFF_UP; 356 ifr.ifr_flags |= IFF_MULTICAST; 357 358 err = ioctl(sk, SIOCSIFFLAGS, (caddr_t) &ifr); 359 360 361 if (err < 0) { 362 BTIF_TRACE_ERROR("Could not bring up network interface:%s, errno:%d", devname, errno); 363 close(sk); 364 return -1; 365 } 366 close(sk); 367 BTIF_TRACE_DEBUG("network interface: %s is up", devname); 368 return 0; 369 } 370 371 static int tap_if_down(const char *devname) 372 { 373 struct ifreq ifr; 374 int sk, err; 375 376 sk = socket(AF_INET, SOCK_DGRAM, 0); 377 378 memset(&ifr, 0, sizeof(ifr)); 379 strncpy(ifr.ifr_name, devname, IF_NAMESIZE - 1); 380 381 ifr.ifr_flags &= ~IFF_UP; 382 383 err = ioctl(sk, SIOCSIFFLAGS, (caddr_t) &ifr); 384 385 close(sk); 386 387 return 0; 388 } 389 390 void btpan_set_flow_control(BOOLEAN enable) { 391 if (btpan_cb.tap_fd == -1) 392 return; 393 394 btpan_cb.flow = enable; 395 if (enable) { 396 btsock_thread_add_fd(pan_pth, btpan_cb.tap_fd, 0, SOCK_THREAD_FD_RD, 0); 397 bta_dmexecutecallback(btu_exec_tap_fd_read, (void *)btpan_cb.tap_fd); 398 } 399 } 400 401 int btpan_tap_open() 402 { 403 struct ifreq ifr; 404 int fd, err; 405 const char *clonedev = "/dev/tun"; 406 407 /* open the clone device */ 408 409 //system("insmod /system/lib/modules/tun.ko"); 410 if( (fd = open(clonedev, O_RDWR)) < 0 ) { 411 412 BTIF_TRACE_DEBUG("could not open %s, err:%d", clonedev, errno); 413 return fd; 414 } 415 416 memset(&ifr, 0, sizeof(ifr)); 417 ifr.ifr_flags = IFF_TAP | IFF_NO_PI; 418 419 strncpy(ifr.ifr_name, TAP_IF_NAME, IFNAMSIZ); 420 421 /* try to create the device */ 422 if( (err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0 )//|| tap_setup_ip(TAP_IF_NAME) == FALSE) 423 { 424 BTIF_TRACE_DEBUG("ioctl error:%d, errno:%s", err, strerror(errno)); 425 close(fd); 426 return err; 427 } 428 BTM_GetLocalDeviceAddr (local_addr); 429 if(tap_if_up(TAP_IF_NAME, local_addr) == 0) 430 { 431 int flags = fcntl(fd, F_GETFL, 0); 432 fcntl(fd, F_SETFL, flags | O_NONBLOCK); 433 return fd; 434 } 435 BTIF_TRACE_ERROR("can not bring up tap interface:%s", TAP_IF_NAME); 436 close(fd); 437 return -1; 438 } 439 440 int btpan_tap_send(int tap_fd, const BD_ADDR src, const BD_ADDR dst, UINT16 proto, const char* buf, 441 UINT16 len, BOOLEAN ext, BOOLEAN forward) 442 { 443 UNUSED(ext); 444 UNUSED(forward); 445 if(tap_fd != -1) 446 { 447 tETH_HDR eth_hdr; 448 //if(is_empty_eth_addr(dst)) 449 // memcpy(ð_hdr.h_dest, local_addr, ETH_ADDR_LEN); 450 //else 451 memcpy(ð_hdr.h_dest, dst, ETH_ADDR_LEN); 452 memcpy(ð_hdr.h_src, src, ETH_ADDR_LEN); 453 eth_hdr.h_proto = htons(proto); 454 char packet[2000]; 455 memcpy(packet, ð_hdr, sizeof(tETH_HDR)); 456 if(len > 2000) 457 { 458 ALOGE("btpan_tap_send eth packet size:%d is exceeded limit!", len); 459 return -1; 460 } 461 memcpy(packet + sizeof(tETH_HDR), buf, len); 462 463 /* Send data to network interface */ 464 //btnet_send(btpan_cb.conn[i].sock.sock, &buffer, (len + sizeof(tETH_HDR))); 465 //dump_bin("packet to network", packet, len + sizeof(tETH_HDR)); 466 int ret = write(tap_fd, packet, len + sizeof(tETH_HDR)); 467 BTIF_TRACE_DEBUG("ret:%d", ret); 468 return ret; 469 } 470 return -1; 471 472 } 473 474 int btpan_tap_close(int fd) 475 { 476 tap_if_down(TAP_IF_NAME); 477 close(fd); 478 if(pan_pth >= 0) 479 btsock_thread_wakeup(pan_pth); 480 return 0; 481 } 482 483 btpan_conn_t * btpan_find_conn_handle(UINT16 handle) 484 { 485 int i; 486 for(i = 0; i < MAX_PAN_CONNS; i++) 487 if(btpan_cb.conns[i].handle == handle) 488 return &btpan_cb.conns[i]; 489 return NULL; 490 } 491 492 btpan_conn_t* btpan_find_conn_addr(const BD_ADDR addr) 493 { 494 int i; 495 for(i = 0; i < MAX_PAN_CONNS; i++) 496 if(memcmp(btpan_cb.conns[i].peer, addr, sizeof(BD_ADDR)) == 0) 497 return &btpan_cb.conns[i]; 498 return NULL; 499 } 500 501 static void btpan_cleanup_conn(btpan_conn_t* conn) 502 { 503 if(conn) 504 { 505 conn->handle = -1; 506 conn->state = -1; 507 memset(&conn->peer, 0, sizeof(conn->peer)); 508 memset(&conn->eth_addr, 0, sizeof(conn->eth_addr)); 509 conn->local_role = conn->remote_role = 0; 510 } 511 } 512 513 btpan_conn_t* btpan_new_conn(int handle, const BD_ADDR addr, int local_role, int remote_role ) 514 { 515 int i; 516 for(i = 0; i < MAX_PAN_CONNS; i++) 517 { 518 BTIF_TRACE_DEBUG("conns[%d]:%d", i, btpan_cb.conns[i].handle); 519 if(btpan_cb.conns[i].handle == -1) 520 { 521 BTIF_TRACE_DEBUG("handle:%d, local_role:%d, remote_role:%d", handle, local_role, remote_role); 522 523 btpan_cb.conns[i].handle = handle; 524 bdcpy(btpan_cb.conns[i].peer, addr); 525 btpan_cb.conns[i].local_role = local_role; 526 btpan_cb.conns[i].remote_role = remote_role; 527 return &btpan_cb.conns[i]; 528 } 529 } 530 BTIF_TRACE_DEBUG("MAX_PAN_CONNS:%d exceeded, return NULL as failed", MAX_PAN_CONNS); 531 return NULL; 532 } 533 534 void btpan_close_handle(btpan_conn_t *p) 535 { 536 BTIF_TRACE_DEBUG("btpan_close_handle : close handle %d", p->handle); 537 p->handle = -1; 538 p->local_role = -1; 539 p->remote_role = -1; 540 memset(&p->peer, 0, 6); 541 } 542 543 static inline bool should_forward(tETH_HDR* hdr) 544 { 545 uint16_t proto = ntohs(hdr->h_proto); 546 if(proto == ETH_P_IP || proto == ETH_P_ARP || proto == ETH_P_IPV6) 547 return true; 548 BTIF_TRACE_DEBUG("unknown proto:%x", proto); 549 return false; 550 } 551 552 static int forward_bnep(tETH_HDR* eth_hdr, BT_HDR *hdr) { 553 int broadcast = eth_hdr->h_dest[0] & 1; 554 int i; 555 556 // Find the right connection to send this frame over. 557 for (i = 0; i < MAX_PAN_CONNS; i++) { 558 UINT16 handle = btpan_cb.conns[i].handle; 559 if (handle != (UINT16)-1 && 560 (broadcast || memcmp(btpan_cb.conns[i].eth_addr, eth_hdr->h_dest, sizeof(BD_ADDR)) == 0 561 || memcmp(btpan_cb.conns[i].peer, eth_hdr->h_dest, sizeof(BD_ADDR)) == 0)) { 562 int result = PAN_WriteBuf(handle, eth_hdr->h_dest, eth_hdr->h_src, ntohs(eth_hdr->h_proto), hdr, 0); 563 switch (result) { 564 case PAN_Q_SIZE_EXCEEDED: 565 return FORWARD_CONGEST; 566 case PAN_SUCCESS: 567 return FORWARD_SUCCESS; 568 default: 569 return FORWARD_FAILURE; 570 } 571 } 572 } 573 GKI_freebuf(hdr); 574 return FORWARD_IGNORE; 575 } 576 577 static void bta_pan_callback_transfer(UINT16 event, char *p_param) 578 { 579 tBTA_PAN *p_data = (tBTA_PAN *)p_param; 580 switch(event) 581 { 582 case BTA_PAN_ENABLE_EVT: 583 BTIF_TRACE_DEBUG("BTA_PAN_ENABLE_EVT"); 584 break; 585 case BTA_PAN_SET_ROLE_EVT: 586 { 587 int btpan_role = bta_role_to_btpan(p_data->set_role.role); 588 bt_status_t status = p_data->set_role.status == BTA_PAN_SUCCESS ? BT_STATUS_SUCCESS : BT_STATUS_FAIL; 589 btpan_control_state_t state = btpan_role == 0 ? BTPAN_STATE_DISABLED : BTPAN_STATE_ENABLED; 590 callback.control_state_cb(state, btpan_role, status, TAP_IF_NAME); 591 break; 592 } 593 case BTA_PAN_OPENING_EVT: 594 { 595 btpan_conn_t* conn; 596 bdstr_t bds; 597 bd2str((bt_bdaddr_t*)p_data->opening.bd_addr, &bds); 598 BTIF_TRACE_DEBUG("BTA_PAN_OPENING_EVT handle %d, addr: %s", p_data->opening.handle, bds); 599 conn = btpan_find_conn_addr(p_data->opening.bd_addr); 600 601 asrt(conn != NULL); 602 if (conn) 603 { 604 conn->handle = p_data->opening.handle; 605 int btpan_conn_local_role = bta_role_to_btpan(conn->local_role); 606 int btpan_remote_role = bta_role_to_btpan(conn->remote_role); 607 callback.connection_state_cb(BTPAN_STATE_CONNECTING, BT_STATUS_SUCCESS, 608 (const bt_bdaddr_t*)p_data->opening.bd_addr, btpan_conn_local_role, btpan_remote_role); 609 } 610 else 611 BTIF_TRACE_ERROR("connection not found"); 612 break; 613 } 614 case BTA_PAN_OPEN_EVT: 615 { 616 /* debug("BTA_PAN_OPEN_EVT, open status:%d, bd_addr = [%02X:%02X:%02X:%02X:%02X:%02X]", */ 617 /* p_data->open.status, */ 618 /* p_data->open.bd_addr[0], p_data->open.bd_addr[1], p_data->open.bd_addr[2], */ 619 /* p_data->open.bd_addr[3], p_data->open.bd_addr[4], p_data->open.bd_addr[5]); */ 620 btpan_connection_state_t state; 621 bt_status_t status; 622 btpan_conn_t *conn = btpan_find_conn_handle(p_data->open.handle); 623 624 ALOGV("%s pan connection open status: %d", __func__, p_data->open.status); 625 if(p_data->open.status == BTA_PAN_SUCCESS) 626 { 627 state = BTPAN_STATE_CONNECTED; 628 status = BT_STATUS_SUCCESS; 629 } 630 else 631 { 632 state = BTPAN_STATE_DISCONNECTED; 633 status = BT_STATUS_FAIL; 634 btpan_cleanup_conn(conn); 635 } 636 /* debug("BTA_PAN_OPEN_EVT handle:%d, conn:%p", p_data->open.handle, conn); */ 637 /* debug("conn bta local_role:%d, bta remote role:%d", conn->local_role, conn->remote_role); */ 638 int btpan_conn_local_role = bta_role_to_btpan(p_data->open.local_role); 639 /* debug("bta local_role:%d, bta remote role:%d", p_data->open.local_role, p_data->open.peer_role); */ 640 int btpan_remote_role = bta_role_to_btpan(p_data->open.peer_role); 641 callback.connection_state_cb(state, status, (const bt_bdaddr_t*)p_data->open.bd_addr, 642 btpan_conn_local_role, btpan_remote_role); 643 break; 644 } 645 case BTA_PAN_CLOSE_EVT: 646 { 647 btpan_conn_t* conn = btpan_find_conn_handle(p_data->close.handle); 648 649 ALOGI("%s: event = BTA_PAN_CLOSE_EVT handle %d", __FUNCTION__, p_data->close.handle); 650 651 if(conn && conn->handle >= 0) 652 { 653 /* debug("BTA_PAN_CLOSE_EVT, conn local_role:%d, remote_role:%d", conn->local_role, conn->remote_role); */ 654 int btpan_conn_local_role = bta_role_to_btpan(conn->local_role); 655 int btpan_remote_role = bta_role_to_btpan(conn->remote_role); 656 callback.connection_state_cb(BTPAN_STATE_DISCONNECTED, 0, (const bt_bdaddr_t*)conn->peer, 657 btpan_conn_local_role, btpan_remote_role); 658 btpan_cleanup_conn(conn); 659 } 660 else 661 BTIF_TRACE_ERROR("pan handle not found (%d)", p_data->close.handle); 662 break; 663 } 664 default: 665 BTIF_TRACE_WARNING("Unknown pan event %d", event); 666 break; 667 } 668 } 669 670 static void bta_pan_callback(tBTA_PAN_EVT event, tBTA_PAN *p_data) 671 { 672 btif_transfer_context(bta_pan_callback_transfer, event, (char*)p_data, sizeof(tBTA_PAN), NULL); 673 } 674 675 #define IS_EXCEPTION(e) ((e) & (POLLHUP | POLLRDHUP | POLLERR | POLLNVAL)) 676 static void btu_exec_tap_fd_read(void *p_param) { 677 struct pollfd ufd; 678 int fd = (int)p_param; 679 680 if (fd == -1 || fd != btpan_cb.tap_fd) 681 return; 682 683 // Don't occupy BTU context too long, avoid GKI buffer overruns and 684 // give other profiles a chance to run by limiting the amount of memory 685 // PAN can use from the shared pool buffer. 686 for(int i = 0; i < PAN_POOL_MAX && btif_is_enabled() && btpan_cb.flow; i++) { 687 BT_HDR *buffer = (BT_HDR *)GKI_getpoolbuf(PAN_POOL_ID); 688 if (!buffer) { 689 BTIF_TRACE_WARNING("%s unable to allocate buffer for packet.", __func__); 690 break; 691 } 692 buffer->offset = PAN_MINIMUM_OFFSET; 693 buffer->len = GKI_get_buf_size(buffer) - sizeof(BT_HDR) - buffer->offset; 694 695 UINT8 *packet = (UINT8 *)buffer + sizeof(BT_HDR) + buffer->offset; 696 697 // If we don't have an undelivered packet left over, pull one from the TAP driver. 698 // We save it in the congest_packet right away in case we can't deliver it in this 699 // attempt. 700 if (!btpan_cb.congest_packet_size) { 701 ssize_t ret = read(fd, btpan_cb.congest_packet, sizeof(btpan_cb.congest_packet)); 702 switch (ret) { 703 case -1: 704 BTIF_TRACE_ERROR("%s unable to read from driver: %s", __func__, strerror(errno)); 705 GKI_freebuf(buffer); 706 //add fd back to monitor thread to try it again later 707 btsock_thread_add_fd(pan_pth, fd, 0, SOCK_THREAD_FD_RD, 0); 708 return; 709 case 0: 710 BTIF_TRACE_WARNING("%s end of file reached.", __func__); 711 GKI_freebuf(buffer); 712 //add fd back to monitor thread to process the exception 713 btsock_thread_add_fd(pan_pth, fd, 0, SOCK_THREAD_FD_RD, 0); 714 return; 715 default: 716 btpan_cb.congest_packet_size = ret; 717 break; 718 } 719 } 720 721 memcpy(packet, btpan_cb.congest_packet, MIN(btpan_cb.congest_packet_size, buffer->len)); 722 buffer->len = MIN(btpan_cb.congest_packet_size, buffer->len); 723 724 if (buffer->len > sizeof(tETH_HDR) && should_forward((tETH_HDR *)packet)) { 725 // Extract the ethernet header from the buffer since the PAN_WriteBuf inside 726 // forward_bnep can't handle two pointers that point inside the same GKI buffer. 727 tETH_HDR hdr; 728 memcpy(&hdr, packet, sizeof(tETH_HDR)); 729 730 // Skip the ethernet header. 731 buffer->len -= sizeof(tETH_HDR); 732 buffer->offset += sizeof(tETH_HDR); 733 if (forward_bnep(&hdr, buffer) != FORWARD_CONGEST) 734 btpan_cb.congest_packet_size = 0; 735 } else { 736 BTIF_TRACE_WARNING("%s dropping packet of length %d", __func__, buffer->len); 737 btpan_cb.congest_packet_size = 0; 738 GKI_freebuf(buffer); 739 } 740 741 // Bail out of the loop if reading from the TAP fd would block. 742 ufd.fd = fd; 743 ufd.events = POLLIN; 744 ufd.revents = 0; 745 if(poll(&ufd, 1, 0) <= 0 || IS_EXCEPTION(ufd.revents)) 746 break; 747 } 748 //add fd back to monitor thread 749 btsock_thread_add_fd(pan_pth, fd, 0, SOCK_THREAD_FD_RD, 0); 750 } 751 752 static void btif_pan_close_all_conns() { 753 int i; 754 if (!stack_initialized) 755 return; 756 757 for (i = 0; i < MAX_PAN_CONNS; ++i) 758 if (btpan_cb.conns[i].handle != -1) 759 BTA_PanClose(btpan_cb.conns[i].handle); 760 } 761 762 static void btpan_tap_fd_signaled(int fd, int type, int flags, uint32_t user_id) { 763 assert(btpan_cb.tap_fd == fd); 764 765 if (btpan_cb.tap_fd != fd) 766 return; 767 768 if(flags & SOCK_THREAD_FD_EXCEPTION) { 769 btpan_cb.tap_fd = -1; 770 btpan_tap_close(fd); 771 btif_pan_close_all_conns(); 772 } else if(flags & SOCK_THREAD_FD_RD) 773 bta_dmexecutecallback(btu_exec_tap_fd_read, (void *)fd); 774 } 775
