• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "softbus_ble_connection.h"
16 
17 #include <stdio.h>
18 #include <stdbool.h>
19 #include <stdint.h>
20 #include <string.h>
21 #include <sys/prctl.h>
22 #include <time.h>
23 
24 #include "bus_center_manager.h"
25 #include "cJSON.h"
26 #include "common_list.h"
27 #include "message_handler.h"
28 #include "securec.h"
29 #include "softbus_adapter_ble_gatt_server.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_adapter_crypto.h"
32 #include "softbus_adapter_timer.h"
33 #include "softbus_ble_gatt_client.h"
34 #include "softbus_ble_gatt_server.h"
35 #include "softbus_ble_queue.h"
36 #include "softbus_ble_trans_manager.h"
37 #include "softbus_conn_manager.h"
38 #include "softbus_common.h"
39 #include "softbus_def.h"
40 #include "softbus_datahead_transform.h"
41 #include "softbus_errcode.h"
42 #include "softbus_json_utils.h"
43 #include "softbus_log.h"
44 #include "softbus_queue.h"
45 #include "softbus_type_def.h"
46 #include "softbus_utils.h"
47 #include "softbus_hidumper_conn.h"
48 #include "softbus_hisysevt_connreporter.h"
49 
50 #define SEND_QUEUE_UNIT_NUM 128
51 #define CONNECT_REF_INCRESE 1
52 #define CONNECT_REF_DECRESE (-1)
53 #define METHOD_NOTIFY_REQUEST 1
54 #define METHOD_NOTIFY_RESPONSE 2
55 #define METHOD_SHUT_DOWN 3
56 #define CONN_MAGIC_NUMBER  0xBABEFACE
57 #define KEY_METHOD "KEY_METHOD"
58 #define KEY_DELTA "KEY_DELTA"
59 #define KEY_REF_NUM "KEY_REF_NUM"
60 #define TYPE_HEADER_SIZE 4
61 #define INVALID_CLIENID (-1)
62 #define BLE_CONNECTION_INFO "BleConnectionInfo"
63 #define CONNECTED_WAIT_TIME (2 * 1000)
64 
65 typedef enum {
66     BLE_CONNECTION_STATE_CONNECTING = 0,
67     BLE_CONNECTION_STATE_CONNECTED,
68     BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED,
69     BLE_CONNECTION_STATE_CLOSING,
70     BLE_CONNECTION_STATE_CLOSED
71 } BleConnectionState;
72 
73 typedef enum {
74     TYPE_UNKNOW = -1,
75     TYPE_AUTH = 0,
76     TYPE_BASIC_INFO = 1,
77     TYPE_DEV_INFO = 2,
78 } BleNetMsgType;
79 
80 typedef enum {
81     BLE_CONNECTION_DISCONNECT_OUT,
82 } BleConnectionLoopMsg;
83 
84 static SoftBusHandler g_bleConnectAsyncHandler = {
85     .name = (char *)"g_bleConnectAsyncHandler"
86 };
87 
88 static const int BLE_GATT_ATT_MTU_DEFAULT_PAYLOAD = 21;
89 static const int BLE_GATT_ATT_MTU_MAX = 512;
90 static const int BLE_ROLE_CLIENT = 1;
91 static const int BLE_ROLE_SERVER = 2;
92 
93 static LIST_HEAD(g_connection_list);
94 static ConnectCallback *g_connectCallback = NULL;
95 static ConnectFuncInterface g_bleInterface = {0};
96 static SoftBusMutex g_connectionLock;
97 
98 static void PackRequest(int32_t delta, uint32_t connectionId);
99 static int32_t SendSelfBasicInfo(uint32_t connId, int32_t roleType);
100 static int32_t BleConnectionDump(int fd);
101 static int32_t BleConnectionRemoveMessageFunc(const SoftBusMessage *msg, void *args);
102 
AllocBleConnectionIdLocked()103 static uint32_t AllocBleConnectionIdLocked()
104 {
105     static uint16_t nextConnectionId = 0;
106     uint32_t tempId;
107     if (SoftBusMutexLock(&g_connectionLock) != 0) {
108         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
109         return 0;
110     }
111     nextConnectionId++;
112     while (1) {
113         tempId = (CONNECT_BLE << CONNECT_TYPE_SHIFT) + nextConnectionId;
114         ListNode *item = NULL;
115         LIST_FOR_EACH(item, &g_connection_list) {
116             BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
117             if (itemNode->connId == tempId) {
118                 nextConnectionId++;
119                 continue;
120             }
121         }
122         break;
123     }
124     (void)SoftBusMutexUnlock(&g_connectionLock);
125     return tempId;
126 }
127 
CreateBleConnectionNode(void)128 static BleConnectionInfo* CreateBleConnectionNode(void)
129 {
130     BleConnectionInfo *newConnectionInfo = (BleConnectionInfo *)SoftBusCalloc(sizeof(BleConnectionInfo));
131     if (newConnectionInfo == NULL) {
132         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "[CreateBleConnectionNode malloc fail.]");
133         return NULL;
134     }
135     ListInit(&newConnectionInfo->node);
136     ListInit(&newConnectionInfo->requestList);
137     newConnectionInfo->connId = AllocBleConnectionIdLocked();
138     newConnectionInfo->mtu = BLE_GATT_ATT_MTU_DEFAULT_PAYLOAD;
139     newConnectionInfo->refCount = 0;
140     newConnectionInfo->info.isAvailable = 1;
141     newConnectionInfo->info.type = CONNECT_BLE;
142     return newConnectionInfo;
143 }
144 
ReleaseBleconnectionNode(BleConnectionInfo * newConnectionInfo)145 static void ReleaseBleconnectionNode(BleConnectionInfo *newConnectionInfo)
146 {
147     if (newConnectionInfo == NULL) {
148         return;
149     }
150 
151     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "ReleaseBleconnectionNode");
152     BleRequestInfo *requestInfo = NULL;
153     ListNode *item = NULL;
154     ListNode *itemNext = NULL;
155     if (IsListEmpty(&newConnectionInfo->requestList) != true) {
156         LIST_FOR_EACH_SAFE(item, itemNext, &newConnectionInfo->requestList) {
157             requestInfo = LIST_ENTRY(item, BleRequestInfo, node);
158             ListDelete(&requestInfo->node);
159             SoftBusFree(requestInfo);
160         }
161     }
162     SoftBusFree(newConnectionInfo);
163     return;
164 }
165 
DeleteBleConnectionNode(BleConnectionInfo * node)166 void DeleteBleConnectionNode(BleConnectionInfo* node)
167 {
168     if (node == NULL) {
169         return;
170     }
171     node->state = BLE_CONNECTION_STATE_CLOSED;
172     for (int i = 0; i < MAX_CACHE_NUM_PER_CONN; i++) {
173         if (node->recvCache[i].cache != NULL) {
174             SoftBusFree(node->recvCache[i].cache);
175         }
176     }
177     SoftBusFree(node);
178 }
179 
GetBleConnInfoByConnId(uint32_t connectionId)180 static BleConnectionInfo* GetBleConnInfoByConnId(uint32_t connectionId)
181 {
182     ListNode *item = NULL;
183     BleConnectionInfo *itemNode = NULL;
184     if (SoftBusMutexLock(&g_connectionLock) != 0) {
185         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
186         return NULL;
187     }
188     LIST_FOR_EACH(item, &g_connection_list) {
189         itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
190         if (itemNode->connId == connectionId) {
191             break;
192         }
193     }
194     (void)SoftBusMutexUnlock(&g_connectionLock);
195     return itemNode;
196 }
197 
GetBleConnInfoByHalConnId(BleHalConnInfo halConnInfo)198 BleConnectionInfo* GetBleConnInfoByHalConnId(BleHalConnInfo halConnInfo)
199 {
200     ListNode *item = NULL;
201     BleConnectionInfo *itemNode = NULL;
202     if (SoftBusMutexLock(&g_connectionLock) != 0) {
203         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
204         return NULL;
205     }
206     LIST_FOR_EACH(item, &g_connection_list) {
207         itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
208         if (itemNode->halConnId == halConnInfo.halConnId && itemNode->info.isServer == halConnInfo.isServer) {
209             break;
210         }
211     }
212     (void)SoftBusMutexUnlock(&g_connectionLock);
213     return itemNode;
214 }
215 
GetBleConnInfoByAddr(const char * strAddr,BleConnectionInfo ** server,BleConnectionInfo ** client)216 static int32_t GetBleConnInfoByAddr(const char *strAddr, BleConnectionInfo **server, BleConnectionInfo **client)
217 {
218     ListNode *item = NULL;
219     BleConnectionInfo *itemNode = NULL;
220     bool findServer = false;
221     bool findClient = false;
222     if (SoftBusMutexLock(&g_connectionLock) != 0) {
223         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
224         return SOFTBUS_BLECONNECTION_MUTEX_LOCK_ERROR;
225     }
226     LIST_FOR_EACH(item, &g_connection_list) {
227         itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
228         if (memcmp(itemNode->info.bleInfo.bleMac, strAddr, BT_MAC_LEN) == 0) {
229             if (itemNode->info.isServer) {
230                 *server = itemNode;
231                 findServer = true;
232             } else {
233                 *client = itemNode;
234                 findClient = true;
235             }
236             if (findServer && findClient) {
237                 break;
238             }
239         }
240     }
241     (void)SoftBusMutexUnlock(&g_connectionLock);
242     return SOFTBUS_OK;
243 }
244 
GetBleConnInfoByDeviceIdHash(const char * deviceIdHash,BleConnectionInfo ** server,BleConnectionInfo ** client)245 static int32_t GetBleConnInfoByDeviceIdHash(const char *deviceIdHash,
246     BleConnectionInfo **server, BleConnectionInfo **client)
247 {
248     ListNode *item = NULL;
249     BleConnectionInfo *itemNode = NULL;
250     bool findServer = false;
251     bool findClient = false;
252     if (SoftBusMutexLock(&g_connectionLock) != 0) {
253         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
254         return SOFTBUS_BLECONNECTION_MUTEX_LOCK_ERROR;
255     }
256     LIST_FOR_EACH(item, &g_connection_list) {
257         itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
258         if (memcmp(itemNode->info.bleInfo.deviceIdHash, deviceIdHash, UDID_HASH_LEN) == 0) {
259             if (itemNode->info.isServer) {
260                 *server = itemNode;
261                 findServer = true;
262             } else {
263                 *client = itemNode;
264                 findClient = true;
265             }
266             if (findServer && findClient) {
267                 break;
268             }
269         }
270     }
271     (void)SoftBusMutexUnlock(&g_connectionLock);
272     return SOFTBUS_OK;
273 }
274 
275 
BleDeviceConnected(const BleConnectionInfo * itemNode,uint32_t requestId,const ConnectResult * result)276 static void BleDeviceConnected(const BleConnectionInfo *itemNode, uint32_t requestId, const ConnectResult *result)
277 {
278     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "ble mac has connected");
279     ConnectionInfo connectionInfo;
280     connectionInfo.isAvailable = 1;
281     connectionInfo.isServer = itemNode->info.isServer;
282     connectionInfo.type = CONNECT_BLE;
283     if (strcpy_s(connectionInfo.bleInfo.bleMac, BT_MAC_LEN, itemNode->info.bleInfo.bleMac) != EOK) {
284         return;
285     }
286     int connectionId = itemNode->connId;
287 
288     if (result->OnConnectSuccessed != NULL) {
289         result->OnConnectSuccessed(
290             requestId, connectionId, &connectionInfo);
291     }
292 
293     (void)PackRequest(CONNECT_REF_INCRESE, connectionId);
294 }
295 
CreateBleRequestInfo(uint32_t requestId,const ConnectResult * result)296 static BleRequestInfo *CreateBleRequestInfo(uint32_t requestId, const ConnectResult *result)
297 {
298     BleRequestInfo *request = (BleRequestInfo *)SoftBusCalloc(sizeof(BleRequestInfo));
299     if (request == NULL) {
300         return NULL;
301     }
302     ListInit(&request->node);
303     request->requestId = requestId;
304     request->callback = *result;
305     return request;
306 }
307 
NewBleConnection(const ConnectOption * option,uint32_t requestId,const ConnectResult * result)308 static BleConnectionInfo* NewBleConnection(const ConnectOption *option, uint32_t requestId, const ConnectResult *result)
309 {
310     BleConnectionInfo *newConnectionInfo = CreateBleConnectionNode();
311     if (newConnectionInfo == NULL) {
312         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "create ble connection node failed, requestId: %d", requestId);
313         return NULL;
314     }
315     newConnectionInfo->mtu = BLE_GATT_ATT_MTU_MAX;
316     newConnectionInfo->state = BLE_CONNECTION_STATE_CONNECTING;
317     newConnectionInfo->info.isServer = BLE_CLIENT_TYPE;
318     if (strcpy_s(newConnectionInfo->info.bleInfo.bleMac, BT_MAC_LEN,
319         option->bleOption.bleMac) != EOK) {
320         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "strcpy_s failed, requestId: %d", requestId);
321         ReleaseBleconnectionNode(newConnectionInfo);
322         return NULL;
323     }
324     if (ConvertBtMacToBinary(option->bleOption.bleMac, BT_MAC_LEN,
325         newConnectionInfo->btBinaryAddr.addr, BT_ADDR_LEN) != SOFTBUS_OK) {
326         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "convert bt mac to binary failed, requestId: %d", requestId);
327         ReleaseBleconnectionNode(newConnectionInfo);
328         return NULL;
329     }
330     BleRequestInfo *requestInfo = CreateBleRequestInfo(requestId, result);
331     if (requestInfo == NULL) {
332         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "CreateBleRequestInfo failed, requestId: %d", requestId);
333         ReleaseBleconnectionNode(newConnectionInfo);
334         return NULL;
335     }
336     ListAdd(&newConnectionInfo->requestList, &requestInfo->node);
337     return newConnectionInfo;
338 }
339 
UpdataBleConnectionUnsafe(const ConnectOption * option,int32_t halId,uint32_t requestId)340 static int32_t UpdataBleConnectionUnsafe(const ConnectOption *option, int32_t halId, uint32_t requestId)
341 {
342     BleConnectionInfo *server = NULL;
343     BleConnectionInfo *client = NULL;
344     if (GetBleConnInfoByAddr(option->bleOption.bleMac, &server, &client) != SOFTBUS_OK) {
345         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "GetBleConnInfoByAddr failed, requestId: %d", requestId);
346         return SOFTBUS_ERR;
347     }
348     (void)server;
349     if (client == NULL) {
350         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "unexperted failure! there is no ble connection info, "
351             "requestId: %d", requestId);
352         return SOFTBUS_ERR;
353     }
354     if (halId < 0) {
355         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "gatt client connect failed, ret: %d, requestId: %d",
356             halId, requestId);
357         ListDelete(&client->node);
358         ReleaseBleconnectionNode(client);
359         return SOFTBUS_ERR;
360     }
361     client->halConnId = halId;
362     return SOFTBUS_OK;
363 }
364 
TryReuseConnectionOrWaitUnsafe(BleConnectionInfo * exist,uint32_t requestId,const ConnectResult * result)365 static int32_t TryReuseConnectionOrWaitUnsafe(BleConnectionInfo *exist, uint32_t requestId,
366     const ConnectResult *result)
367 {
368     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "there is a ble connection processing, state: %d, requestId: %d",
369         exist->state, requestId);
370 
371     if (exist->state == BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED) {
372         BleDeviceConnected(exist, requestId, result);
373         return SOFTBUS_OK;
374     }
375     if (exist->state == BLE_CONNECTION_STATE_CONNECTING || exist->state == BLE_CONNECTION_STATE_CONNECTED) {
376         BleRequestInfo *requestInfo = CreateBleRequestInfo(requestId, result);
377         if (requestInfo == NULL) {
378             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "CreateBleRequestInfo failed, requestId: %d", requestId);
379             return SOFTBUS_ERR;
380         }
381         ListAdd(&exist->requestList, &requestInfo->node);
382         return SOFTBUS_OK;
383     }
384     if (exist->state == BLE_CONNECTION_STATE_CLOSING) {
385         result->OnConnectFailed(requestId, 0);
386         return SOFTBUS_OK;
387     }
388 
389     return SOFTBUS_ERR;
390 }
391 
BleConnectDevice(const ConnectOption * option,uint32_t requestId,const ConnectResult * result)392 static int32_t BleConnectDevice(const ConnectOption *option, uint32_t requestId, const ConnectResult *result)
393 {
394     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "BleConnectDevice, requestId=%d", requestId);
395     if (SoftBusMutexLock(&g_connectionLock) != 0) {
396         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "%s: lock mutex failed, requestId: %d", __func__, requestId);
397         return SOFTBUS_ERR;
398     }
399     BleConnectionInfo *server = NULL;
400     BleConnectionInfo *client = NULL;
401     if (GetBleConnInfoByAddr(option->bleOption.bleMac, &server, &client) != SOFTBUS_OK) {
402         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_CONNECT_FAIL);
403         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "GetBleConnInfoByAddr failed, requestId: %d", requestId);
404         SoftbusRecordConnInfo(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_EVT_CONN_FAIL, 0);
405         (void)SoftBusMutexUnlock(&g_connectionLock);
406         return SOFTBUS_ERR;
407     }
408     (void)server;
409     if (client != NULL) {
410         int ret = TryReuseConnectionOrWaitUnsafe(client, requestId, result);
411         (void)SoftBusMutexUnlock(&g_connectionLock);
412         return ret;
413     }
414     BleConnectionInfo *newConnectionInfo = NewBleConnection(option, requestId, result);
415     if (newConnectionInfo == NULL) {
416         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "ble client node create fail, requestId: %d", requestId);
417         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_CONNECT_FAIL);
418         (void)SoftBusMutexUnlock(&g_connectionLock);
419         return SOFTBUS_ERR;
420     }
421     uint32_t connId = newConnectionInfo->connId;
422     ListAdd(&g_connection_list, &newConnectionInfo->node);
423     (void)SoftBusMutexUnlock(&g_connectionLock);
424 
425     int32_t clientId = INVALID_CLIENID;
426     clientId = SoftBusGattClientConnect(&(newConnectionInfo->btBinaryAddr), option->bleOption.fastestConnectEnable);
427 
428     if (SoftBusMutexLock(&g_connectionLock) != 0) {
429         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "%s: lock mutex failed, requestId: %d", __func__, requestId);
430         return SOFTBUS_ERR;
431     }
432     if (UpdataBleConnectionUnsafe(option, clientId, requestId) != SOFTBUS_OK) {
433         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_CONNECT_FAIL);
434         SoftbusRecordConnInfo(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_EVT_CONN_FAIL, 0);
435         (void)SoftBusMutexUnlock(&g_connectionLock);
436         return SOFTBUS_ERR;
437     }
438     (void)SoftBusMutexUnlock(&g_connectionLock);
439     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "new connection %d, clientId: %d, requesId: %d",
440         connId, clientId, requestId);
441     return SOFTBUS_OK;
442 }
443 
BlePostBytes(uint32_t connectionId,const char * data,int32_t len,int32_t pid,int32_t flag)444 static int32_t BlePostBytes(uint32_t connectionId, const char *data, int32_t len, int32_t pid, int32_t flag)
445 {
446     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO,
447         "BlePostBytes connectionId=%u,pid=%d,len=%d flag=%d", connectionId, pid, len, flag);
448     if (data == NULL) {
449         return SOFTBUS_ERR;
450     }
451     if (SoftBusMutexLock(&g_connectionLock) != 0) {
452         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
453         SoftBusFree((void *)data);
454         return SOFTBUS_ERR;
455     }
456     BleConnectionInfo *connInfo = GetBleConnInfoByConnId(connectionId);
457     if (connInfo == NULL) {
458         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BlePostBytes GetBleConnInfo failed");
459         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_SEND_FAIL);
460         SoftBusFree((void *)data);
461         (void)SoftBusMutexUnlock(&g_connectionLock);
462         return SOFTBUS_BLECONNECTION_GETCONNINFO_ERROR;
463     }
464     SendQueueNode *node = (SendQueueNode *)SoftBusCalloc(sizeof(SendQueueNode));
465     if (node == NULL) {
466         SoftBusFree((void *)data);
467         (void)SoftBusMutexUnlock(&g_connectionLock);
468         return SOFTBUS_MALLOC_ERR;
469     }
470     node->halConnId = connInfo->halConnId;
471     node->connectionId = connectionId;
472     node->isServer = connInfo->info.isServer;
473     node->pid = pid;
474     node->flag = flag;
475     node->len = (uint32_t)len;
476     node->data = data;
477     node->isInner = 0;
478     int ret = BleEnqueueNonBlock((const void *)node);
479     if (ret != SOFTBUS_OK) {
480         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BlePostBytes enqueue failed");
481         SoftBusFree((void *)data);
482         SoftBusFree(node);
483         (void)SoftBusMutexUnlock(&g_connectionLock);
484         return ret;
485     }
486     (void)SoftBusMutexUnlock(&g_connectionLock);
487     return SOFTBUS_OK;
488 }
489 
BlePostBytesInner(uint32_t connectionId,ConnPostData * data)490 static int32_t BlePostBytesInner(uint32_t connectionId, ConnPostData *data)
491 {
492     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "BlePostBytesInner connectionId=%u", connectionId);
493     if (data == NULL) {
494         return SOFTBUS_ERR;
495     }
496     if (SoftBusMutexLock(&g_connectionLock) != 0) {
497         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
498         return SOFTBUS_ERR;
499     }
500     BleConnectionInfo *connInfo = GetBleConnInfoByConnId(connectionId);
501     if (connInfo == NULL) {
502         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BlePostBytes GetBleConnInfo failed");
503         (void)SoftBusMutexUnlock(&g_connectionLock);
504         return SOFTBUS_BLECONNECTION_GETCONNINFO_ERROR;
505     }
506     SendQueueNode *node = (SendQueueNode *)SoftBusCalloc(sizeof(SendQueueNode));
507     if (node == NULL) {
508         (void)SoftBusMutexUnlock(&g_connectionLock);
509         return SOFTBUS_MALLOC_ERR;
510     }
511     node->halConnId = connInfo->halConnId;
512     node->connectionId = connectionId;
513     node->isServer = connInfo->info.isServer;
514     node->len = data->len;
515     node->data = data->buf;
516     node->isInner = 1;
517     node->module = data->module;
518     node->seq = data->seq;
519     int ret = BleEnqueueNonBlock((const void *)node);
520     if (ret != SOFTBUS_OK) {
521         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BlePostBytes enqueue failed");
522         SoftBusFree(node);
523         (void)SoftBusMutexUnlock(&g_connectionLock);
524         return ret;
525     }
526     (void)SoftBusMutexUnlock(&g_connectionLock);
527     return SOFTBUS_OK;
528 }
529 
AddNumToJson(cJSON * json,int32_t requestOrResponse,int32_t delta,int32_t count)530 static int AddNumToJson(cJSON *json, int32_t requestOrResponse, int32_t delta, int32_t count)
531 {
532     if (requestOrResponse == METHOD_NOTIFY_REQUEST) {
533         if (!AddNumberToJsonObject(json, KEY_METHOD, METHOD_NOTIFY_REQUEST) ||
534             !AddNumberToJsonObject(json, KEY_DELTA, delta) ||
535             !AddNumberToJsonObject(json, KEY_REF_NUM, count)) {
536             return SOFTBUS_BRCONNECTION_PACKJSON_ERROR;
537         }
538     } else {
539         if (!AddNumberToJsonObject(json, KEY_METHOD, METHOD_NOTIFY_RESPONSE) ||
540             !AddNumberToJsonObject(json, KEY_REF_NUM, count)) {
541             return SOFTBUS_BRCONNECTION_PACKJSON_ERROR;
542         }
543     }
544     return SOFTBUS_OK;
545 }
546 
SendRefMessage(int32_t delta,int32_t connectionId,int32_t count,int32_t requestOrResponse)547 static void SendRefMessage(int32_t delta, int32_t connectionId, int32_t count, int32_t requestOrResponse)
548 {
549     cJSON *json = cJSON_CreateObject();
550     if (json == NULL) {
551         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "Cannot create cJSON object");
552         return;
553     }
554     if (AddNumToJson(json, requestOrResponse, delta, count) != SOFTBUS_OK) {
555         cJSON_Delete(json);
556         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "Cannot AddNumToJson");
557         return;
558     }
559     char *data = cJSON_PrintUnformatted(json);
560     cJSON_Delete(json);
561     if (data == NULL) {
562         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "cJSON_PrintUnformatted failed");
563         return;
564     }
565     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "SendRefMessage:%s", data);
566     uint32_t headSize = sizeof(ConnPktHead);
567     uint32_t dataLen = strlen(data) + 1 + headSize;
568     char *buf = (char *)SoftBusCalloc(dataLen);
569     if (buf == NULL) {
570         cJSON_free(data);
571         return;
572     }
573     ConnPktHead head;
574     head.magic = CONN_MAGIC_NUMBER;
575     head.module = MODULE_CONNECTION;
576     head.seq = 1;
577     head.flag = 0;
578     head.len = strlen(data) + 1;
579     PackConnPktHead(&head);
580     if (memcpy_s(buf, dataLen, (void *)&head, headSize) != EOK) {
581         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "memcpy_s head error");
582         cJSON_free(data);
583         SoftBusFree(buf);
584         return;
585     }
586     if (memcpy_s(buf + headSize, dataLen - headSize, data, strlen(data) + 1) != EOK) {
587         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "memcpy_s data error");
588         cJSON_free(data);
589         SoftBusFree(buf);
590         return;
591     }
592     cJSON_free(data);
593     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "SendRefMessage BlePostBytes");
594     if (BlePostBytes(connectionId, buf, dataLen, 0, 0) != SOFTBUS_OK) {
595         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendRefMessage BlePostBytes failed");
596     }
597     return;
598 }
599 
PackRequest(int32_t delta,uint32_t connectionId)600 static void PackRequest(int32_t delta, uint32_t connectionId)
601 {
602     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO,
603         "[onNotifyRequest: delta=%d, connectionIds=%u", delta, connectionId);
604     ListNode *item = NULL;
605     BleConnectionInfo *targetNode = NULL;
606     int refCount;
607     if (SoftBusMutexLock(&g_connectionLock) != 0) {
608         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
609         return;
610     }
611     LIST_FOR_EACH(item, &g_connection_list) {
612         BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
613         if (itemNode->connId == connectionId) {
614             itemNode->refCount += delta;
615             refCount = itemNode->refCount;
616             targetNode = itemNode;
617             break;
618         }
619     }
620     if (targetNode != NULL && refCount <= 0) {
621         SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
622         if (msg == NULL) {
623             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "bleConnectionCreateLoopMsg SoftBusCalloc failed");
624             (void)SoftBusMutexUnlock(&g_connectionLock);
625             return;
626         }
627         msg->what = BLE_CONNECTION_DISCONNECT_OUT;
628         msg->arg1 = connectionId;
629         msg->handler = &g_bleConnectAsyncHandler;
630         g_bleConnectAsyncHandler.looper->PostMessageDelay(g_bleConnectAsyncHandler.looper, msg, CONNECTED_WAIT_TIME);
631 
632         targetNode->state = BLE_CONNECTION_STATE_CLOSING;
633     }
634 
635     (void)SoftBusMutexUnlock(&g_connectionLock);
636     if (targetNode == NULL) {
637         return;
638     }
639 
640     SendRefMessage(delta, connectionId, refCount, METHOD_NOTIFY_REQUEST);
641 }
642 
AbortConnection(SoftBusBtAddr btAddr,int32_t halConnId,int32_t isServer)643 static void AbortConnection(SoftBusBtAddr btAddr, int32_t halConnId, int32_t isServer)
644 {
645     if (isServer == BLE_CLIENT_TYPE) {
646         SoftBusGattClientDisconnect(halConnId);
647     }
648     SoftBusGattsDisconnect(btAddr, halConnId);
649 }
650 
OnPackResponse(int32_t delta,int32_t peerRef,uint32_t connectionId)651 static void OnPackResponse(int32_t delta, int32_t peerRef, uint32_t connectionId)
652 {
653     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO,
654         "[onNotifyRequest: delta=%d, RemoteRef=%d, connectionIds=%u", delta, peerRef, connectionId);
655     ListNode *item = NULL;
656     BleConnectionInfo *targetNode = NULL;
657     int myRefCount;
658     if (SoftBusMutexLock(&g_connectionLock) != 0) {
659         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
660         return;
661     }
662     LIST_FOR_EACH(item, &g_connection_list) {
663         BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
664         if (itemNode->connId == connectionId) {
665             targetNode = itemNode;
666             targetNode->refCount += delta;
667             myRefCount = targetNode->refCount;
668             break;
669         }
670     }
671     if (targetNode == NULL) {
672         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "Not find OnPackResponse device");
673         (void)SoftBusMutexUnlock(&g_connectionLock);
674         return;
675     }
676     if (peerRef > 0 && targetNode->state == BLE_CONNECTION_STATE_CLOSING) {
677         g_bleConnectAsyncHandler.looper->RemoveMessageCustom(g_bleConnectAsyncHandler.looper,
678             &g_bleConnectAsyncHandler, BleConnectionRemoveMessageFunc, (void*)(uintptr_t)connectionId);
679 
680         targetNode->state = BLE_CONNECTION_STATE_CONNECTED;
681     }
682 
683     (void)SoftBusMutexUnlock(&g_connectionLock);
684     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[onPackRequest: myRefCount=%d]", myRefCount);
685     if (peerRef > 0) {
686         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[remote device Ref is > 0, do not reply]");
687         return;
688     }
689     if (myRefCount <= 0) {
690         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[local device Ref <= 0, close connection now]");
691         targetNode->state = BLE_CONNECTION_STATE_CLOSING;
692         AbortConnection(targetNode->btBinaryAddr, targetNode->halConnId, targetNode->info.isServer);
693         return;
694     }
695     SendRefMessage(delta, connectionId, myRefCount, METHOD_NOTIFY_RESPONSE);
696 }
697 
RecvConnectedComd(uint32_t connectionId,const cJSON * data)698 static void RecvConnectedComd(uint32_t connectionId, const cJSON *data)
699 {
700     int32_t keyMethod = 0;
701     int32_t keyDelta = 0;
702     int32_t keyReferenceNum = 0;
703     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "RecvConnectedComd ID=%u", connectionId);
704 
705     if (!GetJsonObjectNumberItem(data, KEY_METHOD, &keyMethod)) {
706         return;
707     }
708     if (keyMethod == METHOD_NOTIFY_REQUEST) {
709         if (!GetJsonObjectNumberItem(data, KEY_METHOD, &keyMethod) ||
710             !GetJsonObjectSignedNumberItem(data, KEY_DELTA, &keyDelta) ||
711             !GetJsonObjectNumberItem(data, KEY_REF_NUM, &keyReferenceNum)) {
712             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "REQUEST fail");
713             return;
714         }
715         OnPackResponse(keyDelta, keyReferenceNum, connectionId);
716     }
717     if (keyMethod == METHOD_NOTIFY_RESPONSE) {
718         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "NOTIFY_RESPONSE");
719         if (!GetJsonObjectNumberItem(data, KEY_METHOD, &keyMethod) ||
720             !GetJsonObjectNumberItem(data, KEY_REF_NUM, &keyReferenceNum)) {
721             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "RESPONSE fail");
722             return;
723         }
724         (void)SoftBusMutexLock(&g_connectionLock);
725         ListNode *item = NULL;
726         LIST_FOR_EACH(item, &g_connection_list) {
727             BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
728             if (itemNode->connId == connectionId) {
729                 if (itemNode->state == BLE_CONNECTION_STATE_CLOSING) {
730                     g_bleConnectAsyncHandler.looper->RemoveMessageCustom(g_bleConnectAsyncHandler.looper,
731                         &g_bleConnectAsyncHandler, BleConnectionRemoveMessageFunc, (void*)(uintptr_t)connectionId);
732                     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "NOTIFY_CHANGE");
733                     itemNode->state = BLE_CONNECTION_STATE_CONNECTED;
734                 }
735                 break;
736             }
737         }
738         (void)SoftBusMutexUnlock(&g_connectionLock);
739     }
740 }
741 
BleDisconnectDevice(uint32_t connectionId)742 static int32_t BleDisconnectDevice(uint32_t connectionId)
743 {
744     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[DisconnectDevice]");
745     BleConnectionInfo *connInfo = GetBleConnInfoByConnId(connectionId);
746     if (connInfo == NULL) {
747         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleDisconnectDevice GetBleConnInfo failed");
748         return SOFTBUS_BLECONNECTION_GETCONNINFO_ERROR;
749     }
750     (void)PackRequest(CONNECT_REF_DECRESE, connectionId);
751     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[DisconnectDevice over]");
752     return SOFTBUS_OK;
753 }
754 
BleDisconnectDeviceNow(const ConnectOption * option)755 static int32_t BleDisconnectDeviceNow(const ConnectOption *option)
756 {
757     int32_t ret;
758     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[DisconnectDeviceByOption]");
759     BleConnectionInfo *server = NULL;
760     BleConnectionInfo *client = NULL;
761     if (SoftBusMutexLock(&g_connectionLock) != 0) {
762         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
763         return SOFTBUS_ERR;
764     }
765     ret = GetBleConnInfoByAddr(option->bleOption.bleMac, &server, &client);
766     if ((ret != SOFTBUS_OK) || ((server == NULL) && (client == NULL))) {
767         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleDisconnectDevice GetBleConnInfo failed");
768         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_DISCONNECT_FAIL);
769         (void)SoftBusMutexUnlock(&g_connectionLock);
770         return SOFTBUS_BLECONNECTION_GETCONNINFO_ERROR;
771     }
772     if (server != NULL) {
773         server->state = BLE_CONNECTION_STATE_CLOSING;
774         SoftBusBtAddr binAddr = server->btBinaryAddr;
775         int32_t halId = server->halConnId;
776         (void)SoftBusMutexUnlock(&g_connectionLock);
777         SoftBusGattsDisconnect(binAddr, halId);
778     } else {
779         client->state = BLE_CONNECTION_STATE_CLOSING;
780         int32_t halId = client->halConnId;
781         (void)SoftBusMutexUnlock(&g_connectionLock);
782         SoftBusGattClientDisconnect(halId);
783     }
784     return ret;
785 }
786 
BleGetConnectionInfo(uint32_t connectionId,ConnectionInfo * info)787 static int32_t BleGetConnectionInfo(uint32_t connectionId, ConnectionInfo *info)
788 {
789     int32_t result = SOFTBUS_ERR;
790     if (SoftBusMutexLock(&g_connectionLock) != 0) {
791         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
792         return SOFTBUS_ERR;
793     }
794     ListNode *item = NULL;
795     LIST_FOR_EACH(item, &g_connection_list) {
796         BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
797         if (itemNode->connId == connectionId) {
798             if (memcpy_s(info, sizeof(ConnectionInfo), &(itemNode->info), sizeof(ConnectionInfo)) != EOK) {
799                 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleGetConnInfo scpy error");
800                 (void)SoftBusMutexUnlock(&g_connectionLock);
801                 return SOFTBUS_BLECONNECTION_GETCONNINFO_ERROR;
802             }
803             result = SOFTBUS_OK;
804             break;
805         }
806     }
807     (void)SoftBusMutexUnlock(&g_connectionLock);
808     return result;
809 }
810 
BleStartLocalListening(const LocalListenerInfo * info)811 static int32_t BleStartLocalListening(const LocalListenerInfo *info)
812 {
813     return SoftBusGattServerStartService();
814 }
815 
BleStopLocalListening(const LocalListenerInfo * info)816 static int32_t BleStopLocalListening(const LocalListenerInfo *info)
817 {
818     return SoftBusGattServerStopService();
819 }
820 
BleCheckActiveConnection(const ConnectOption * option)821 static bool BleCheckActiveConnection(const ConnectOption *option)
822 {
823     if (option == NULL || option->type != CONNECT_BLE) {
824         return false;
825     }
826     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "BleCheckActiveConnection");
827     int32_t ret;
828     BleConnectionInfo *server = NULL;
829     BleConnectionInfo *client = NULL;
830 
831     if (SoftBusMutexLock(&g_connectionLock) != 0) {
832         return false;
833     }
834     ret = GetBleConnInfoByDeviceIdHash(option->bleOption.deviceIdHash, &server, &client);
835     if ((ret != SOFTBUS_OK) || (server == NULL && client == NULL)) {
836         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleCheckActiveConnection no active conn");
837         (void)SoftBusMutexUnlock(&g_connectionLock);
838         return false;
839     }
840     if ((server != NULL && server->state == BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED) ||
841         (client != NULL && client->state == BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED)) {
842         (void)SoftBusMutexUnlock(&g_connectionLock);
843         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "BleCheckActiveConnection had active conn");
844         return true;
845     }
846     (void)SoftBusMutexUnlock(&g_connectionLock);
847     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "BleCheckActiveConnection no active conn");
848     return false;
849 }
850 
BleUpdateConnection(uint32_t connectionId,UpdateOption * option)851 static int32_t BleUpdateConnection(uint32_t connectionId, UpdateOption *option)
852 {
853     BleConnectionInfo *connInfo = GetBleConnInfoByConnId(connectionId);
854     if (connInfo == NULL) {
855         CLOGE("update ble connection failed, %u not exist", connectionId);
856         return SOFTBUS_ERR;
857     }
858     if (connInfo->state != BLE_CONNECTION_STATE_CONNECTED &&
859         connInfo->state != BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED) {
860         CLOGE("update ble connection failed, %u current state is %d, only %d or %d support", connectionId,
861             connInfo->state, BLE_CONNECTION_STATE_CONNECTED, BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED);
862         return SOFTBUS_ERR;
863     }
864     if (connInfo->info.isServer) {
865         CLOGE("update ble connection failed, %u is server side, only client side support", connectionId);
866         return SOFTBUS_ERR;
867     }
868 
869     SoftbusGattPriority priority;
870     switch (option->bleOption.priority) {
871         case CONN_BLE_PRIORITY_BALANCED:
872             priority = SOFTBUS_GATT_PRIORITY_BALANCED;
873             break;
874         case CONN_BLE_PRIORITY_HIGH:
875             priority = SOFTBUS_GATT_PRIORITY_HIGH;
876             break;
877         case CONN_BLE_PRIORITY_LOW_POWER:
878             priority = SOFTBUS_GATT_PRIORITY_LOW_POWER;
879             break;
880         default:
881             CLOGE("update ble connection failed, %u, unknown priority: %d", connectionId, option->bleOption.priority);
882             return SOFTBUS_ERR;
883     }
884     int32_t ret = SoftbusGattcSetPriority(connInfo->halConnId, &connInfo->btBinaryAddr, priority);
885     CLOGI("set ble connection priority to %d, ret=%d", priority, ret);
886     return ret;
887 }
888 
BleDeviceConnectPackRequest(int32_t value,int32_t connId)889 static void BleDeviceConnectPackRequest(int32_t value, int32_t connId)
890 {
891     int32_t data = value;
892     while (data-- > 0) {
893         (void)PackRequest(CONNECT_REF_INCRESE, connId);
894     }
895 }
896 
BleClientConnectCallback(int32_t halConnId,const char * bleStrMac,const SoftBusBtAddr * btAddr)897 static void BleClientConnectCallback(int32_t halConnId, const char *bleStrMac, const SoftBusBtAddr *btAddr)
898 {
899     ListNode *bleItem = NULL;
900     (void)SoftBusMutexLock(&g_connectionLock);
901     uint32_t connId = 0;
902     LIST_FOR_EACH(bleItem, &g_connection_list) {
903         BleConnectionInfo *itemNode = LIST_ENTRY(bleItem, BleConnectionInfo, node);
904         if (itemNode->halConnId != halConnId || itemNode->info.isServer != BLE_CLIENT_TYPE) {
905             continue;
906         }
907         connId = itemNode->connId;
908         itemNode->state = BLE_CONNECTION_STATE_CONNECTED;
909     }
910     (void)SoftBusMutexUnlock(&g_connectionLock);
911     SoftbusGattcHandShakeEvent(halConnId);
912     if (SendSelfBasicInfo(connId, BLE_ROLE_CLIENT) != SOFTBUS_OK) {
913         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendSelfBasicInfo error");
914     }
915 }
916 
BleClientDoneConnect(BleConnectionInfo * targetNode)917 static void BleClientDoneConnect(BleConnectionInfo *targetNode)
918 {
919     ListNode notifyList;
920     ListNode *item = NULL;
921     ListNode *itemNext = NULL;
922     BleRequestInfo *requestInfo = NULL;
923     int32_t packRequestFlag = 0;
924     ListInit(&notifyList);
925     LIST_FOR_EACH_SAFE(item, itemNext, &targetNode->requestList) {
926         requestInfo = LIST_ENTRY(item, BleRequestInfo, node);
927         ListDelete(&requestInfo->node);
928         ListAdd(&notifyList, &requestInfo->node);
929         packRequestFlag++;
930     }
931     if (packRequestFlag == 0) {
932         return;
933     }
934     BleDeviceConnectPackRequest(packRequestFlag, targetNode->connId);
935     LIST_FOR_EACH_SAFE(item, itemNext, &notifyList) {
936         requestInfo = LIST_ENTRY(item, BleRequestInfo, node);
937         if (requestInfo->callback.OnConnectSuccessed != NULL) {
938             requestInfo->callback.OnConnectSuccessed(
939                 requestInfo->requestId, targetNode->connId, &targetNode->info);
940         }
941         ListDelete(&requestInfo->node);
942         SoftBusFree(requestInfo);
943     }
944 }
945 
BleServerConnectCallback(int32_t halConnId,const char * bleStrMac,const SoftBusBtAddr * btAddr)946 static void BleServerConnectCallback(int32_t halConnId, const char *bleStrMac, const SoftBusBtAddr *btAddr)
947 {
948     if (SoftBusMutexLock(&g_connectionLock) != 0) {
949         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
950         return;
951     }
952     ListNode *item = NULL;
953     LIST_FOR_EACH(item, &g_connection_list) {
954         BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
955         if (itemNode->halConnId == halConnId && itemNode->info.isServer == BLE_SERVER_TYPE) {
956             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleConnectCallback exist same connId, exit");
957             (void)SoftBusMutexUnlock(&g_connectionLock);
958             return;
959         }
960     }
961     BleConnectionInfo *newNode = CreateBleConnectionNode();
962     if (newNode == NULL) {
963         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "ble client node create fail");
964         (void)SoftBusMutexUnlock(&g_connectionLock);
965         return;
966     }
967     newNode->halConnId = halConnId;
968     if (memcpy_s(newNode->btBinaryAddr.addr, BT_ADDR_LEN, btAddr->addr, BT_ADDR_LEN) != EOK) {
969         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleConnectCallback memcpy_s error");
970         SoftBusFree(newNode);
971         (void)SoftBusMutexUnlock(&g_connectionLock);
972         return;
973     }
974     if (memcpy_s(newNode->info.bleInfo.bleMac, BT_MAC_LEN, bleStrMac, BT_MAC_LEN) != EOK) {
975         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleConnectCallback memcpy_s error");
976         SoftBusFree(newNode);
977         (void)SoftBusMutexUnlock(&g_connectionLock);
978         return;
979     }
980     newNode->info.isServer = BLE_SERVER_TYPE;
981     newNode->state = BLE_CONNECTION_STATE_CONNECTED;
982     ListTailInsert(&g_connection_list, &(newNode->node));
983     (void)SoftBusMutexUnlock(&g_connectionLock);
984 }
985 
ReleaseBleConnectionInfo(BleConnectionInfo * info)986 static void ReleaseBleConnectionInfo(BleConnectionInfo *info)
987 {
988     if (info == NULL) {
989         return;
990     }
991     ListNode *item = NULL;
992     ListNode *nextItem = NULL;
993     ListDelete(&info->node);
994     LIST_FOR_EACH_SAFE(item, nextItem, &info->requestList) {
995         BleRequestInfo *requestInfo = LIST_ENTRY(item, BleRequestInfo, node);
996         ListDelete(&(requestInfo->node));
997         SoftBusFree(requestInfo);
998     }
999     SoftBusFree(info);
1000 }
1001 
BleNotifyDisconnect(const ListNode * notifyList,int32_t connectionId,ConnectionInfo connectionInfo,int32_t errCode)1002 static void BleNotifyDisconnect(const ListNode *notifyList, int32_t connectionId,
1003     ConnectionInfo connectionInfo, int32_t errCode)
1004 {
1005     ListNode *item = NULL;
1006     ListNode *itemNext = NULL;
1007     if (IsListEmpty(notifyList) != true) {
1008         LIST_FOR_EACH_SAFE(item, itemNext, notifyList) {
1009             BleRequestInfo *requestInfo = LIST_ENTRY(item, BleRequestInfo, node);
1010             if (requestInfo->callback.OnConnectFailed != NULL) {
1011                 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[BleNotifyDisconnect]connectionId=%d", connectionId);
1012                 requestInfo->callback.OnConnectFailed(requestInfo->requestId, errCode);
1013             }
1014             ListDelete(&requestInfo->node);
1015             SoftBusFree(requestInfo);
1016         }
1017     }
1018 
1019     if (g_connectCallback != NULL) {
1020         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[BleNotifyDisconnect] disconn connectionId=%d", connectionId);
1021         g_connectCallback->OnDisconnected(connectionId, &connectionInfo);
1022     }
1023 }
1024 
BleDisconnectCallback(BleHalConnInfo halConnInfo,int32_t errCode)1025 static void BleDisconnectCallback(BleHalConnInfo halConnInfo, int32_t errCode)
1026 {
1027     ListNode *bleItem = NULL;
1028     ListNode *item = NULL;
1029     ListNode *itemNext = NULL;
1030     uint32_t connectionId = 0;
1031     ListNode notifyList;
1032     ListInit(&notifyList);
1033     ConnectionInfo connectionInfo;
1034     BleConnectionInfo *bleNode = NULL;
1035     if (SoftBusMutexLock(&g_connectionLock) != 0) {
1036         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleDisconnectCallback mutex failed");
1037         return;
1038     }
1039     LIST_FOR_EACH(bleItem, &g_connection_list) {
1040         BleConnectionInfo *itemNode = LIST_ENTRY(bleItem, BleConnectionInfo, node);
1041         if (itemNode->halConnId == halConnInfo.halConnId && itemNode->info.isServer == halConnInfo.isServer) {
1042             bleNode = itemNode;
1043             itemNode->state = BLE_CONNECTION_STATE_CLOSED;
1044             if (memcpy_s(&connectionInfo, sizeof(ConnectionInfo), &(itemNode->info), sizeof(ConnectionInfo)) != EOK) {
1045                 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleDisconnectCallback memcpy_s fail");
1046                 return;
1047             }
1048             connectionId = itemNode->connId;
1049             connectionInfo.isAvailable = 0;
1050             LIST_FOR_EACH_SAFE(item, itemNext, &itemNode->requestList) {
1051                 BleRequestInfo *requestInfo = LIST_ENTRY(item, BleRequestInfo, node);
1052                 ListDelete(&requestInfo->node);
1053                 ListAdd(&notifyList, &requestInfo->node);
1054             }
1055             break;
1056         }
1057     }
1058     ReleaseBleConnectionInfo(bleNode);
1059     if (connectionId != 0) {
1060         BleNotifyDisconnect(&notifyList, connectionId, connectionInfo, errCode);
1061     }
1062     (void)SoftBusMutexUnlock(&g_connectionLock);
1063 }
1064 
GetLocalInfoJson(int32_t roleType)1065 static cJSON *GetLocalInfoJson(int32_t roleType)
1066 {
1067     cJSON *json =  cJSON_CreateObject();
1068     if (json == NULL) {
1069         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "Cannot create cJSON object");
1070         return NULL;
1071     }
1072     char udid[UDID_BUF_LEN] = {0};
1073     if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
1074         cJSON_Delete(json);
1075         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendSelfBasicInfo Get local dev Id failed.");
1076         return NULL;
1077     }
1078     if (!AddStringToJsonObject(json, "devid", udid)) {
1079         cJSON_Delete(json);
1080         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendSelfBasicInfo Cannot add udid to jsonobj");
1081         return NULL;
1082     }
1083     if (!AddNumberToJsonObject(json, "type", roleType)) {
1084         cJSON_Delete(json);
1085         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendSelfBasicInfo Cannot add type to jsonobj");
1086         return NULL;
1087     }
1088     return json;
1089 }
1090 
SendSelfBasicInfo(uint32_t connId,int32_t roleType)1091 static int32_t SendSelfBasicInfo(uint32_t connId, int32_t roleType)
1092 {
1093     cJSON *json =  GetLocalInfoJson(roleType);
1094     if (json == NULL) {
1095         return SOFTBUS_ERR;
1096     }
1097     char *data = cJSON_PrintUnformatted(json);
1098     cJSON_Delete(json);
1099     if (data == NULL) {
1100         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "cJSON_PrintUnformatted failed");
1101         return SOFTBUS_ERR;
1102     }
1103     uint32_t dataLen = strlen(data) + 1 + TYPE_HEADER_SIZE;
1104     int32_t *buf = (int32_t *)SoftBusCalloc(dataLen);
1105     if (buf == NULL) {
1106         cJSON_free(data);
1107         return SOFTBUS_ERR;
1108     }
1109     buf[0] = TYPE_BASIC_INFO;
1110     if (memcpy_s((char*)buf + TYPE_HEADER_SIZE, dataLen - TYPE_HEADER_SIZE, data, strlen(data) + 1)) {
1111         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "memcpy_s data error");
1112         cJSON_free(data);
1113         SoftBusFree(buf);
1114         return SOFTBUS_ERR;
1115     }
1116     cJSON_free(data);
1117     static int i = 0;
1118     ConnPostData postData = {
1119         .module = MODULE_BLE_NET,
1120         .seq = i++,
1121         .flag = 0,
1122         .pid = 0,
1123         .len = dataLen,
1124         .buf = (char*)buf
1125     };
1126     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "SendSelfBasicInfo BlePostBytesInner module:%d", postData.module);
1127     int ret = BlePostBytesInner(connId, &postData);
1128     if (ret != SOFTBUS_OK) {
1129         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendSelfBasicInfo BlePostBytesInner failed");
1130         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_SEND_FAIL);
1131         SoftBusFree(buf);
1132     }
1133     return ret;
1134 }
1135 
PeerBasicInfoParse(BleConnectionInfo * connInfo,const char * value,int32_t len)1136 static int32_t PeerBasicInfoParse(BleConnectionInfo *connInfo, const char *value, int32_t len)
1137 {
1138     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "ConnectId=%d receive basicInfo data", connInfo->connId);
1139     if (len <= TYPE_HEADER_SIZE) {
1140         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "PeerBasicInfoParse invalid data length");
1141         return SOFTBUS_ERR;
1142     }
1143     cJSON *data = cJSON_ParseWithLength(value + TYPE_HEADER_SIZE, len - TYPE_HEADER_SIZE);
1144     if (data == NULL) {
1145         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "PeerBasicInfoParse cJSON_Parse failed");
1146         return SOFTBUS_ERR;
1147     }
1148     if (!GetJsonObjectStringItem(data, "devid", connInfo->peerDevId, UUID_BUF_LEN) ||
1149         !GetJsonObjectNumberItem(data, "type", &connInfo->peerType)) {
1150         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "PeerBasicInfoParse get info failed");
1151         cJSON_Delete(data);
1152         return SOFTBUS_ERR;
1153     }
1154     cJSON_Delete(data);
1155     char udidHash[UDID_HASH_LEN];
1156     if (SoftBusGenerateStrHash((unsigned char *)connInfo->peerDevId, strlen(connInfo->peerDevId),
1157         (unsigned char *)udidHash) != SOFTBUS_OK) {
1158         SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "PeerBasicInfoParse GenerateStrHash failed");
1159         return SOFTBUS_ERR;
1160     }
1161     if (memcpy_s(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN, udidHash, UDID_HASH_LEN) != EOK) {
1162         SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "PeerBasicInfoParse memcpy_s failed");
1163         return SOFTBUS_ERR;
1164     }
1165     return SOFTBUS_OK;
1166 }
1167 
BleOnDataUpdate(BleConnectionInfo * targetNode)1168 static int32_t BleOnDataUpdate(BleConnectionInfo *targetNode)
1169 {
1170     if (targetNode->peerType != BLE_ROLE_CLIENT && targetNode->peerType != BLE_ROLE_SERVER) {
1171         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleOnDataUpdate invalid role type");
1172         return SOFTBUS_ERR;
1173     }
1174     if (targetNode->peerType == BLE_ROLE_SERVER) {
1175         BleClientDoneConnect(targetNode);
1176         return SOFTBUS_OK;
1177     }
1178     if (SendSelfBasicInfo(targetNode->connId, BLE_ROLE_SERVER) != SOFTBUS_OK) {
1179         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SendSelfBasicInfo error");
1180         return SOFTBUS_ERR;
1181     }
1182     g_connectCallback->OnConnected(targetNode->connId, &(targetNode->info));
1183     return SOFTBUS_OK;
1184 }
1185 
BleConnectionReceived(BleHalConnInfo halConnInfo,uint32_t len,const char * value)1186 static void BleConnectionReceived(BleHalConnInfo halConnInfo, uint32_t len, const char *value)
1187 {
1188     uint32_t connPktHeadLen = (uint32_t) sizeof(ConnPktHead);
1189     if (connPktHeadLen >= len) {
1190         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleOnConnectionReceived len error");
1191         return;
1192     }
1193     ConnPktHead *head = (ConnPktHead *)value;
1194     UnpackConnPktHead(head);
1195     if (UINT32_MAX - connPktHeadLen < head->len || head->len + connPktHeadLen > len) {
1196         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BLEINFOPRINT: recv broken data:%d, not support",
1197                    head->len + connPktHeadLen);
1198         return;
1199     }
1200     if (SoftBusMutexLock(&g_connectionLock) != SOFTBUS_OK) {
1201         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
1202         return;
1203     }
1204     BleConnectionInfo *targetNode = GetBleConnInfoByHalConnId(halConnInfo);
1205     if (targetNode == NULL) {
1206         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleOnDataReceived unknown device");
1207         (void)SoftBusMutexUnlock(&g_connectionLock);
1208         return;
1209     }
1210     uint32_t connectionId = targetNode->connId;
1211     (void)SoftBusMutexUnlock(&g_connectionLock);
1212     if (head->module != MODULE_CONNECTION) {
1213         if (g_connectCallback != NULL) {
1214             g_connectCallback->OnDataReceived(connectionId, (ConnModule) head->module, head->seq,
1215                 (char *)value, head->len + connPktHeadLen);
1216         }
1217         return;
1218     }
1219     cJSON *data = cJSON_ParseWithLength(value + connPktHeadLen, head->len);
1220     if (data == NULL) {
1221         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "[receive data invalid]");
1222         return;
1223     }
1224     RecvConnectedComd(connectionId, (const cJSON*)data);
1225     cJSON_Delete(data);
1226 }
BleNetReceived(BleHalConnInfo halConnInfo,uint32_t len,const char * value)1227 static void BleNetReceived(BleHalConnInfo halConnInfo, uint32_t len, const char *value)
1228 {
1229     if (SoftBusMutexLock(&g_connectionLock) != SOFTBUS_OK) {
1230         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
1231         return;
1232     }
1233     BleConnectionInfo *targetNode = GetBleConnInfoByHalConnId(halConnInfo);
1234     if (targetNode == NULL) {
1235         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleOnDataReceived unknown device");
1236         (void)SoftBusMutexUnlock(&g_connectionLock);
1237         return;
1238     }
1239     if (targetNode->state != BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED) {
1240         if (PeerBasicInfoParse(targetNode, value, len) != SOFTBUS_OK) {
1241             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "PeerBasicInfoParse failed");
1242             (void)SoftBusMutexUnlock(&g_connectionLock);
1243             return;
1244         }
1245         SoftbusGattcOnRecvHandShakeRespon(targetNode->halConnId);
1246         targetNode->state = BLE_CONNECTION_STATE_BASIC_INFO_EXCHANGED;
1247         if (BleOnDataUpdate(targetNode) != SOFTBUS_OK) {
1248             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleOnDataUpdate failed");
1249         }
1250         (void)SoftBusMutexUnlock(&g_connectionLock);
1251         return;
1252     }
1253     (void)SoftBusMutexUnlock(&g_connectionLock);
1254     g_connectCallback->OnDataReceived(targetNode->connId, MODULE_BLE_NET, 0, (char *)value, len);
1255 }
1256 
BleOnDataReceived(bool isBleConn,BleHalConnInfo halConnInfo,uint32_t len,const char * value)1257 static void BleOnDataReceived(bool isBleConn, BleHalConnInfo halConnInfo, uint32_t len, const char *value)
1258 {
1259     isBleConn ? BleConnectionReceived(halConnInfo, len, value) : BleNetReceived(halConnInfo, len, value);
1260 }
1261 
SendBleData(SendQueueNode * node)1262 static int32_t SendBleData(SendQueueNode *node)
1263 {
1264     if (node->len > MAX_DATA_LEN) {
1265         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "SendBleData big msg, len:%u\n", node->len);
1266     }
1267 
1268     BleConnectionInfo *connInfo = GetBleConnInfoByConnId(node->connectionId);
1269     if (connInfo == NULL) {
1270         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleMtuChangeCallback GetBleConnInfo failed");
1271         return SOFTBUS_ERR;
1272     }
1273     if (node->isInner) {
1274         return BleTransSend(connInfo, node->data, node->len, node->seq, node->module);
1275     }
1276     ConnPktHead *head = (ConnPktHead *)node->data;
1277     return BleTransSend(connInfo, node->data, node->len, head->seq, head->module);
1278 }
1279 
FreeSendNode(SendQueueNode * node)1280 static void FreeSendNode(SendQueueNode *node)
1281 {
1282     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "FreeSendNode");
1283     if (node == NULL) {
1284         return;
1285     }
1286     if (node->data != NULL) {
1287         SoftBusFree((void *)node->data);
1288     }
1289     SoftBusFree((void *)node);
1290 }
1291 
BleSendTask(void * arg)1292 void *BleSendTask(void *arg)
1293 {
1294 #define WAIT_TIME 10
1295     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "BleSendTask enter");
1296     SendQueueNode *node = NULL;
1297     while (1) {
1298         int32_t ret = BleDequeueBlock((void **)(&node));
1299         if (ret != SOFTBUS_OK) {
1300             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "ble dequeue send node failed, error=%d", ret);
1301             SoftBusSleepMs(WAIT_TIME);
1302             continue;
1303         }
1304         if (SendBleData(node) != SOFTBUS_OK) {
1305             SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "SendItem fail");
1306         }
1307         FreeSendNode(node);
1308         node = NULL;
1309     }
1310 }
1311 
InitBleInterface(void)1312 static void InitBleInterface(void)
1313 {
1314     g_bleInterface.ConnectDevice = BleConnectDevice;
1315     g_bleInterface.PostBytes = BlePostBytes;
1316     g_bleInterface.DisconnectDevice = BleDisconnectDevice;
1317     g_bleInterface.DisconnectDeviceNow = BleDisconnectDeviceNow;
1318     g_bleInterface.GetConnectionInfo = BleGetConnectionInfo;
1319     g_bleInterface.StartLocalListening = BleStartLocalListening;
1320     g_bleInterface.StopLocalListening = BleStopLocalListening;
1321     g_bleInterface.CheckActiveConnection = BleCheckActiveConnection;
1322     g_bleInterface.UpdateConnection = BleUpdateConnection;
1323 }
1324 
BleQueueInit(void)1325 static int BleQueueInit(void)
1326 {
1327     if (BleInnerQueueInit() != SOFTBUS_OK) {
1328         return SOFTBUS_ERR;
1329     }
1330     SoftBusThread tid;
1331     if (SoftBusThreadCreate(&tid, NULL, BleSendTask, NULL) != 0) {
1332         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "create BleSendTask failed");
1333         BleInnerQueueDeinit();
1334         return SOFTBUS_ERR;
1335     }
1336     return SOFTBUS_OK;
1337 }
1338 
BleConnOnBtStateChanged(int listenerId,int state)1339 void BleConnOnBtStateChanged(int listenerId, int state)
1340 {
1341     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[BleOnBtStateChanged] id:%d, state:%d", listenerId, state);
1342     SoftBusGattServerOnBtStateChanged(state);
1343 }
1344 
1345 static SoftBusBtStateListener g_bleConnStateListener = {
1346     .OnBtStateChanged = BleConnOnBtStateChanged,
1347     .OnBtAclStateChanged = NULL,
1348 };
1349 
1350 static SoftBusBleConnCalback g_bleClientConnCalback = {
1351     .BleOnDataReceived = BleOnDataReceived,
1352     .BleDisconnectCallback = BleDisconnectCallback,
1353     .BleConnectCallback = BleClientConnectCallback,
1354     .GetBleConnInfoByHalConnId = GetBleConnInfoByHalConnId,
1355 };
1356 
1357 static SoftBusBleConnCalback g_bleServerConnCalback = {
1358     .BleOnDataReceived = BleOnDataReceived,
1359     .BleDisconnectCallback = BleDisconnectCallback,
1360     .BleConnectCallback = BleServerConnectCallback,
1361     .GetBleConnInfoByHalConnId = GetBleConnInfoByHalConnId,
1362 };
1363 
1364 static SoftBusBleTransCalback g_bleTransCallback = {
1365     .GetBleConnInfoByHalConnId = GetBleConnInfoByHalConnId,
1366 };
1367 
BleConnectionMsgHandler(SoftBusMessage * msg)1368 static void BleConnectionMsgHandler(SoftBusMessage *msg)
1369 {
1370     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, " 11ble gattc conn loop process msg type %d", msg->what);
1371     switch (msg->what) {
1372         case BLE_CONNECTION_DISCONNECT_OUT: {
1373             uint32_t connectionId = (uint32_t)msg->arg1;
1374             BleConnectionInfo *targetNode = NULL;
1375             if (SoftBusMutexLock(&g_connectionLock) != SOFTBUS_OK) {
1376                 SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
1377                 return;
1378             }
1379             ListNode *item = NULL;
1380             LIST_FOR_EACH(item, &g_connection_list) {
1381                 BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
1382                 if (itemNode->connId == connectionId) {
1383                     targetNode = itemNode;
1384                     break;
1385                 }
1386             }
1387             if (targetNode == NULL) {
1388                 (void)SoftBusMutexUnlock(&g_connectionLock);
1389                 return;
1390             }
1391             AbortConnection(targetNode->btBinaryAddr, targetNode->halConnId, targetNode->info.isServer);
1392             (void)SoftBusMutexUnlock(&g_connectionLock);
1393             break;
1394         }
1395         default:
1396             break;
1397     }
1398 }
1399 
BleConnectionRemoveMessageFunc(const SoftBusMessage * msg,void * args)1400 static int32_t BleConnectionRemoveMessageFunc(const SoftBusMessage *msg, void *args)
1401 {
1402     uint64_t clientId = (uint64_t)(uintptr_t)args;
1403     if ((msg->what == BLE_CONNECTION_DISCONNECT_OUT) && (msg->arg1 == clientId)) {
1404         return SOFTBUS_OK;
1405     }
1406     return SOFTBUS_ERR;
1407 }
1408 
BleConnLooperInit(void)1409 static int BleConnLooperInit(void)
1410 {
1411     g_bleConnectAsyncHandler.name = (char *)"ble_conn_handler";
1412     g_bleConnectAsyncHandler.HandleMessage = BleConnectionMsgHandler;
1413     g_bleConnectAsyncHandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
1414     if (g_bleConnectAsyncHandler.looper == NULL ||
1415         g_bleConnectAsyncHandler.looper->PostMessage == NULL ||
1416         g_bleConnectAsyncHandler.looper->PostMessageDelay == NULL ||
1417         g_bleConnectAsyncHandler.looper->RemoveMessageCustom == NULL) {
1418         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "create looper failed");
1419         return SOFTBUS_ERR;
1420     }
1421     return SOFTBUS_OK;
1422 }
1423 
ConnInitBle(const ConnectCallback * callback)1424 ConnectFuncInterface *ConnInitBle(const ConnectCallback *callback)
1425 {
1426     SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_INFO, "[InitBle]");
1427     int32_t ret;
1428     ret = BleConnLooperInit();
1429     if (ret != SOFTBUS_OK) {
1430         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleConnLooperInit failed: %d", ret);
1431         return NULL;
1432     }
1433     ret = SoftBusGattServerInit(&g_bleServerConnCalback);
1434     if (ret != SOFTBUS_OK) {
1435         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_GATTSERVER_INIT_FAIL);
1436         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SoftBusGattServerInit failed: %d", ret);
1437         return NULL;
1438     }
1439     ret = SoftBusGattClientInit(&g_bleClientConnCalback);
1440     if (ret != SOFTBUS_OK) {
1441         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_GATTCLIENT_INIT_FAIL);
1442         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SoftBusGattClientInit failed: %d", ret);
1443         return NULL;
1444     }
1445     ret = BleTransInit(&g_bleTransCallback);
1446     if (ret != SOFTBUS_OK) {
1447         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_TRANS_INIT_FAIL);
1448         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleTransInit failed: %d", ret);
1449         return NULL;
1450     }
1451     SoftBusMutexAttr attr;
1452     attr.type = SOFTBUS_MUTEX_RECURSIVE;
1453     SoftBusMutexInit(&g_connectionLock, &attr);
1454     ret = BleQueueInit();
1455     if (ret != SOFTBUS_OK) {
1456         SoftBusReportConnFaultEvt(SOFTBUS_HISYSEVT_CONN_MEDIUM_BLE, SOFTBUS_HISYSEVT_BLE_QUEUE_INIT_FAIL);
1457         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "BleQueueInit failed: %d", ret);
1458         return NULL;
1459     }
1460     ret = SoftBusAddBtStateListener(&g_bleConnStateListener);
1461     if (ret < 0) {
1462         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "SoftBusAddBtStateListener failed: %d", ret);
1463         return NULL;
1464     }
1465     g_connectCallback = (ConnectCallback*)callback;
1466     InitBleInterface();
1467     SoftBusRegConnVarDump(BLE_CONNECTION_INFO, &BleConnectionDump);
1468     return &g_bleInterface;
1469 }
1470 
BleConnectionDump(int fd)1471 static int32_t BleConnectionDump(int fd)
1472 {
1473     char addr[BT_ADDR_LEN] = {0};
1474     char bleMac[BT_MAC_LEN] = {0};
1475     char deviceIdHash[UDID_HASH_LEN] = {0};
1476     char peerDevId[UDID_BUF_LEN] = {0};
1477     if (SoftBusMutexLock(&g_connectionLock) != SOFTBUS_OK) {
1478         SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "lock mutex failed");
1479         return SOFTBUS_LOCK_ERR;
1480     }
1481     ListNode *item = NULL;
1482     SOFTBUS_DPRINTF(fd, "\n-----------------BLEConnectList Info-------------------\n");
1483     LIST_FOR_EACH(item, &g_connection_list) {
1484         BleConnectionInfo *itemNode = LIST_ENTRY(item, BleConnectionInfo, node);
1485         SOFTBUS_DPRINTF(fd, "halConnId                     : %d\n", itemNode->halConnId);
1486         SOFTBUS_DPRINTF(fd, "connId                        : %d\n", itemNode->connId);
1487         DataMasking((char *)(itemNode->btBinaryAddr.addr), BT_ADDR_LEN, MAC_DELIMITER, addr);
1488         SOFTBUS_DPRINTF(fd, "btMac                         : %s\n", addr);
1489         SOFTBUS_DPRINTF(fd, "Connection Info isAvailable   : %d\n", itemNode->info.isAvailable);
1490         SOFTBUS_DPRINTF(fd, "Connection Info isServer      : %d\n", itemNode->info.isServer);
1491         SOFTBUS_DPRINTF(fd, "Connection Info type          : %u\n", itemNode->info.type);
1492         DataMasking(itemNode->info.bleInfo.bleMac, BT_MAC_LEN, MAC_DELIMITER, bleMac);
1493         SOFTBUS_DPRINTF(fd, "BleInfo addr                  : %s\n", bleMac);
1494         DataMasking(itemNode->info.bleInfo.deviceIdHash, UDID_HASH_LEN, ID_DELIMITER, deviceIdHash);
1495         SOFTBUS_DPRINTF(fd, "BleInfo deviceIdHash          : %s\n", deviceIdHash);
1496         SOFTBUS_DPRINTF(fd, "Connection state              : %d\n", itemNode->state);
1497         SOFTBUS_DPRINTF(fd, "Connection refCount           : %d\n", itemNode->refCount);
1498         SOFTBUS_DPRINTF(fd, "Connection mtu                : %d\n", itemNode->mtu);
1499         SOFTBUS_DPRINTF(fd, "Connection peerType           : %d\n", itemNode->peerType);
1500         DataMasking(itemNode->peerDevId, UDID_BUF_LEN, ID_DELIMITER, peerDevId);
1501         SOFTBUS_DPRINTF(fd, "Connection peerDevId          : %s\n", peerDevId);
1502         LIST_FOR_EACH(item, &itemNode->requestList) {
1503             BleRequestInfo *requestNode = LIST_ENTRY(item, BleRequestInfo, node);
1504             SOFTBUS_DPRINTF(fd, "request isUsed                : %u\n", requestNode->requestId);
1505         }
1506         for (int i = 0; i < MAX_CACHE_NUM_PER_CONN; i++) {
1507             SOFTBUS_DPRINTF(fd, "recvCache isUsed              : %d\n", itemNode->recvCache[i].isUsed);
1508             SOFTBUS_DPRINTF(fd, "recvCache timeStamp           : %d\n", itemNode->recvCache[i].timeStamp);
1509             SOFTBUS_DPRINTF(fd, "recvCache seq                 : %d\n", itemNode->recvCache[i].seq);
1510             SOFTBUS_DPRINTF(fd, "recvCache currentSize         : %d\n", itemNode->recvCache[i].currentSize);
1511             SOFTBUS_DPRINTF(fd, "recvCache cache               : %s\n", itemNode->recvCache[i].cache);
1512         }
1513     }
1514     (void)SoftBusMutexUnlock(&g_connectionLock);
1515     return SOFTBUS_OK;
1516 }
1517