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