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_sock_rfc.c
22 *
23 * Description: Handsfree Profile Bluetooth Interface
24 *
25 ***********************************************************************************/
26 #include <hardware/bluetooth.h>
27 #include <hardware/bt_sock.h>
28 #include <sys/types.h>
29 #include <sys/socket.h>
30 #include <errno.h>
31 #include <sys/ioctl.h>
32
33 #define LOG_TAG "BTIF_SOCK"
34 #include "btif_common.h"
35 #include "btif_util.h"
36
37 #include "bd.h"
38
39 #include "bta_api.h"
40 #include "btif_sock_thread.h"
41 #include "btif_sock_sdp.h"
42 #include "btif_sock_util.h"
43
44 #include "bt_target.h"
45 #include "gki.h"
46 #include "hcimsgs.h"
47 #include "sdp_api.h"
48 #include "btu.h"
49 #include "btm_api.h"
50 #include "btm_int.h"
51 #include "bta_jv_api.h"
52 #include "bta_jv_co.h"
53 #include "port_api.h"
54
55 #include <cutils/log.h>
56 #include <hardware/bluetooth.h>
57 #define asrt(s) if(!(s)) APPL_TRACE_ERROR3("## %s assert %s failed at line:%d ##",__FUNCTION__, #s, __LINE__)
58
59 extern void uuid_to_string(bt_uuid_t *p_uuid, char *str);
logu(const char * title,const uint8_t * p_uuid)60 static inline void logu(const char* title, const uint8_t * p_uuid)
61 {
62 char uuids[128];
63 uuid_to_string((bt_uuid_t*)p_uuid, uuids);
64 ALOGD("%s: %s", title, uuids);
65 }
66
67
68
69 #define MAX_RFC_CHANNEL 30
70 #define MAX_RFC_SESSION BTA_JV_MAX_RFC_SR_SESSION //3 by default
71 typedef struct {
72 int outgoing_congest : 1;
73 int pending_sdp_request : 1;
74 int doing_sdp_request : 1;
75 int server : 1;
76 int connected : 1;
77 int closing : 1;
78 } flags_t;
79
80 typedef struct {
81 flags_t f;
82 uint32_t id;
83 int security;
84 int scn;
85 bt_bdaddr_t addr;
86 uint8_t service_uuid[16];
87 char service_name[256];
88 int fd, app_fd;
89 int mtu;
90 uint8_t* packet;
91 int sdp_handle;
92 int rfc_handle;
93 int rfc_port_handle;
94 int role;
95 BUFFER_Q incoming_que;
96 } rfc_slot_t;
97
98 static rfc_slot_t rfc_slots[MAX_RFC_CHANNEL];
99 static uint32_t rfc_slot_id;
100 static volatile int pth = -1; //poll thread handle
101 static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data);
102 static void cleanup_rfc_slot(rfc_slot_t* rs);
103 static inline void close_rfc_connection(int rfc_handle, int server);
104 static bt_status_t dm_get_remote_service_record(bt_bdaddr_t *remote_addr,
105 bt_uuid_t *uuid);
106 static void *rfcomm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data);
107 static inline BOOLEAN send_app_scn(rfc_slot_t* rs);
108 static pthread_mutex_t slot_lock;
109 #define is_init_done() (pth != -1)
clear_slot_flag(flags_t * f)110 static inline void clear_slot_flag(flags_t* f)
111 {
112 memset(f, 0, sizeof(*f));
113 }
114
bd_copy(UINT8 * dest,UINT8 * src,BOOLEAN swap)115 static inline void bd_copy(UINT8* dest, UINT8* src, BOOLEAN swap)
116 {
117 if (swap)
118 {
119 int i;
120 for (i =0; i < 6 ;i++)
121 dest[i]= src[5-i];
122 }
123 else memcpy(dest, src, 6);
124 }
free_gki_que(BUFFER_Q * q)125 static inline void free_gki_que(BUFFER_Q* q)
126 {
127 while(!GKI_queue_is_empty(q))
128 GKI_freebuf(GKI_dequeue(q));
129 }
init_rfc_slots()130 static void init_rfc_slots()
131 {
132 int i;
133 memset(rfc_slots, 0, sizeof(rfc_slot_t)*MAX_RFC_CHANNEL);
134 for(i = 0; i < MAX_RFC_CHANNEL; i++)
135 {
136 rfc_slots[i].scn = -1;
137 rfc_slots[i].sdp_handle = 0;
138 rfc_slots[i].fd = rfc_slots[i].app_fd = -1;
139 GKI_init_q(&rfc_slots[i].incoming_que);
140 }
141 BTA_JvEnable(jv_dm_cback);
142 init_slot_lock(&slot_lock);
143 }
btsock_rfc_init(int poll_thread_handle)144 bt_status_t btsock_rfc_init(int poll_thread_handle)
145 {
146 pth = poll_thread_handle;
147 init_rfc_slots();
148 return BT_STATUS_SUCCESS;
149 }
btsock_rfc_cleanup()150 void btsock_rfc_cleanup()
151 {
152 int curr_pth = pth;
153 pth = -1;
154 btsock_thread_exit(curr_pth);
155 lock_slot(&slot_lock);
156 int i;
157 for(i = 0; i < MAX_RFC_CHANNEL; i++)
158 {
159 if(rfc_slots[i].id)
160 cleanup_rfc_slot(&rfc_slots[i]);
161 }
162 unlock_slot(&slot_lock);
163 }
find_free_slot()164 static inline rfc_slot_t* find_free_slot()
165 {
166 int i;
167 for(i = 0; i < MAX_RFC_CHANNEL; i++)
168 {
169 if(rfc_slots[i].fd == -1)
170 {
171 return &rfc_slots[i];
172 }
173 }
174 return NULL;
175 }
find_rfc_slot_by_id(uint32_t id)176 static inline rfc_slot_t* find_rfc_slot_by_id(uint32_t id)
177 {
178 int i;
179 if(id)
180 {
181 for(i = 0; i < MAX_RFC_CHANNEL; i++)
182 {
183 if(rfc_slots[i].id == id)
184 {
185 return &rfc_slots[i];
186 }
187 }
188 }
189 APPL_TRACE_WARNING1("invalid rfc slot id: %d", id);
190 return NULL;
191 }
find_rfc_slot_by_pending_sdp()192 static inline rfc_slot_t* find_rfc_slot_by_pending_sdp()
193 {
194 uint32_t min_id = (uint32_t)-1;
195 int slot = -1;
196 int i;
197 for(i = 0; i < MAX_RFC_CHANNEL; i++)
198 {
199 if(rfc_slots[i].id && rfc_slots[i].f.pending_sdp_request)
200 {
201 if(rfc_slots[i].id < min_id)
202 {
203 min_id = rfc_slots[i].id;
204 slot = i;
205 }
206 }
207 }
208 if(0<= slot && slot < MAX_RFC_CHANNEL)
209 return &rfc_slots[slot];
210 return NULL;
211 }
find_rfc_slot_requesting_sdp()212 static inline rfc_slot_t* find_rfc_slot_requesting_sdp()
213 {
214 int i;
215 for(i = 0; i < MAX_RFC_CHANNEL; i++)
216 {
217 if(rfc_slots[i].id && rfc_slots[i].f.doing_sdp_request)
218 return &rfc_slots[i];
219 }
220 APPL_TRACE_DEBUG0("can not find any slot is requesting sdp");
221 return NULL;
222 }
223
find_rfc_slot_by_fd(int fd)224 static inline rfc_slot_t* find_rfc_slot_by_fd(int fd)
225 {
226 int i;
227 if(fd >= 0)
228 {
229 for(i = 0; i < MAX_RFC_CHANNEL; i++)
230 {
231 if(rfc_slots[i].fd == fd)
232 {
233 if(rfc_slots[i].id)
234 return &rfc_slots[i];
235 else
236 {
237 APPL_TRACE_ERROR0("invalid rfc slot id, cannot be 0");
238 break;
239 }
240 }
241 }
242 }
243 return NULL;
244 }
alloc_rfc_slot(const bt_bdaddr_t * addr,const char * name,const uint8_t * uuid,int channel,int flags,BOOLEAN server)245 static rfc_slot_t* alloc_rfc_slot(const bt_bdaddr_t *addr, const char* name, const uint8_t* uuid, int channel, int flags, BOOLEAN server)
246 {
247 int security = 0;
248 if(flags & BTSOCK_FLAG_ENCRYPT)
249 security |= server ? BTM_SEC_IN_ENCRYPT : BTM_SEC_OUT_ENCRYPT;
250 if(flags & BTSOCK_FLAG_AUTH)
251 security |= server ? BTM_SEC_IN_AUTHENTICATE : BTM_SEC_OUT_AUTHENTICATE;
252
253 rfc_slot_t* rs = find_free_slot();
254 if(rs)
255 {
256 int fds[2] = {-1, -1};
257 if(socketpair(AF_LOCAL, SOCK_STREAM, 0, fds))
258 {
259 APPL_TRACE_ERROR1("socketpair failed, errno:%d", errno);
260 return NULL;
261 }
262 rs->fd = fds[0];
263 rs->app_fd = fds[1];
264 rs->security = security;
265 rs->scn = channel;
266 if(uuid)
267 memcpy(rs->service_uuid, uuid, sizeof(rs->service_uuid));
268 else memset(rs->service_uuid, 0, sizeof(rs->service_uuid));
269 if(name && *name)
270 strncpy(rs->service_name, name, sizeof(rs->service_name) -1);
271 if(addr)
272 rs->addr = *addr;
273 ++rfc_slot_id;
274 if(rfc_slot_id == 0)
275 rfc_slot_id = 1; //skip 0 when wrapped
276 rs->id = rfc_slot_id;
277 rs->f.server = server;
278 }
279 return rs;
280 }
281 // rfc_slot_t* accept_rs = create_srv_accept_rfc_slot(srv_rs, p_open->rem_bda,p_opne->handle, p_open->new_listen_handle);
create_srv_accept_rfc_slot(rfc_slot_t * srv_rs,const bt_bdaddr_t * addr,int open_handle,int new_listen_handle)282 static inline rfc_slot_t* create_srv_accept_rfc_slot(rfc_slot_t* srv_rs, const bt_bdaddr_t* addr,
283 int open_handle, int new_listen_handle)
284 {
285 rfc_slot_t *accept_rs = alloc_rfc_slot(addr, srv_rs->service_name, srv_rs->service_uuid, srv_rs->scn, 0, FALSE);
286 clear_slot_flag(&accept_rs->f);
287 accept_rs->f.server = FALSE;
288 accept_rs->f.connected = TRUE;
289 accept_rs->security = srv_rs->security;
290 accept_rs->mtu = srv_rs->mtu;
291 accept_rs->role = srv_rs->role;
292 accept_rs->rfc_handle = open_handle;
293 accept_rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(open_handle);
294 //now update listen rfc_handle of server slot
295 srv_rs->rfc_handle = new_listen_handle;
296 srv_rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(new_listen_handle);
297 BTIF_TRACE_DEBUG4("create_srv_accept__rfc_slot(open_handle: 0x%x, new_listen_handle:"
298 "0x%x) accept_rs->rfc_handle:0x%x, srv_rs_listen->rfc_handle:0x%x"
299 ,open_handle, new_listen_handle, accept_rs->rfc_port_handle, srv_rs->rfc_port_handle);
300 asrt(accept_rs->rfc_port_handle != srv_rs->rfc_port_handle);
301 //now swap the slot id
302 uint32_t new_listen_id = accept_rs->id;
303 accept_rs->id = srv_rs->id;
304 srv_rs->id = new_listen_id;
305 return accept_rs;
306 }
btsock_rfc_listen(const char * service_name,const uint8_t * service_uuid,int channel,int * sock_fd,int flags)307 bt_status_t btsock_rfc_listen(const char* service_name, const uint8_t* service_uuid, int channel,
308 int* sock_fd, int flags)
309 {
310
311 APPL_TRACE_DEBUG1("btsock_rfc_listen, service_name:%s", service_name);
312 if(sock_fd == NULL || (service_uuid == NULL && (channel < 1 || channel > 30)))
313 {
314 APPL_TRACE_ERROR3("invalid rfc channel:%d or sock_fd:%p, uuid:%p", channel, sock_fd, service_uuid);
315 return BT_STATUS_PARM_INVALID;
316 }
317 *sock_fd = -1;
318 if(!is_init_done())
319 return BT_STATUS_NOT_READY;
320 if(is_uuid_empty(service_uuid))
321 service_uuid = UUID_SPP; //use serial port profile to listen to specified channel
322 else
323 {
324 //Check the service_uuid. overwrite the channel # if reserved
325 int reserved_channel = get_reserved_rfc_channel(service_uuid);
326 if(reserved_channel > 0)
327 {
328 channel = reserved_channel;
329 }
330 }
331 int status = BT_STATUS_FAIL;
332 lock_slot(&slot_lock);
333 rfc_slot_t* rs = alloc_rfc_slot(NULL, service_name, service_uuid, channel, flags, TRUE);
334 if(rs)
335 {
336 APPL_TRACE_DEBUG1("BTA_JvCreateRecordByUser:%s", service_name);
337 BTA_JvCreateRecordByUser((void *)rs->id);
338 *sock_fd = rs->app_fd;
339 rs->app_fd = -1; //the fd ownership is transferred to app
340 status = BT_STATUS_SUCCESS;
341 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, rs->id);
342 }
343 unlock_slot(&slot_lock);
344 return status;
345 }
btsock_rfc_connect(const bt_bdaddr_t * bd_addr,const uint8_t * service_uuid,int channel,int * sock_fd,int flags)346 bt_status_t btsock_rfc_connect(const bt_bdaddr_t *bd_addr, const uint8_t* service_uuid,
347 int channel, int* sock_fd, int flags)
348 {
349 if(sock_fd == NULL || (service_uuid == NULL && (channel < 1 || channel > 30)))
350 {
351 APPL_TRACE_ERROR3("invalid rfc channel:%d or sock_fd:%p, uuid:%p", channel, sock_fd,
352 service_uuid);
353 return BT_STATUS_PARM_INVALID;
354 }
355 *sock_fd = -1;
356 if(!is_init_done())
357 return BT_STATUS_NOT_READY;
358 int status = BT_STATUS_FAIL;
359 lock_slot(&slot_lock);
360 rfc_slot_t* rs = alloc_rfc_slot(bd_addr, NULL, service_uuid, channel, flags, FALSE);
361 if(rs)
362 {
363 if(is_uuid_empty(service_uuid))
364 {
365 APPL_TRACE_DEBUG1("connecting to rfcomm channel:%d without service discovery", channel);
366 if(BTA_JvRfcommConnect(rs->security, rs->role, rs->scn, rs->addr.address,
367 rfcomm_cback, (void*)rs->id) == BTA_JV_SUCCESS)
368 {
369 if(send_app_scn(rs))
370 {
371 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM,
372 SOCK_THREAD_FD_RD, rs->id);
373 *sock_fd = rs->app_fd;
374 rs->app_fd = -1; //the fd ownership is transferred to app
375 status = BT_STATUS_SUCCESS;
376 }
377 else cleanup_rfc_slot(rs);
378 }
379 else cleanup_rfc_slot(rs);
380 }
381 else
382 {
383 tSDP_UUID sdp_uuid;
384 sdp_uuid.len = 16;
385 memcpy(sdp_uuid.uu.uuid128, service_uuid, sizeof(sdp_uuid.uu.uuid128));
386 logu("service_uuid", service_uuid);
387 *sock_fd = rs->app_fd;
388 rs->app_fd = -1; //the fd ownership is transferred to app
389 status = BT_STATUS_SUCCESS;
390 rfc_slot_t* rs_doing_sdp = find_rfc_slot_requesting_sdp();
391 if(rs_doing_sdp == NULL)
392 {
393 BTA_JvStartDiscovery((UINT8*)bd_addr->address, 1, &sdp_uuid, (void*)rs->id);
394 rs->f.pending_sdp_request = FALSE;
395 rs->f.doing_sdp_request = TRUE;
396 }
397 else
398 {
399 rs->f.pending_sdp_request = TRUE;
400 rs->f.doing_sdp_request = FALSE;
401 }
402 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, rs->id);
403 }
404 }
405 unlock_slot(&slot_lock);
406 return status;
407 }
408
create_server_sdp_record(rfc_slot_t * rs)409 static int create_server_sdp_record(rfc_slot_t* rs)
410 {
411 int scn = rs->scn;
412 if(rs->scn > 0)
413 {
414 if(BTM_TryAllocateSCN(rs->scn) == FALSE)
415 {
416 APPL_TRACE_ERROR1("rfc channel:%d already in use", scn);
417 return FALSE;
418 }
419 }
420 else if((rs->scn = BTM_AllocateSCN()) == 0)
421 {
422 APPL_TRACE_ERROR0("run out of rfc channels");
423 return FALSE;
424 }
425 if((rs->sdp_handle = add_rfc_sdp_rec(rs->service_name, rs->service_uuid, rs->scn)) <= 0)
426 {
427 return FALSE;
428 }
429 return TRUE;
430 }
431 const char * jv_evt[] = {
432 "BTA_JV_ENABLE_EVT",
433 "BTA_JV_SET_DISCOVER_EVT",
434 "BTA_JV_LOCAL_ADDR_EVT",
435 "BTA_JV_LOCAL_NAME_EVT",
436 "BTA_JV_REMOTE_NAME_EVT",
437 "BTA_JV_SET_ENCRYPTION_EVT",
438 "BTA_JV_GET_SCN_EVT",
439 "BTA_JV_GET_PSM_EVT",
440 "BTA_JV_DISCOVERY_COMP_EVT",
441 "BTA_JV_SERVICES_LEN_EVT",
442 "BTA_JV_SERVICE_SEL_EVT",
443 "BTA_JV_CREATE_RECORD_EVT",
444 "BTA_JV_UPDATE_RECORD_EVT",
445 "BTA_JV_ADD_ATTR_EVT",
446 "BTA_JV_DELETE_ATTR_EVT",
447 "BTA_JV_CANCEL_DISCVRY_EVT",
448
449 "BTA_JV_L2CAP_OPEN_EVT",
450 "BTA_JV_L2CAP_CLOSE_EVT",
451 "BTA_JV_L2CAP_START_EVT",
452 "BTA_JV_L2CAP_CL_INIT_EVT",
453 "BTA_JV_L2CAP_DATA_IND_EVT",
454 "BTA_JV_L2CAP_CONG_EVT",
455 "BTA_JV_L2CAP_READ_EVT",
456 "BTA_JV_L2CAP_RECEIVE_EVT",
457 "BTA_JV_L2CAP_WRITE_EVT",
458
459 "BTA_JV_RFCOMM_OPEN_EVT",
460 "BTA_JV_RFCOMM_CLOSE_EVT",
461 "BTA_JV_RFCOMM_START_EVT",
462 "BTA_JV_RFCOMM_CL_INIT_EVT",
463 "BTA_JV_RFCOMM_DATA_IND_EVT",
464 "BTA_JV_RFCOMM_CONG_EVT",
465 "BTA_JV_RFCOMM_READ_EVT",
466 "BTA_JV_RFCOMM_WRITE_EVT",
467 "BTA_JV_RFCOMM_SRV_OPEN_EVT", // 33 /* open status of Server RFCOMM connection */
468 "BTA_JV_MAX_EVT"
469 };
free_rfc_slot_scn(rfc_slot_t * rs)470 static inline void free_rfc_slot_scn(rfc_slot_t* rs)
471 {
472 if(rs->scn > 0)
473 {
474 if(rs->f.server && !rs->f.closing && rs->rfc_handle)
475 {
476 BTA_JvRfcommStopServer(rs->rfc_handle, (void*)rs->id);
477 rs->rfc_handle = 0;
478 }
479 if(rs->f.server)
480 BTM_FreeSCN(rs->scn);
481 rs->scn = 0;
482 }
483 }
cleanup_rfc_slot(rfc_slot_t * rs)484 static void cleanup_rfc_slot(rfc_slot_t* rs)
485 {
486 APPL_TRACE_DEBUG4("cleanup slot:%d, fd:%d, scn:%d, sdp_handle:0x%x", rs->id, rs->fd, rs->scn, rs->sdp_handle);
487 if(rs->fd != -1)
488 {
489 shutdown(rs->fd, 2);
490 close(rs->fd);
491 rs->fd = -1;
492 }
493 if(rs->app_fd != -1)
494 {
495 close(rs->app_fd);
496 rs->app_fd = -1;
497 }
498 if(rs->sdp_handle > 0)
499 {
500 del_rfc_sdp_rec(rs->sdp_handle);
501 rs->sdp_handle = 0;
502 }
503 if(rs->rfc_handle && !rs->f.closing && !rs->f.server)
504 {
505 APPL_TRACE_DEBUG1("closing rfcomm connection, rfc_handle:0x%x", rs->rfc_handle);
506 BTA_JvRfcommClose(rs->rfc_handle, (void*)rs->id);
507 rs->rfc_handle = 0;
508 }
509 free_rfc_slot_scn(rs);
510 free_gki_que(&rs->incoming_que);
511
512 rs->rfc_port_handle = 0;
513 //cleanup the flag
514 memset(&rs->f, 0, sizeof(rs->f));
515 rs->id = 0;
516 }
send_app_scn(rfc_slot_t * rs)517 static inline BOOLEAN send_app_scn(rfc_slot_t* rs)
518 {
519 if(sock_send_all(rs->fd, (const uint8_t*)&rs->scn, sizeof(rs->scn)) == sizeof(rs->scn))
520 {
521 return TRUE;
522 }
523
524 return FALSE;
525 }
send_app_connect_signal(int fd,const bt_bdaddr_t * addr,int channel,int status,int send_fd)526 static BOOLEAN send_app_connect_signal(int fd, const bt_bdaddr_t* addr, int channel, int status, int send_fd)
527 {
528 /*
529 typedef struct {
530 short size;
531 bt_bdaddr_t bd_addr;
532 int channel;
533 int status;
534 } __attribute__((packed)) sock_connect_signal_t;
535 */
536 sock_connect_signal_t cs;
537 cs.size = sizeof(cs);
538 cs.bd_addr = *addr;
539 cs.channel = channel;
540 cs.status = status;
541 if(send_fd != -1)
542 {
543 if(sock_send_fd(fd, (const uint8_t*)&cs, sizeof(cs), send_fd) == sizeof(cs))
544 return TRUE;
545 else APPL_TRACE_ERROR2("sock_send_fd failed, fd:%d, send_fd:%d", fd, send_fd);
546 }
547 else if(sock_send_all(fd, (const uint8_t*)&cs, sizeof(cs)) == sizeof(cs))
548 {
549 return TRUE;
550 }
551 return FALSE;
552 }
on_cl_rfc_init(tBTA_JV_RFCOMM_CL_INIT * p_init,uint32_t id)553 static void on_cl_rfc_init(tBTA_JV_RFCOMM_CL_INIT *p_init, uint32_t id)
554 {
555 lock_slot(&slot_lock);
556 rfc_slot_t* rs = find_rfc_slot_by_id(id);
557 if(rs)
558 {
559 if (p_init->status != BTA_JV_SUCCESS)
560 cleanup_rfc_slot(rs);
561 else
562 {
563 rs->rfc_handle = p_init->handle;
564 }
565 }
566 unlock_slot(&slot_lock);
567 }
on_srv_rfc_listen_started(tBTA_JV_RFCOMM_START * p_start,uint32_t id)568 static void on_srv_rfc_listen_started(tBTA_JV_RFCOMM_START *p_start, uint32_t id)
569 {
570 lock_slot(&slot_lock);
571 rfc_slot_t* rs = find_rfc_slot_by_id(id);
572 if(rs)
573 {
574 if (p_start->status != BTA_JV_SUCCESS)
575 cleanup_rfc_slot(rs);
576 else
577 {
578 rs->rfc_handle = p_start->handle;
579
580 if(!send_app_scn(rs))
581 {
582 //closed
583 APPL_TRACE_DEBUG1("send_app_scn() failed, close rs->id:%d", rs->id);
584 cleanup_rfc_slot(rs);
585 }
586 }
587 }
588 unlock_slot(&slot_lock);
589 }
on_srv_rfc_connect(tBTA_JV_RFCOMM_SRV_OPEN * p_open,uint32_t id)590 static uint32_t on_srv_rfc_connect(tBTA_JV_RFCOMM_SRV_OPEN *p_open, uint32_t id)
591 {
592 uint32_t new_listen_slot_id = 0;
593 lock_slot(&slot_lock);
594 rfc_slot_t* srv_rs = find_rfc_slot_by_id(id);
595 if(srv_rs)
596 {
597 rfc_slot_t* accept_rs = create_srv_accept_rfc_slot(srv_rs, (const bt_bdaddr_t*)p_open->rem_bda,
598 p_open->handle, p_open->new_listen_handle);
599 if(accept_rs)
600 {
601 //start monitor the socket
602 btsock_thread_add_fd(pth, srv_rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_EXCEPTION, srv_rs->id);
603 btsock_thread_add_fd(pth, accept_rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, accept_rs->id);
604 APPL_TRACE_DEBUG1("sending connect signal & app fd:%dto app server to accept() the connection",
605 accept_rs->app_fd);
606 APPL_TRACE_DEBUG2("server fd:%d, scn:%d", srv_rs->fd, srv_rs->scn);
607 send_app_connect_signal(srv_rs->fd, &accept_rs->addr, srv_rs->scn, 0, accept_rs->app_fd);
608 accept_rs->app_fd = -1; //the fd is closed after sent to app
609 new_listen_slot_id = srv_rs->id;
610 }
611 }
612 unlock_slot(&slot_lock);
613 return new_listen_slot_id;
614 }
on_cli_rfc_connect(tBTA_JV_RFCOMM_OPEN * p_open,uint32_t id)615 static void on_cli_rfc_connect(tBTA_JV_RFCOMM_OPEN *p_open, uint32_t id)
616 {
617 lock_slot(&slot_lock);
618 rfc_slot_t* rs = find_rfc_slot_by_id(id);
619 if(rs && p_open->status == BTA_JV_SUCCESS)
620 {
621 rs->rfc_port_handle = BTA_JvRfcommGetPortHdl(p_open->handle);
622 bd_copy(rs->addr.address, p_open->rem_bda, 0);
623 //notify app rfc is connected
624 APPL_TRACE_DEBUG4("call send_app_connect_signal, slot id:%d, fd:%d, rfc scn:%d, server:%d",
625 rs->id, rs->fd, rs->scn, rs->f.server);
626 if(send_app_connect_signal(rs->fd, &rs->addr, rs->scn, 0, -1))
627 {
628 //start monitoring the socketpair to get call back when app writing data
629 APPL_TRACE_DEBUG3("on_rfc_connect_ind, connect signal sent, slot id:%d, rfc scn:%d, server:%d",
630 rs->id, rs->scn, rs->f.server);
631 rs->f.connected = TRUE;
632 }
633 else APPL_TRACE_ERROR0("send_app_connect_signal failed");
634 }
635 else if(rs)
636 cleanup_rfc_slot(rs);
637 unlock_slot(&slot_lock);
638 }
on_rfc_close(tBTA_JV_RFCOMM_CLOSE * p_close,uint32_t id)639 static void on_rfc_close(tBTA_JV_RFCOMM_CLOSE * p_close, uint32_t id)
640 {
641 lock_slot(&slot_lock);
642 rfc_slot_t* rs = find_rfc_slot_by_id(id);
643 if(rs)
644 {
645 APPL_TRACE_DEBUG4("on_rfc_close, slot id:%d, fd:%d, rfc scn:%d, server:%d",
646 rs->id, rs->fd, rs->scn, rs->f.server);
647 free_rfc_slot_scn(rs);
648 // rfc_handle already closed when receiving rfcomm close event from stack.
649 rs->f.connected = FALSE;
650 cleanup_rfc_slot(rs);
651 }
652 unlock_slot(&slot_lock);
653 }
on_rfc_write_done(tBTA_JV_RFCOMM_WRITE * p,uint32_t id)654 static void on_rfc_write_done(tBTA_JV_RFCOMM_WRITE *p, uint32_t id)
655 {
656 lock_slot(&slot_lock);
657 rfc_slot_t* rs = find_rfc_slot_by_id(id);
658 if(rs && !rs->f.outgoing_congest)
659 {
660 //mointer the fd for any outgoing data
661 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, rs->id);
662 }
663 unlock_slot(&slot_lock);
664 }
on_rfc_outgoing_congest(tBTA_JV_RFCOMM_CONG * p,uint32_t id)665 static void on_rfc_outgoing_congest(tBTA_JV_RFCOMM_CONG *p, uint32_t id)
666 {
667 lock_slot(&slot_lock);
668 rfc_slot_t* rs = find_rfc_slot_by_id(id);
669 if(rs)
670 {
671 rs->f.outgoing_congest = p->cong ? 1 : 0;
672 //mointer the fd for any outgoing data
673 if(!rs->f.outgoing_congest)
674 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_RD, rs->id);
675 }
676 unlock_slot(&slot_lock);
677 }
678
rfcomm_cback(tBTA_JV_EVT event,tBTA_JV * p_data,void * user_data)679 static void *rfcomm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data)
680 {
681 int rc;
682 void* new_user_data = NULL;
683 APPL_TRACE_DEBUG1("event=%s", jv_evt[event]);
684
685 switch (event)
686 {
687 case BTA_JV_RFCOMM_START_EVT:
688 on_srv_rfc_listen_started(&p_data->rfc_start, (uint32_t)user_data);
689 break;
690
691 case BTA_JV_RFCOMM_CL_INIT_EVT:
692 on_cl_rfc_init(&p_data->rfc_cl_init, (uint32_t)user_data);
693 break;
694
695 case BTA_JV_RFCOMM_OPEN_EVT:
696 BTA_JvSetPmProfile(p_data->rfc_open.handle,BTA_JV_PM_ID_1,BTA_JV_CONN_OPEN);
697 on_cli_rfc_connect(&p_data->rfc_open, (uint32_t)user_data);
698 break;
699 case BTA_JV_RFCOMM_SRV_OPEN_EVT:
700 BTA_JvSetPmProfile(p_data->rfc_srv_open.handle,BTA_JV_PM_ALL,BTA_JV_CONN_OPEN);
701 new_user_data = (void*)on_srv_rfc_connect(&p_data->rfc_srv_open, (uint32_t)user_data);
702 break;
703
704 case BTA_JV_RFCOMM_CLOSE_EVT:
705 APPL_TRACE_DEBUG1("BTA_JV_RFCOMM_CLOSE_EVT: user_data:%d", (uint32_t)user_data);
706 on_rfc_close(&p_data->rfc_close, (uint32_t)user_data);
707 break;
708
709 case BTA_JV_RFCOMM_READ_EVT:
710 APPL_TRACE_DEBUG0("BTA_JV_RFCOMM_READ_EVT not used");
711 break;
712
713 case BTA_JV_RFCOMM_WRITE_EVT:
714 on_rfc_write_done(&p_data->rfc_write, (uint32_t)user_data);
715 break;
716
717 case BTA_JV_RFCOMM_DATA_IND_EVT:
718 APPL_TRACE_DEBUG0("BTA_JV_RFCOMM_DATA_IND_EVT not used");
719 break;
720
721 case BTA_JV_RFCOMM_CONG_EVT:
722 //on_rfc_cong(&p_data->rfc_cong);
723 on_rfc_outgoing_congest(&p_data->rfc_cong, (uint32_t)user_data);
724 break;
725 default:
726 APPL_TRACE_ERROR2("unhandled event %d, slot id:%d", event, (uint32_t)user_data);
727 break;
728 }
729 return new_user_data;
730 }
731
jv_dm_cback(tBTA_JV_EVT event,tBTA_JV * p_data,void * user_data)732 static void jv_dm_cback(tBTA_JV_EVT event, tBTA_JV *p_data, void *user_data)
733 {
734 uint32_t id = (uint32_t)user_data;
735 APPL_TRACE_DEBUG2("jv_dm_cback: event:%d, slot id:%d", event, id);
736 switch(event)
737 {
738 case BTA_JV_CREATE_RECORD_EVT:
739 {
740 lock_slot(&slot_lock);
741 rfc_slot_t* rs = find_rfc_slot_by_id(id);
742 if(rs && create_server_sdp_record(rs))
743 {
744 //now start the rfcomm server after sdp & channel # assigned
745 BTA_JvRfcommStartServer(rs->security, rs->role, rs->scn, MAX_RFC_SESSION, rfcomm_cback,
746 (void*)rs->id);
747 }
748 else if(rs)
749 {
750 APPL_TRACE_ERROR1("jv_dm_cback: cannot start server, slot found:%p", rs);
751 cleanup_rfc_slot(rs);
752 }
753 unlock_slot(&slot_lock);
754 break;
755 }
756 case BTA_JV_DISCOVERY_COMP_EVT:
757 {
758 rfc_slot_t* rs = NULL;
759 lock_slot(&slot_lock);
760 if(p_data->disc_comp.status == BTA_JV_SUCCESS && p_data->disc_comp.scn)
761 {
762 APPL_TRACE_DEBUG3("BTA_JV_DISCOVERY_COMP_EVT, slot id:%d, status:%d, scn:%d",
763 id, p_data->disc_comp.status, p_data->disc_comp.scn);
764
765 rs = find_rfc_slot_by_id(id);
766 if(rs && rs->f.doing_sdp_request)
767 {
768 if(BTA_JvRfcommConnect(rs->security, rs->role, p_data->disc_comp.scn, rs->addr.address,
769 rfcomm_cback, (void*)rs->id) == BTA_JV_SUCCESS)
770 {
771 rs->scn = p_data->disc_comp.scn;
772 rs->f.doing_sdp_request = FALSE;
773 if(!send_app_scn(rs))
774 cleanup_rfc_slot(rs);
775 }
776 else cleanup_rfc_slot(rs);
777 }
778 else if(rs)
779 {
780 APPL_TRACE_ERROR3("DISCOVERY_COMP_EVT no pending sdp request, slot id:%d, \
781 flag sdp pending:%d, flag sdp doing:%d",
782 id, rs->f.pending_sdp_request, rs->f.doing_sdp_request);
783 }
784 }
785 else
786 {
787 APPL_TRACE_ERROR3("DISCOVERY_COMP_EVT slot id:%d, failed to find channle, \
788 status:%d, scn:%d", id, p_data->disc_comp.status,
789 p_data->disc_comp.scn);
790 rs = find_rfc_slot_by_id(id);
791 if(rs)
792 cleanup_rfc_slot(rs);
793 }
794 rs = find_rfc_slot_by_pending_sdp();
795 if(rs)
796 {
797 APPL_TRACE_DEBUG0("BTA_JV_DISCOVERY_COMP_EVT, start another pending scn sdp request");
798 tSDP_UUID sdp_uuid;
799 sdp_uuid.len = 16;
800 memcpy(sdp_uuid.uu.uuid128, rs->service_uuid, sizeof(sdp_uuid.uu.uuid128));
801 BTA_JvStartDiscovery((UINT8*)rs->addr.address, 1, &sdp_uuid, (void*)rs->id);
802 rs->f.pending_sdp_request = FALSE;
803 rs->f.doing_sdp_request = TRUE;
804 }
805 unlock_slot(&slot_lock);
806 break;
807 }
808 default:
809 APPL_TRACE_DEBUG2("unhandled event:%d, slot id:%d", event, id);
810 break;
811 }
812
813 }
814 #define SENT_ALL 2
815 #define SENT_PARTIAL 1
816 #define SENT_NONE 0
817 #define SENT_FAILED (-1)
send_data_to_app(int fd,BT_HDR * p_buf)818 static int send_data_to_app(int fd, BT_HDR *p_buf)
819 {
820 if(p_buf->len == 0)
821 return SENT_ALL;
822 int sent = send(fd, (UINT8 *)(p_buf + 1) + p_buf->offset, p_buf->len, MSG_DONTWAIT);
823 if(sent == p_buf->len)
824 return SENT_ALL;
825
826 if(sent > 0 && sent < p_buf->len)
827 {
828 //sent partial
829 APPL_TRACE_ERROR2("send partial, sent:%d, p_buf->len:%d", sent, p_buf->len);
830 p_buf->offset += sent;
831 p_buf->len -= sent;
832 return SENT_PARTIAL;
833
834 }
835 if(sent < 0 &&
836 (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR))
837 {
838 APPL_TRACE_ERROR1("send none, EAGAIN or EWOULDBLOCK, errno:%d", errno);
839 return SENT_NONE;
840 }
841 APPL_TRACE_ERROR3("unknown send() error, sent:%d, p_buf->len:%d, errno:%d", sent, p_buf->len, errno);
842 return SENT_FAILED;
843 }
flush_incoming_que_on_wr_signal(rfc_slot_t * rs)844 static BOOLEAN flush_incoming_que_on_wr_signal(rfc_slot_t* rs)
845 {
846 while(!GKI_queue_is_empty(&rs->incoming_que))
847 {
848 BT_HDR *p_buf = GKI_dequeue(&rs->incoming_que);
849 int sent = send_data_to_app(rs->fd, p_buf);
850 switch(sent)
851 {
852 case SENT_NONE:
853 case SENT_PARTIAL:
854 //add it back to the queue at same position
855 GKI_enqueue_head (&rs->incoming_que, p_buf);
856 //monitor the fd to get callback when app is ready to receive data
857 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, rs->id);
858 return TRUE;
859 case SENT_ALL:
860 GKI_freebuf(p_buf);
861 break;
862 case SENT_FAILED:
863 GKI_freebuf(p_buf);
864 return FALSE;
865 }
866 }
867
868 //app is ready to receive data, tell stack to start the data flow
869 //fix me: need a jv flow control api to serialize the call in stack
870 APPL_TRACE_DEBUG3("enable data flow, rfc_handle:0x%x, rfc_port_handle:0x%x, user_id:%d",
871 rs->rfc_handle, rs->rfc_port_handle, rs->id);
872 extern int PORT_FlowControl_MaxCredit(UINT16 handle, BOOLEAN enable);
873 PORT_FlowControl_MaxCredit(rs->rfc_port_handle, TRUE);
874 return TRUE;
875 }
btsock_rfc_signaled(int fd,int flags,uint32_t user_id)876 void btsock_rfc_signaled(int fd, int flags, uint32_t user_id)
877 {
878 lock_slot(&slot_lock);
879 rfc_slot_t* rs = find_rfc_slot_by_id(user_id);
880 if(rs)
881 {
882 APPL_TRACE_DEBUG3("rfc slot id:%d, fd:%d, flags:%x", rs->id, fd, flags);
883 BOOLEAN need_close = FALSE;
884 if(flags & SOCK_THREAD_FD_RD)
885 {
886 //data available from app, tell stack we have outgoing data
887 if(!rs->f.server)
888 {
889 if(rs->f.connected)
890 {
891 int size = 0;
892 //make sure there's data pending in case the peer closed the socket
893 if(!(flags & SOCK_THREAD_FD_EXCEPTION) ||
894 (ioctl(rs->fd, FIONREAD, &size) == 0 && size))
895 BTA_JvRfcommWrite(rs->rfc_handle, (UINT32)rs->id);
896 }
897 else
898 {
899 APPL_TRACE_ERROR2("SOCK_THREAD_FD_RD signaled when rfc is not connected, \
900 slot id:%d, channel:%d", rs->id, rs->scn);
901 need_close = TRUE;
902 }
903 }
904 }
905 if(flags & SOCK_THREAD_FD_WR)
906 {
907 //app is ready to receive more data, tell stack to enable the data flow
908 if(!rs->f.connected || !flush_incoming_que_on_wr_signal(rs))
909 {
910 need_close = TRUE;
911 APPL_TRACE_ERROR2("SOCK_THREAD_FD_WR signaled when rfc is not connected \
912 or app closed fd, slot id:%d, channel:%d", rs->id, rs->scn);
913 }
914
915 }
916 if(need_close || (flags & SOCK_THREAD_FD_EXCEPTION))
917 {
918 int size = 0;
919 if(need_close || ioctl(rs->fd, FIONREAD, &size) != 0 || size == 0 )
920 {
921 //cleanup when no data pending
922 APPL_TRACE_DEBUG3("SOCK_THREAD_FD_EXCEPTION, cleanup, flags:%x, need_close:%d, pending size:%d",
923 flags, need_close, size);
924 cleanup_rfc_slot(rs);
925 }
926 else
927 APPL_TRACE_DEBUG3("SOCK_THREAD_FD_EXCEPTION, cleanup pending, flags:%x, need_close:%d, pending size:%d",
928 flags, need_close, size);
929 }
930 }
931 unlock_slot(&slot_lock);
932 }
933
bta_co_rfc_data_incoming(void * user_data,BT_HDR * p_buf)934 int bta_co_rfc_data_incoming(void *user_data, BT_HDR *p_buf)
935 {
936 uint32_t id = (uint32_t)user_data;
937 int ret = 0;
938 lock_slot(&slot_lock);
939 rfc_slot_t* rs = find_rfc_slot_by_id(id);
940 if(rs)
941 {
942 if(!GKI_queue_is_empty(&rs->incoming_que))
943 GKI_enqueue(&rs->incoming_que, p_buf);
944 else
945 {
946 int sent = send_data_to_app(rs->fd, p_buf);
947 switch(sent)
948 {
949 case SENT_NONE:
950 case SENT_PARTIAL:
951 //add it to the end of the queue
952 GKI_enqueue(&rs->incoming_que, p_buf);
953 //monitor the fd to get callback when app is ready to receive data
954 btsock_thread_add_fd(pth, rs->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, rs->id);
955 break;
956 case SENT_ALL:
957 GKI_freebuf(p_buf);
958 ret = 1;//enable the data flow
959 break;
960 case SENT_FAILED:
961 GKI_freebuf(p_buf);
962 cleanup_rfc_slot(rs);
963 break;
964 }
965 }
966 }
967 unlock_slot(&slot_lock);
968 return ret;//return 0 to disable data flow
969 }
bta_co_rfc_data_outgoing_size(void * user_data,int * size)970 int bta_co_rfc_data_outgoing_size(void *user_data, int *size)
971 {
972 uint32_t id = (uint32_t)user_data;
973 int ret = FALSE;
974 *size = 0;
975 lock_slot(&slot_lock);
976 rfc_slot_t* rs = find_rfc_slot_by_id(id);
977 if(rs)
978 {
979 if(ioctl(rs->fd, FIONREAD, size) == 0)
980 {
981 APPL_TRACE_DEBUG2("ioctl read avaiable size:%d, fd:%d", *size, rs->fd);
982 ret = TRUE;
983 }
984 else
985 {
986 APPL_TRACE_ERROR2("ioctl FIONREAD error, errno:%d, fd:%d", errno, rs->fd);
987 cleanup_rfc_slot(rs);
988 }
989 }
990 else APPL_TRACE_ERROR1("bta_co_rfc_data_outgoing_size, invalid slot id:%d", id);
991 unlock_slot(&slot_lock);
992 return ret;
993 }
bta_co_rfc_data_outgoing(void * user_data,UINT8 * buf,UINT16 size)994 int bta_co_rfc_data_outgoing(void *user_data, UINT8* buf, UINT16 size)
995 {
996 uint32_t id = (uint32_t)user_data;
997 int ret = FALSE;
998 lock_slot(&slot_lock);
999 rfc_slot_t* rs = find_rfc_slot_by_id(id);
1000 if(rs)
1001 {
1002 int received = recv(rs->fd, buf, size, 0);
1003 if(received == size)
1004 ret = TRUE;
1005 else
1006 {
1007 APPL_TRACE_ERROR4("recv error, errno:%d, fd:%d, size:%d, received:%d",
1008 errno, rs->fd, size, received);
1009 cleanup_rfc_slot(rs);
1010 }
1011 }
1012 else APPL_TRACE_ERROR1("bta_co_rfc_data_outgoing, invalid slot id:%d", id);
1013 unlock_slot(&slot_lock);
1014 return ret;
1015 }
1016
1017