1 /*
2 * Copyright (c) 2022 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
16 #include <securec.h>
17 #include <string.h>
18
19 #include "anonymizer.h"
20 #include "bus_center_event.h"
21 #include "bus_center_manager.h"
22 #include "g_enhance_lnn_func_pack.h"
23 #include "lnn_log.h"
24 #include "lnn_net_builder.h"
25 #include "lnn_network_manager.h"
26 #include "lnn_node_info_struct.h"
27 #include "lnn_physical_subnet_manager.h"
28 #include "softbus_adapter_bt_common.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_adapter_timer.h"
31 #include "softbus_error_code.h"
32 #include "softbus_utils.h"
33
34 #define LNN_BT_PROTOCOL_PRI 10
35 #define TIME_FACTOR (1000LL)
36
37 typedef enum {
38 BT_SUBNET_MANAGER_EVENT_IF_READY, // bluetooth on
39 BT_SUBNET_MANAGER_EVENT_IF_DOWN, // bluetooth off
40 BT_SUBNET_MANAGER_EVENT_MAX
41 } BtSubnetManagerEvent;
42
43 typedef enum {
44 BT_EVENT_RESULT_ACCEPTED = 0,
45 BT_EVENT_RESULT_REJECTED,
46 BT_EVENT_RESULT_OPTION_COUNT
47 } BtSubnetManagerEventResultOptions;
48
TransactBtSubnetState(LnnPhysicalSubnet * subnet,BtSubnetManagerEvent event,bool isAccepted)49 static void TransactBtSubnetState(LnnPhysicalSubnet *subnet, BtSubnetManagerEvent event, bool isAccepted)
50 {
51 LnnPhysicalSubnetStatus lastStatus = subnet->status;
52 LnnPhysicalSubnetStatus transactMap[][BT_EVENT_RESULT_OPTION_COUNT] = {
53 [BT_SUBNET_MANAGER_EVENT_IF_READY] = {LNN_SUBNET_RUNNING, LNN_SUBNET_IDLE},
54 [BT_SUBNET_MANAGER_EVENT_IF_DOWN] = {LNN_SUBNET_SHUTDOWN, subnet->status},
55 };
56 if (event == BT_SUBNET_MANAGER_EVENT_MAX) {
57 LNN_LOGE(LNN_BUILDER, "event error");
58 return;
59 }
60 subnet->status = transactMap[event][isAccepted ? BT_EVENT_RESULT_ACCEPTED : BT_EVENT_RESULT_REJECTED];
61 LNN_LOGD(LNN_BUILDER,
62 "subnet ifName status trans. ifName=%{public}s, status:%{public}d->%{public}d", subnet->ifName,
63 lastStatus, subnet->status);
64 }
65
GetAvailableBtMac(char * macStr,uint32_t len)66 static int32_t GetAvailableBtMac(char *macStr, uint32_t len)
67 {
68 int32_t ret;
69 SoftBusBtAddr mac = {0};
70
71 if (len != BT_MAC_LEN) {
72 return SOFTBUS_INVALID_PARAM;
73 }
74 ret = SoftBusGetBtMacAddr(&mac);
75 if (ret != SOFTBUS_OK) {
76 LNN_LOGE(LNN_BUILDER, "get bt mac addr fail");
77 return ret;
78 }
79 ret = ConvertBtMacToStr(macStr, len, mac.addr, sizeof(mac.addr));
80 if (ret != SOFTBUS_OK) {
81 LNN_LOGE(LNN_BUILDER, "convert bt mac to str fail");
82 return ret;
83 }
84 LnnSetLocalByteInfo(BYTE_KEY_PUB_MAC, mac.addr, sizeof(mac.addr));
85 return SOFTBUS_OK;
86 }
87
EnableBtSubnet(LnnPhysicalSubnet * subnet)88 static int32_t EnableBtSubnet(LnnPhysicalSubnet *subnet)
89 {
90 char macStr[BT_MAC_LEN] = {0};
91
92 if (subnet->status == LNN_SUBNET_RUNNING) {
93 LNN_LOGI(LNN_BUILDER, "bt running return ok");
94 return SOFTBUS_OK;
95 }
96 int32_t ret = GetAvailableBtMac(macStr, sizeof(macStr));
97 if (ret != SOFTBUS_OK) {
98 LNN_LOGE(LNN_BUILDER, "get available bt mac fail");
99 return ret;
100 }
101 char *anonyMac = NULL;
102 Anonymize(macStr, &anonyMac);
103 LNN_LOGI(LNN_BUILDER, "btmac=%{public}s", AnonymizeWrapper(anonyMac));
104 AnonymizeFree(anonyMac);
105 return LnnSetLocalStrInfo(STRING_KEY_BT_MAC, macStr);
106 }
107
DisableBrSubnet(LnnPhysicalSubnet * subnet)108 static int32_t DisableBrSubnet(LnnPhysicalSubnet *subnet)
109 {
110 bool addrType[CONNECTION_ADDR_MAX] = {
111 [CONNECTION_ADDR_BR] = true,
112 };
113
114 if (subnet->status != LNN_SUBNET_RUNNING) {
115 return SOFTBUS_NETWORK_SUBNET_STATUS_ERR;
116 }
117 LNN_LOGI(LNN_BUILDER, "br subnet is disable, start leave br network");
118 int32_t ret = LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX);
119 if (ret != SOFTBUS_OK) {
120 LNN_LOGE(LNN_BUILDER, "leave br network fail, ret=%{public}d", ret);
121 return ret;
122 }
123 return SOFTBUS_OK;
124 }
125
DisableBleSubnet(LnnPhysicalSubnet * subnet)126 static int32_t DisableBleSubnet(LnnPhysicalSubnet *subnet)
127 {
128 int32_t ret;
129 bool addrType[CONNECTION_ADDR_MAX] = {
130 [CONNECTION_ADDR_BLE] = true,
131 };
132
133 if (subnet->status != LNN_SUBNET_RUNNING) {
134 return SOFTBUS_NETWORK_SUBNET_STATUS_ERR;
135 }
136 LNN_LOGI(LNN_BUILDER, "ble subnet is disable, start leave ble network");
137 ret = LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX);
138 if (ret != SOFTBUS_OK) {
139 LNN_LOGE(LNN_BUILDER, "leave ble network fail, ret=%{public}d", ret);
140 return ret;
141 }
142 CheckNeedCloudSyncOfflinePacked(DISCOVERY_TYPE_BLE);
143 return SOFTBUS_OK;
144 }
145
DestroyBtSubnetManager(LnnPhysicalSubnet * subnet)146 static void DestroyBtSubnetManager(LnnPhysicalSubnet *subnet)
147 {
148 int32_t ret;
149 LnnNetIfType type;
150
151 LnnGetNetIfTypeByName(subnet->ifName, &type);
152 if (subnet->status == LNN_SUBNET_RUNNING) {
153 ret = (type == LNN_NETIF_TYPE_BR) ? DisableBrSubnet(subnet) : DisableBleSubnet(subnet);
154 TransactBtSubnetState(subnet, BT_SUBNET_MANAGER_EVENT_IF_DOWN, (ret == SOFTBUS_OK));
155 }
156 SoftBusFree(subnet);
157 }
158
GetBtRegistEvent(void)159 static BtSubnetManagerEvent GetBtRegistEvent(void)
160 {
161 char macStr[BT_MAC_LEN] = {0};
162
163 if (!SoftBusGetBtState()) {
164 LNN_LOGD(LNN_BUILDER, "bluetooth is not enabled yet");
165 return BT_SUBNET_MANAGER_EVENT_IF_DOWN;
166 }
167 return GetAvailableBtMac(macStr, sizeof(macStr)) == SOFTBUS_OK ?
168 BT_SUBNET_MANAGER_EVENT_IF_READY : BT_SUBNET_MANAGER_EVENT_IF_DOWN;
169 }
170
GetBtStatusChangedEvent(SoftBusBtState btState)171 static BtSubnetManagerEvent GetBtStatusChangedEvent(SoftBusBtState btState)
172 {
173 if (btState == SOFTBUS_BR_TURN_ON || btState == SOFTBUS_BLE_TURN_ON) {
174 return BT_SUBNET_MANAGER_EVENT_IF_READY;
175 }
176 if (btState == SOFTBUS_BR_TURN_OFF || btState == SOFTBUS_BLE_TURN_OFF) {
177 return BT_SUBNET_MANAGER_EVENT_IF_DOWN;
178 }
179 return BT_SUBNET_MANAGER_EVENT_MAX;
180 }
181
OnBtNetifStatusChanged(LnnPhysicalSubnet * subnet,void * status)182 static void OnBtNetifStatusChanged(LnnPhysicalSubnet *subnet, void *status)
183 {
184 BtSubnetManagerEvent event = BT_SUBNET_MANAGER_EVENT_MAX;
185
186 if (status == NULL) {
187 event = GetBtRegistEvent();
188 /* Only used for initialization process to obtain bt subnet status */
189 if (event != BT_SUBNET_MANAGER_EVENT_IF_READY) {
190 return;
191 }
192 } else {
193 SoftBusBtState btState = (SoftBusBtState)(*(uint8_t *)status);
194 event = GetBtStatusChangedEvent(btState);
195 }
196
197 int32_t ret = SOFTBUS_NETWORK_NETIF_STATUS_CHANGED;
198 LnnNetIfType type;
199 LnnGetNetIfTypeByName(subnet->ifName, &type);
200 switch (event) {
201 case BT_SUBNET_MANAGER_EVENT_IF_READY:
202 if (type == LNN_NETIF_TYPE_BR || type == LNN_NETIF_TYPE_BLE) {
203 ret = EnableBtSubnet(subnet);
204 }
205 break;
206 case BT_SUBNET_MANAGER_EVENT_IF_DOWN:
207 if (type == LNN_NETIF_TYPE_BR) {
208 ret = DisableBrSubnet(subnet);
209 }
210 if (type == LNN_NETIF_TYPE_BLE) {
211 ret = DisableBleSubnet(subnet);
212 }
213 break;
214 default:
215 LNN_LOGW(LNN_BUILDER, "discard unexpected event. event=%{public}d", event);
216 return;
217 }
218 TransactBtSubnetState(subnet, event, (ret == SOFTBUS_OK));
219 }
220
CreateBtSubnetManager(struct LnnProtocolManager * self,const char * ifName)221 static LnnPhysicalSubnet *CreateBtSubnetManager(struct LnnProtocolManager *self, const char *ifName)
222 {
223 LnnNetIfType type;
224 LnnGetNetIfTypeByName(ifName, &type);
225 LnnPhysicalSubnet *subnet = (LnnPhysicalSubnet *)SoftBusCalloc(sizeof(LnnPhysicalSubnet));
226 if (subnet == NULL) {
227 LNN_LOGE(LNN_BUILDER, "calloc bt subnet fail");
228 return NULL;
229 }
230
231 do {
232 subnet->destroy = DestroyBtSubnetManager;
233 subnet->protocol = self;
234 subnet->status = LNN_SUBNET_IDLE;
235 subnet->onNetifStatusChanged = OnBtNetifStatusChanged;
236 subnet->onSoftbusNetworkDisconnected = NULL;
237
238 int32_t ret = strcpy_s(subnet->ifName, sizeof(subnet->ifName), ifName);
239 if (ret != EOK) {
240 LNN_LOGE(LNN_BUILDER, "copy ifName failed! ret=%{public}d", ret);
241 break;
242 }
243 return subnet;
244 } while (false);
245
246 subnet->destroy(subnet);
247 return NULL;
248 }
249
NotifyBtStatusChanged(const LnnNetIfMgr * netifManager,void * data)250 static VisitNextChoice NotifyBtStatusChanged(const LnnNetIfMgr *netifManager, void *data)
251 {
252 SoftBusBtState btState = (SoftBusBtState)(*(uint8_t *)data);
253 if (netifManager->type == LNN_NETIF_TYPE_BR &&
254 (btState == SOFTBUS_BR_TURN_ON || btState == SOFTBUS_BR_TURN_OFF)) {
255 LnnNotifyPhysicalSubnetStatusChanged(netifManager->ifName, LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE, data);
256 }
257 if (netifManager->type == LNN_NETIF_TYPE_BLE &&
258 (btState == SOFTBUS_BLE_TURN_ON || btState == SOFTBUS_BLE_TURN_OFF)) {
259 LnnNotifyPhysicalSubnetStatusChanged(netifManager->ifName, LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE, data);
260 }
261 return CHOICE_VISIT_NEXT;
262 }
263
BtNetworkInfoUpdate(SoftBusBtState btState)264 static void BtNetworkInfoUpdate(SoftBusBtState btState)
265 {
266 if (btState == SOFTBUS_BLE_TURN_ON) {
267 LnnSetLocalNum64Info(NUM_KEY_BLE_START_TIME, 0);
268 }
269 if (btState == SOFTBUS_BLE_TURN_OFF) {
270 LnnSetLocalNum64Info(NUM_KEY_BLE_START_TIME, 0);
271 }
272 }
273
BtStateChangedEvtHandler(const LnnEventBasicInfo * info)274 static void BtStateChangedEvtHandler(const LnnEventBasicInfo *info)
275 {
276 if (info == NULL || info->event != LNN_EVENT_BT_STATE_CHANGED) {
277 LNN_LOGE(LNN_BUILDER, "not interest event");
278 return;
279 }
280
281 LnnMonitorHbStateChangedEvent *event = (LnnMonitorHbStateChangedEvent *)info;
282 (void)LnnVisitNetif(NotifyBtStatusChanged, (void *)&event->status);
283 BtNetworkInfoUpdate((SoftBusBtState)event->status);
284 }
285
LeaveSpecificBrNetwork(const char * btMac)286 static void LeaveSpecificBrNetwork(const char *btMac)
287 {
288 char networkId[NETWORK_ID_BUF_LEN] = {0};
289 if (LnnGetNetworkIdByBtMac(btMac, networkId, sizeof(networkId)) != SOFTBUS_OK) {
290 LNN_LOGW(LNN_BUILDER, "networkId not found by btMac");
291 return;
292 }
293 char *anonyNetworkId = NULL;
294 Anonymize(networkId, &anonyNetworkId);
295 LNN_LOGI(LNN_BUILDER, "start leave specific br networkId=%{public}s", AnonymizeWrapper(anonyNetworkId));
296 AnonymizeFree(anonyNetworkId);
297 int32_t ret = LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_BR);
298 if (ret != SOFTBUS_OK) {
299 LNN_LOGE(LNN_BUILDER, "leave br network fail=%{public}d", ret);
300 }
301 }
302
BtAclStateChangedEvtHandler(const LnnEventBasicInfo * info)303 static void BtAclStateChangedEvtHandler(const LnnEventBasicInfo *info)
304 {
305 if (info == NULL || info->event != LNN_EVENT_BT_ACL_STATE_CHANGED) {
306 LNN_LOGE(LNN_BUILDER, "bt acl state event handler get invalid param");
307 return;
308 }
309
310 const LnnMonitorBtAclStateChangedEvent *event = (const LnnMonitorBtAclStateChangedEvent *)info;
311 LNN_LOGI(LNN_BUILDER, "BtAclStateChange=%{public}d", event->status);
312 switch (event->status) {
313 case SOFTBUS_BR_ACL_CONNECTED:
314 /* do nothing */
315 break;
316 case SOFTBUS_BR_ACL_DISCONNECTED:
317 LeaveSpecificBrNetwork(event->btMac);
318 break;
319 default:
320 break;
321 }
322 }
323
LnnInitBtProtocol(struct LnnProtocolManager * self)324 int32_t LnnInitBtProtocol(struct LnnProtocolManager *self)
325 {
326 (void)self;
327 if (LnnRegisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, BtStateChangedEvtHandler) != SOFTBUS_OK) {
328 LNN_LOGE(LNN_INIT, "register bt state change event handler failed");
329 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
330 }
331 if (LnnRegisterEventHandler(LNN_EVENT_BT_ACL_STATE_CHANGED, BtAclStateChangedEvtHandler) != SOFTBUS_OK) {
332 LNN_LOGE(LNN_INIT, "register bt acl state change event handler failed");
333 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
334 }
335 return SOFTBUS_OK;
336 }
337
LnnEnableBtProtocol(struct LnnProtocolManager * self,LnnNetIfMgr * netifMgr)338 int32_t LnnEnableBtProtocol(struct LnnProtocolManager *self, LnnNetIfMgr *netifMgr)
339 {
340 (void)self;
341
342 if (netifMgr == NULL) {
343 LNN_LOGE(LNN_BUILDER, "netifMgr is nullptr");
344 return SOFTBUS_INVALID_PARAM;
345 }
346 LnnPhysicalSubnet *manager = CreateBtSubnetManager(self, netifMgr->ifName);
347 if (manager == NULL) {
348 LNN_LOGE(LNN_BUILDER, "create bt subnet mgr fail");
349 return SOFTBUS_NETWORK_CREATE_SUBNET_MANAGER_FAILED;
350 }
351
352 int ret = LnnRegistPhysicalSubnet(manager);
353 if (ret != SOFTBUS_OK) {
354 LNN_LOGE(LNN_BUILDER, "regist subnet manager failed! ret=%{public}d", ret);
355 manager->destroy(manager);
356 return ret;
357 }
358 return SOFTBUS_OK;
359 }
360
LnnGetBtListenerModule(ListenerMode mode)361 static ListenerModule LnnGetBtListenerModule(ListenerMode mode)
362 {
363 return UNUSE_BUTT;
364 }
365
LnnDeinitBtNetwork(struct LnnProtocolManager * self)366 void LnnDeinitBtNetwork(struct LnnProtocolManager *self)
367 {
368 (void)self;
369 LnnUnregisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, BtStateChangedEvtHandler);
370 LnnUnregisterEventHandler(LNN_EVENT_BT_ACL_STATE_CHANGED, BtAclStateChangedEvtHandler);
371 LnnUnregistPhysicalSubnetByType(LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE);
372 LNN_LOGW(LNN_INIT, "bt network deinited");
373 }
374
375 static LnnProtocolManager g_btProtocol = {
376 .init = LnnInitBtProtocol,
377 .deinit = LnnDeinitBtNetwork,
378 .enable = LnnEnableBtProtocol,
379 .disable = NULL,
380 .getListenerModule = LnnGetBtListenerModule,
381 .id = LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE,
382 .supportedNetif = LNN_NETIF_TYPE_BR | LNN_NETIF_TYPE_BLE,
383 .pri = LNN_BT_PROTOCOL_PRI,
384 };
385
RegistBtProtocolManager(void)386 int32_t RegistBtProtocolManager(void)
387 {
388 return LnnRegistProtocol(&g_btProtocol);
389 }