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
16 #include "lnn_network_manager.h"
17
18 #include <securec.h>
19
20 #include "auth_interface.h"
21 #include "bus_center_manager.h"
22 #include "disc_interface.h"
23 #include "lnn_discovery_manager.h"
24 #include "lnn_heartbeat_ctrl.h"
25 #include "lnn_ohos_account.h"
26 #include "lnn_physical_subnet_manager.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_errcode.h"
29 #include "softbus_feature_config.h"
30 #include "softbus_log.h"
31
32 #define LNN_MAX_IF_NAME_LEN 256
33 #define LNN_DELIMITER_OUTSIDE ","
34 #define LNN_DELIMITER_INSIDE ":"
35
36 #define LNN_DEFAULT_IF_NAME_WLAN "wlan0"
37 #define LNN_DEFAULT_IF_NAME_ETH "eth0"
38 #define LNN_DEFAULT_IF_NAME_BR "br0"
39 #define LNN_DEFAULT_IF_NAME_BLE "ble0"
40
41 typedef enum {
42 LNN_ETH_TYPE = 0,
43 LNN_WLAN_TYPE,
44 LNN_BR_TYPE,
45 LNN_BLE_TYPE,
46 LNN_MAX_NUM_TYPE,
47 } LnnNetIfNameType;
48
49 static ListNode g_netIfNameList = {
50 .prev = &g_netIfNameList,
51 .next = &g_netIfNameList,
52 };
53
54 int32_t RegistIPProtocolManager(void);
55 int32_t RegistNewIPProtocolManager(void);
56
RegistNewIPProtocolManager(void)57 int32_t __attribute__((weak)) RegistNewIPProtocolManager(void)
58 {
59 return SOFTBUS_OK;
60 }
61
RegistBtProtocolManager(void)62 int32_t __attribute__ ((weak)) RegistBtProtocolManager(void)
63 {
64 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "regist virtual bt protocol manager");
65 return SOFTBUS_OK;
66 }
67
68 static LnnNetIfManagerBuilder g_netifBuilders[LNN_MAX_NUM_TYPE] = {0};
69
70 static LnnProtocolManager *g_networkProtocols[LNN_NETWORK_MAX_PROTOCOL_COUNT] = {0};
71
CreateNetifMgr(const char * netIfName)72 static LnnNetIfMgr *CreateNetifMgr(const char *netIfName)
73 {
74 if (netIfName == NULL) {
75 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters invalid!");
76 return NULL;
77 }
78 LnnNetIfMgr *netIfMgr = (LnnNetIfMgr *)SoftBusCalloc(sizeof(LnnNetIfMgr));
79 if (netIfMgr == NULL) {
80 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail: malloc LnnNetIfMgr");
81 return NULL;
82 }
83 do {
84 ListInit(&netIfMgr->node);
85 if (strncpy_s(netIfMgr->ifName, NET_IF_NAME_LEN, netIfName, strlen(netIfName)) != EOK) {
86 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy netIfName fail");
87 break;
88 }
89 return netIfMgr;
90 } while (false);
91
92 SoftBusFree(netIfMgr);
93 return NULL;
94 }
95
RegistNetIfMgr(LnnNetIfNameType type,LnnNetIfManagerBuilder builder)96 static int32_t RegistNetIfMgr(LnnNetIfNameType type, LnnNetIfManagerBuilder builder)
97 {
98 if (type >= LNN_MAX_NUM_TYPE) {
99 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:type too big!", __func__);
100 return SOFTBUS_ERR;
101 }
102
103 if (g_netifBuilders[type] != NULL && g_netifBuilders[type] != builder) {
104 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:type already registed!", __func__);
105 return SOFTBUS_ERR;
106 }
107 g_netifBuilders[type] = builder;
108 return SOFTBUS_OK;
109 }
110
ConvertToNetIfType(LnnNetIfNameType nameType)111 static LnnNetIfType ConvertToNetIfType(LnnNetIfNameType nameType)
112 {
113 return nameType >= LNN_MAX_NUM_TYPE ? 0 : (0x1 << nameType);
114 }
115
NetifMgrFactory(LnnNetIfNameType type,const char * ifName)116 static LnnNetIfMgr *NetifMgrFactory(LnnNetIfNameType type, const char *ifName)
117 {
118 if (type >= LNN_MAX_NUM_TYPE) {
119 return NULL;
120 }
121 if (g_netifBuilders[type] == NULL) {
122 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "netif type %d not supportted!", type);
123 return NULL;
124 }
125 LnnNetIfMgr *netifMgr = g_netifBuilders[type](ifName);
126 if (netifMgr != NULL) {
127 netifMgr->type = ConvertToNetIfType(type);
128 }
129 return netifMgr;
130 }
131
ParseIfNameConfig(char * buf,uint32_t bufLen)132 static int32_t ParseIfNameConfig(char *buf, uint32_t bufLen)
133 {
134 char *outerPtr = NULL;
135 char *innerPtr = NULL;
136 char *value1 = NULL;
137 char *value2 = NULL;
138 if (buf == NULL || bufLen == 0) {
139 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters invaild!");
140 return SOFTBUS_ERR;
141 }
142 char *key = strtok_r(buf, LNN_DELIMITER_OUTSIDE, &outerPtr);
143 while (key != NULL) {
144 value1 = strtok_r(key, LNN_DELIMITER_INSIDE, &innerPtr);
145 value2 = strtok_r(NULL, LNN_DELIMITER_INSIDE, &innerPtr);
146
147 LnnNetIfMgr *netIfMgr = NetifMgrFactory((LnnNetIfNameType)atoi(value1), value2);
148 if (netIfMgr != NULL) {
149 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "Create netif mgr [%s],[%s]", value1, value2);
150 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
151 } else {
152 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Create netif mgr failed!,[%s],[%s]", value1, value2);
153 }
154 key = strtok_r(NULL, LNN_DELIMITER_OUTSIDE, &outerPtr);
155 }
156 return SOFTBUS_OK;
157 }
158
SetIfNameDefaultVal(void)159 static int32_t SetIfNameDefaultVal(void)
160 {
161 LnnNetIfMgr *netIfMgr = NetifMgrFactory(LNN_ETH_TYPE, LNN_DEFAULT_IF_NAME_ETH);
162 if (netIfMgr == NULL) {
163 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add default ETH port failed!");
164 return SOFTBUS_ERR;
165 }
166 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
167
168 netIfMgr = NetifMgrFactory(LNN_WLAN_TYPE, LNN_DEFAULT_IF_NAME_WLAN);
169 if (netIfMgr == NULL) {
170 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add default ETH port failed!");
171 return SOFTBUS_ERR;
172 }
173 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
174
175 netIfMgr = NetifMgrFactory(LNN_BR_TYPE, LNN_DEFAULT_IF_NAME_BR);
176 if (netIfMgr == NULL) {
177 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add default BR netIfMgr failed!");
178 return SOFTBUS_ERR;
179 }
180 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
181
182 netIfMgr = NetifMgrFactory(LNN_BLE_TYPE, LNN_DEFAULT_IF_NAME_BLE);
183 if (netIfMgr == NULL) {
184 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add default BLE netIfMgr failed!");
185 return SOFTBUS_ERR;
186 }
187 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
188 return SOFTBUS_OK;
189 }
190
LnnInitManagerByConfig(void)191 static int32_t LnnInitManagerByConfig(void)
192 {
193 char netIfName[LNN_MAX_IF_NAME_LEN] = {0};
194 if (SoftbusGetConfig(SOFTBUS_STR_LNN_NET_IF_NAME, (unsigned char *)netIfName, sizeof(netIfName)) != SOFTBUS_OK) {
195 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get lnn net ifName fail, use default value");
196 if (SetIfNameDefaultVal() != SOFTBUS_OK) {
197 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "default value set fail");
198 return SOFTBUS_ERR;
199 }
200 return SOFTBUS_OK;
201 }
202 if (ParseIfNameConfig(netIfName, strlen(netIfName)) != SOFTBUS_OK) {
203 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ifName str parse fail!");
204 return SOFTBUS_ERR;
205 }
206 return SOFTBUS_OK;
207 }
208
LnnClearNetConfigList(void)209 int32_t LnnClearNetConfigList(void)
210 {
211 LnnNetIfMgr *item = NULL;
212 LnnNetIfMgr *next = NULL;
213
214 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netIfNameList, LnnNetIfMgr, node)
215 {
216 ListDelete(&item->node);
217 SoftBusFree(item);
218 }
219 return SOFTBUS_OK;
220 }
221
LnnRegistProtocol(LnnProtocolManager * protocolMgr)222 int32_t LnnRegistProtocol(LnnProtocolManager *protocolMgr)
223 {
224 int32_t ret = SOFTBUS_OK;
225
226 if (protocolMgr == NULL || protocolMgr->GetListenerModule == NULL || protocolMgr->Init == NULL ||
227 protocolMgr->Enable == NULL) {
228 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:bad input protocol!", __func__);
229 return SOFTBUS_ERR;
230 }
231
232 for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
233 if (g_networkProtocols[i] != NULL) {
234 continue;
235 }
236 if (protocolMgr->Init != NULL) {
237 ret = protocolMgr->Init(protocolMgr);
238 if (ret != SOFTBUS_OK) {
239 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init network protocol failed! ret=%d", ret);
240 break;
241 }
242 } else {
243 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "network protocol (supportedNetif=%u) have no init",
244 protocolMgr->supportedNetif);
245 }
246 g_networkProtocols[i] = protocolMgr;
247 break;
248 }
249 return ret;
250 }
251
UnregistProtocol(LnnProtocolManager * protocolMgr)252 int32_t UnregistProtocol(LnnProtocolManager *protocolMgr)
253 {
254 uint8_t i;
255 if (protocolMgr == NULL) {
256 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:null ptr!", __func__);
257 return SOFTBUS_ERR;
258 }
259
260 for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
261 if (g_networkProtocols[i] == protocolMgr) {
262 g_networkProtocols[i] = NULL;
263 if (protocolMgr->Deinit != NULL) {
264 protocolMgr->Deinit(protocolMgr);
265 }
266 return SOFTBUS_OK;
267 }
268 }
269 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:no such protocol!", __func__);
270 return SOFTBUS_ERR;
271 }
272
LnnVisitNetif(VisitNetifCallback callback,void * data)273 bool LnnVisitNetif(VisitNetifCallback callback, void *data)
274 {
275 LnnNetIfMgr *item = NULL;
276 VisitNextChoice result = CHOICE_VISIT_NEXT;
277 LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node)
278 {
279 result = callback(item, data);
280 if (result == CHOICE_FINISH_VISITING) {
281 return false;
282 }
283 }
284 return true;
285 }
286
LnnVisitProtocol(VisitProtocolCallback callback,void * data)287 bool LnnVisitProtocol(VisitProtocolCallback callback, void *data)
288 {
289 VisitNextChoice result = CHOICE_VISIT_NEXT;
290 for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
291 if (g_networkProtocols[i] == NULL) {
292 continue;
293 }
294 result = callback(g_networkProtocols[i], data);
295 if (result == CHOICE_FINISH_VISITING) {
296 return false;
297 }
298 }
299 return true;
300 }
301
RestartCoapDiscovery(void)302 static void RestartCoapDiscovery(void)
303 {
304 char ifName[NET_IF_NAME_LEN] = {0};
305 int32_t authPort = 0;
306 if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName, NET_IF_NAME_LEN) != SOFTBUS_OK) {
307 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ifName error!");
308 return;
309 }
310 if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) == 0) {
311 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "ip invalid now, stop group create");
312 return;
313 }
314 if (LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &authPort) != SOFTBUS_OK) {
315 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local auth port failed.");
316 return;
317 }
318 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "open previous discovery again");
319 LnnStopDiscovery();
320 if (LnnStartDiscovery() != SOFTBUS_OK) {
321 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start discovery failed");
322 }
323 SetCallLnnStatus(true);
324 }
325
OnGroupCreated(const char * groupId)326 static void OnGroupCreated(const char *groupId)
327 {
328 (void)groupId;
329 RestartCoapDiscovery();
330 LnnOnOhosAccountChanged();
331 LnnHbOnAuthGroupCreated();
332 }
333
OnGroupDeleted(const char * groupId)334 static void OnGroupDeleted(const char *groupId)
335 {
336 (void)groupId;
337 LnnOnOhosAccountChanged();
338 LnnHbOnAuthGroupDeleted();
339 }
340
341 static GroupChangeListener g_groupChangeListener = {
342 .onGroupCreated = OnGroupCreated,
343 .onGroupDeleted = OnGroupDeleted,
344 };
345
GetAllProtocols(const LnnProtocolManager * manager,void * data)346 static VisitNextChoice GetAllProtocols(const LnnProtocolManager *manager, void *data)
347 {
348 if (manager == NULL || data == NULL) {
349 return CHOICE_FINISH_VISITING;
350 }
351
352 ProtocolType *type = (ProtocolType *)data;
353 *type |= manager->id;
354 return CHOICE_VISIT_NEXT;
355 }
356
LnnInitNetworkManager(void)357 int32_t LnnInitNetworkManager(void)
358 {
359 RegistNetIfMgr(LNN_ETH_TYPE, CreateNetifMgr);
360 RegistNetIfMgr(LNN_WLAN_TYPE, CreateNetifMgr);
361 RegistNetIfMgr(LNN_BR_TYPE, CreateNetifMgr);
362 RegistNetIfMgr(LNN_BLE_TYPE, CreateNetifMgr);
363
364 int32_t ret = LnnInitManagerByConfig();
365 if (ret != SOFTBUS_OK) {
366 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Read net config failed!ret=%d", ret);
367 return ret;
368 }
369
370 // Regist default protocols
371 ret = RegistIPProtocolManager();
372 if (ret != SOFTBUS_OK) {
373 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "regist ip protocol manager failed,ret=%d", ret);
374 return ret;
375 }
376 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "IP protocol registed.");
377
378 ret = RegistBtProtocolManager();
379 if (ret != SOFTBUS_OK) {
380 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "regist bt protocol manager failed,ret=%d", ret);
381 return ret;
382 }
383 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "BT protocol registed.");
384
385 ret = RegistNewIPProtocolManager();
386 if (ret != SOFTBUS_OK) {
387 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "regist newip protocol manager failed,ret=%d\n", ret);
388 return ret;
389 }
390
391 ret = RegGroupChangeListener(&g_groupChangeListener);
392 if (ret != SOFTBUS_OK) {
393 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register group change listener fail");
394 return ret;
395 }
396
397 ret = LnnInitPhysicalSubnetManager();
398 if (ret != SOFTBUS_OK) {
399 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init subnet manager failed!,ret=%d", ret);
400 return ret;
401 }
402
403 ProtocolType type = 0;
404 if (!LnnVisitProtocol(GetAllProtocols, &type)) {
405 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Get all protocol failed!");
406 return SOFTBUS_ERR;
407 }
408
409 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "set supported protocol to %lld.", type);
410 ret = LnnSetLocalNum64Info(NUM_KEY_TRANS_PROTOCOLS, (int64_t)type);
411 if (ret != SOFTBUS_OK) {
412 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set supported protocol failed!,ret=%d\n", ret);
413 return ret;
414 }
415
416 return SOFTBUS_OK;
417 }
418
LnnInitNetworkManagerDelay(void)419 int32_t LnnInitNetworkManagerDelay(void)
420 {
421 uint32_t i;
422
423 char udid[UDID_BUF_LEN] = {0};
424 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
425 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid error!");
426 return SOFTBUS_ERR;
427 }
428
429 LnnNetIfMgr *item = NULL;
430 LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node) {
431 for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) {
432 if (g_networkProtocols[i] == NULL) {
433 continue;
434 }
435 if ((g_networkProtocols[i]->supportedNetif & item->type) != 0) {
436 int32_t ret = g_networkProtocols[i]->Enable(g_networkProtocols[i], item);
437 if (ret != SOFTBUS_OK) {
438 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "enable protocol (%d) for netif %s failed", i,
439 item->ifName);
440 }
441 SoftBusLog(
442 SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "enable protocol (%d) for netif %s success", i, item->ifName);
443 }
444 }
445 }
446 return SOFTBUS_OK;
447 }
448
LnnIsAutoNetWorkingEnabled(void)449 bool LnnIsAutoNetWorkingEnabled(void)
450 {
451 bool isEnabled = false;
452 if (SoftbusGetConfig(SOFTBUS_INT_AUTO_NETWORKING_SWITCH, (unsigned char *)&isEnabled,
453 sizeof(isEnabled)) != SOFTBUS_OK) {
454 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Cannot get autoNetworkingSwitch from config file");
455 return true;
456 }
457 return isEnabled;
458 }
459
LnnDeinitNetworkManager(void)460 void LnnDeinitNetworkManager(void)
461 {
462 uint32_t i;
463 if (LnnClearNetConfigList() != SOFTBUS_OK) {
464 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "deinit network manager failed");
465 }
466
467 LnnDeinitPhysicalSubnetManager();
468
469 for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) {
470 if (g_networkProtocols[i] == NULL || g_networkProtocols[i]->Deinit == NULL) {
471 continue;
472 }
473 g_networkProtocols[i]->Deinit(g_networkProtocols[i]);
474 g_networkProtocols[i] = NULL;
475 }
476 }
477
LnnGetNetIfTypeByName(const char * ifName,LnnNetIfType * type)478 int32_t LnnGetNetIfTypeByName(const char *ifName, LnnNetIfType *type)
479 {
480 if (ifName == NULL || type == NULL) {
481 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters are NULL!");
482 return SOFTBUS_ERR;
483 }
484 LnnNetIfMgr *netif = NULL;
485 LIST_FOR_EACH_ENTRY(netif, &g_netIfNameList, LnnNetIfMgr, node) {
486 if (strncmp(ifName, netif->ifName, sizeof(netif->ifName)) == 0) {
487 *type = netif->type;
488 return SOFTBUS_OK;
489 }
490 }
491 return SOFTBUS_ERR;
492 }
493
LnnGetAddrTypeByIfName(const char * ifName,ConnectionAddrType * type)494 int32_t LnnGetAddrTypeByIfName(const char *ifName, ConnectionAddrType *type)
495 {
496 if (type == NULL || ifName == NULL) {
497 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters are NULL!");
498 return SOFTBUS_ERR;
499 }
500 LnnNetIfType netifType;
501 int32_t ret = LnnGetNetIfTypeByName(ifName, &netifType);
502 if (ret != SOFTBUS_OK) {
503 return ret;
504 }
505 switch (netifType) {
506 case LNN_NETIF_TYPE_ETH:
507 *type = CONNECTION_ADDR_ETH;
508 break;
509 case LNN_NETIF_TYPE_WLAN:
510 *type = CONNECTION_ADDR_WLAN;
511 break;
512 case LNN_NETIF_TYPE_BR:
513 *type = CONNECTION_ADDR_BR;
514 break;
515 case LNN_NETIF_TYPE_BLE:
516 *type = CONNECTION_ADDR_BLE;
517 break;
518 default:
519 ret = SOFTBUS_ERR;
520 }
521 return ret;
522 }
523
524 struct FindProtocolByTypeRequest {
525 ProtocolType protocol;
526 const LnnProtocolManager *manager;
527 };
528
FindProtocolByType(const LnnProtocolManager * manager,void * data)529 static VisitNextChoice FindProtocolByType(const LnnProtocolManager *manager, void *data)
530 {
531 struct FindProtocolByTypeRequest *request = (struct FindProtocolByTypeRequest *)data;
532 if (manager->id == request->protocol) {
533 request->manager = manager;
534 return CHOICE_FINISH_VISITING;
535 } else {
536 return CHOICE_VISIT_NEXT;
537 }
538 }
539
LnnGetProtocolListenerModule(ProtocolType protocol,ListenerMode mode)540 ListenerModule LnnGetProtocolListenerModule(ProtocolType protocol, ListenerMode mode)
541 {
542 struct FindProtocolByTypeRequest request = {.protocol = protocol, .manager = NULL};
543 if (LnnVisitProtocol(FindProtocolByType, &request)) {
544 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s: not such protocol! protocolId=%d", __func__, protocol);
545 return UNUSE_BUTT;
546 }
547 if (request.manager == NULL || request.manager->GetListenerModule == NULL) {
548 SoftBusLog(
549 SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s: protocol manager is null! protocolId=%d", __func__, protocol);
550 return UNUSE_BUTT;
551 }
552 return request.manager->GetListenerModule(mode);
553 }
554