1 /******************************************************************************
2  *
3  *  Copyright 2014 Google, Inc.
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 #define LOG_TAG "bt_btif_sock"
20 
21 #include <atomic>
22 
23 #include <base/logging.h>
24 
25 #include <frameworks/proto_logging/stats/enums/bluetooth/enums.pb.h>
26 #include <hardware/bluetooth.h>
27 #include <hardware/bt_sock.h>
28 
29 #include "bta_api.h"
30 #include "btif_common.h"
31 #include "btif_config.h"
32 #include "btif_metrics_logging.h"
33 #include "btif_sock_l2cap.h"
34 #include "btif_sock_rfc.h"
35 #include "btif_sock_sco.h"
36 #include "btif_sock_sdp.h"
37 #include "btif_sock_thread.h"
38 #include "btif_uid.h"
39 #include "btif_util.h"
40 #include "device/include/controller.h"
41 #include "osi/include/thread.h"
42 
43 using bluetooth::Uuid;
44 
45 static bt_status_t btsock_listen(btsock_type_t type, const char* service_name,
46                                  const Uuid* uuid, int channel, int* sock_fd,
47                                  int flags, int app_uid);
48 static bt_status_t btsock_connect(const RawAddress* bd_addr, btsock_type_t type,
49                                   const Uuid* uuid, int channel, int* sock_fd,
50                                   int flags, int app_uid);
51 
52 static void btsock_request_max_tx_data_length(const RawAddress& bd_addr);
53 
54 static void btsock_signaled(int fd, int type, int flags, uint32_t user_id);
55 
56 static std::atomic_int thread_handle{-1};
57 static thread_t* thread;
58 
btif_sock_get_interface(void)59 const btsock_interface_t* btif_sock_get_interface(void) {
60   static btsock_interface_t interface = {
61       sizeof(interface), btsock_listen, /* listen */
62       btsock_connect,                   /* connect */
63       btsock_request_max_tx_data_length /* request_max_tx_data_length */
64   };
65 
66   return &interface;
67 }
68 
btif_sock_init(uid_set_t * uid_set)69 bt_status_t btif_sock_init(uid_set_t* uid_set) {
70   CHECK(thread_handle == -1);
71   CHECK(thread == NULL);
72 
73   bt_status_t status;
74   btsock_thread_init();
75   thread_handle = btsock_thread_create(btsock_signaled, NULL);
76   if (thread_handle == -1) {
77     LOG_ERROR("%s unable to create btsock_thread.", __func__);
78     goto error;
79   }
80 
81   status = btsock_rfc_init(thread_handle, uid_set);
82   if (status != BT_STATUS_SUCCESS) {
83     LOG_ERROR("%s error initializing RFCOMM sockets: %d", __func__, status);
84     goto error;
85   }
86 
87   status = btsock_l2cap_init(thread_handle, uid_set);
88   if (status != BT_STATUS_SUCCESS) {
89     LOG_ERROR("%s error initializing L2CAP sockets: %d", __func__, status);
90     goto error;
91   }
92 
93   thread = thread_new("btif_sock");
94   if (!thread) {
95     LOG_ERROR("%s error creating new thread.", __func__);
96     btsock_rfc_cleanup();
97     goto error;
98   }
99 
100   status = btsock_sco_init(thread);
101   if (status != BT_STATUS_SUCCESS) {
102     LOG_ERROR("%s error initializing SCO sockets: %d", __func__, status);
103     btsock_rfc_cleanup();
104     goto error;
105   }
106 
107   return BT_STATUS_SUCCESS;
108 
109 error:;
110   thread_free(thread);
111   thread = NULL;
112   if (thread_handle != -1) btsock_thread_exit(thread_handle);
113   thread_handle = -1;
114   uid_set = NULL;
115   return BT_STATUS_FAIL;
116 }
117 
btif_sock_cleanup(void)118 void btif_sock_cleanup(void) {
119   int saved_handle = thread_handle;
120   if (std::atomic_exchange(&thread_handle, -1) == -1) return;
121 
122   btsock_thread_exit(saved_handle);
123   btsock_rfc_cleanup();
124   btsock_sco_cleanup();
125   btsock_l2cap_cleanup();
126   thread_free(thread);
127   thread = NULL;
128 }
129 
btsock_listen(btsock_type_t type,const char * service_name,const Uuid * service_uuid,int channel,int * sock_fd,int flags,int app_uid)130 static bt_status_t btsock_listen(btsock_type_t type, const char* service_name,
131                                  const Uuid* service_uuid, int channel,
132                                  int* sock_fd, int flags, int app_uid) {
133   if ((flags & BTSOCK_FLAG_NO_SDP) == 0) {
134     CHECK(sock_fd != NULL);
135   }
136 
137   *sock_fd = INVALID_FD;
138   bt_status_t status = BT_STATUS_FAIL;
139   int original_channel = channel;
140 
141   log_socket_connection_state(RawAddress::kEmpty, 0, type,
142                               android::bluetooth::SocketConnectionstateEnum::
143                                   SOCKET_CONNECTION_STATE_LISTENING,
144                               0, 0, app_uid, channel,
145                               android::bluetooth::SOCKET_ROLE_LISTEN);
146   switch (type) {
147     case BTSOCK_RFCOMM:
148       status = btsock_rfc_listen(service_name, service_uuid, channel, sock_fd,
149                                  flags, app_uid);
150       break;
151     case BTSOCK_L2CAP:
152       status =
153           btsock_l2cap_listen(service_name, channel, sock_fd, flags, app_uid);
154       break;
155     case BTSOCK_L2CAP_LE:
156       if (flags & BTSOCK_FLAG_NO_SDP) {
157         /* Set channel to zero so that it will be assigned */
158         channel = 0;
159       } else if (channel <= 0) {
160         LOG_ERROR("%s: type BTSOCK_L2CAP_LE: invalid channel=%d", __func__,
161                   channel);
162         break;
163       }
164       flags |= BTSOCK_FLAG_LE_COC;
165       LOG_INFO(
166 
167           "%s: type=BTSOCK_L2CAP_LE, channel=0x%x, original=0x%x, flags=0x%x",
168           __func__, channel, original_channel, flags);
169       status =
170           btsock_l2cap_listen(service_name, channel, sock_fd, flags, app_uid);
171       break;
172     case BTSOCK_SCO:
173       status = btsock_sco_listen(sock_fd, flags);
174       break;
175 
176     default:
177       LOG_ERROR("%s unknown/unsupported socket type: %d", __func__, type);
178       status = BT_STATUS_UNSUPPORTED;
179       break;
180   }
181   if (status != BT_STATUS_SUCCESS) {
182     log_socket_connection_state(RawAddress::kEmpty, 0, type,
183                                 android::bluetooth::SocketConnectionstateEnum::
184                                     SOCKET_CONNECTION_STATE_DISCONNECTED,
185                                 0, 0, app_uid, channel,
186                                 android::bluetooth::SOCKET_ROLE_LISTEN);
187   }
188   return status;
189 }
190 
btsock_connect(const RawAddress * bd_addr,btsock_type_t type,const Uuid * uuid,int channel,int * sock_fd,int flags,int app_uid)191 static bt_status_t btsock_connect(const RawAddress* bd_addr, btsock_type_t type,
192                                   const Uuid* uuid, int channel, int* sock_fd,
193                                   int flags, int app_uid) {
194   CHECK(bd_addr != NULL);
195   CHECK(sock_fd != NULL);
196 
197   *sock_fd = INVALID_FD;
198   bt_status_t status = BT_STATUS_FAIL;
199 
200   log_socket_connection_state(*bd_addr, 0, type,
201                               android::bluetooth::SocketConnectionstateEnum::
202                                   SOCKET_CONNECTION_STATE_CONNECTING,
203                               0, 0, app_uid, channel,
204                               android::bluetooth::SOCKET_ROLE_CONNECTION);
205   switch (type) {
206     case BTSOCK_RFCOMM:
207       status =
208           btsock_rfc_connect(bd_addr, uuid, channel, sock_fd, flags, app_uid);
209       break;
210 
211     case BTSOCK_L2CAP:
212       status = btsock_l2cap_connect(bd_addr, channel, sock_fd, flags, app_uid);
213       break;
214 
215     case BTSOCK_L2CAP_LE: {
216       flags |= BTSOCK_FLAG_LE_COC;
217 
218       // Ensure device is in inquiry database
219       tBLE_ADDR_TYPE addr_type = BLE_ADDR_PUBLIC;
220       int device_type = 0;
221 
222       if (btif_get_address_type(*bd_addr, &addr_type) &&
223           btif_get_device_type(*bd_addr, &device_type) &&
224           device_type != BT_DEVICE_TYPE_BREDR) {
225         BTA_DmAddBleDevice(*bd_addr, addr_type, device_type);
226       }
227 
228       LOG_INFO("%s: type=BTSOCK_L2CAP_LE, channel=0x%x, flags=0x%x", __func__,
229                channel, flags);
230       status = btsock_l2cap_connect(bd_addr, channel, sock_fd, flags, app_uid);
231       break;
232     }
233 
234     case BTSOCK_SCO:
235       status = btsock_sco_connect(bd_addr, sock_fd, flags);
236       break;
237 
238     default:
239       LOG_ERROR("%s unknown/unsupported socket type: %d", __func__, type);
240       status = BT_STATUS_UNSUPPORTED;
241       break;
242   }
243   if (status != BT_STATUS_SUCCESS) {
244     log_socket_connection_state(*bd_addr, 0, type,
245                                 android::bluetooth::SocketConnectionstateEnum::
246                                     SOCKET_CONNECTION_STATE_DISCONNECTED,
247                                 0, 0, app_uid, channel,
248                                 android::bluetooth::SOCKET_ROLE_CONNECTION);
249   }
250   return status;
251 }
252 
btsock_request_max_tx_data_length(const RawAddress & remote_device)253 static void btsock_request_max_tx_data_length(const RawAddress& remote_device) {
254   BTA_DmBleRequestMaxTxDataLength(remote_device);
255 }
256 
btsock_signaled(int fd,int type,int flags,uint32_t user_id)257 static void btsock_signaled(int fd, int type, int flags, uint32_t user_id) {
258   switch (type) {
259     case BTSOCK_RFCOMM:
260       btsock_rfc_signaled(fd, flags, user_id);
261       break;
262     case BTSOCK_L2CAP:
263     case BTSOCK_L2CAP_LE:
264       /* Note: The caller may not distinguish between BTSOCK_L2CAP and
265        * BTSOCK_L2CAP_LE correctly */
266       btsock_l2cap_signaled(fd, flags, user_id);
267       break;
268     default:
269       LOG(FATAL) << "Invalid socket type! type=" << type << " fd=" << fd
270                  << " flags=" << flags << " user_id=" << user_id;
271       break;
272   }
273 }
274