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