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 "disc_nstackx_adapter.h"
17
18 #include <stdio.h>
19 #include <string.h>
20 #include "bus_center_manager.h"
21 #include "nstackx.h"
22 #include "securec.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_errcode.h"
25 #include "softbus_feature_config.h"
26 #include "softbus_json_utils.h"
27 #include "softbus_log.h"
28 #include "softbus_utils.h"
29 #include "softbus_hidumper_disc.h"
30 #include "softbus_hisysevt_discreporter.h"
31
32 #define JSON_WLAN_IP "wifiIpAddr"
33 #define JSON_HW_ACCOUNT "hwAccountHashVal"
34 #define JSON_SERVICE_DATA "serviceData"
35 #define SERVICE_DATA_PORT "port"
36 #define DEVICE_UDID "UDID"
37 #define AUTH_PORT_LEN 6
38 #define WLAN_IFACE_NAME_PREFIX "wlan"
39 #define INVALID_IP_ADDR "0.0.0.0"
40 #define DEFAULT_DEVICE_TYPE 0xAF
41 #define DISC_FREQ_COUNT_MASK 0xFFFF
42 #define DISC_FREQ_DURATION_BIT 16
43 #define DISC_USECOND 1000
44
45 #define NSTACKX_LOCAL_DEV_INFO "NstackxLocalDevInfo"
46
47 static NSTACKX_LocalDeviceInfo *g_localDeviceInfo = NULL;
48 static DiscInnerCallback *g_discCoapInnerCb = NULL;
49 static char *g_capabilityData = NULL;
50 static int32_t NstackxLocalDevInfoDump(int fd);
51
ParseWifiIpAddr(const cJSON * data,DeviceInfo * device)52 static void ParseWifiIpAddr(const cJSON *data, DeviceInfo *device)
53 {
54 if (!GetJsonObjectStringItem(data, JSON_WLAN_IP, device->addr[0].info.ip.ip,
55 sizeof(device->addr[0].info.ip.ip))) {
56 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse wifi ip address failed.");
57 return;
58 }
59 }
60
ParseHwAccountHash(const cJSON * data,DeviceInfo * device)61 static void ParseHwAccountHash(const cJSON *data, DeviceInfo *device)
62 {
63 if (!GetJsonObjectStringItem(data, JSON_HW_ACCOUNT, device->accountHash, sizeof(device->accountHash))) {
64 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse hw account hash value failed.");
65 return;
66 }
67 }
68
ParseItemDataFromServiceData(char * serviceData,const char * key,char * targetStr,uint32_t len)69 static void ParseItemDataFromServiceData(char *serviceData, const char *key, char *targetStr, uint32_t len)
70 {
71 const char *itemDelimit = ",";
72 const char *keyStr = NULL;
73 char *valueStr = NULL;
74 char *itemStr = NULL;
75 char *saveItemPtr = NULL;
76 itemStr = strtok_s(serviceData, itemDelimit, &saveItemPtr);
77 while (itemStr != NULL) {
78 valueStr = strchr(itemStr, ':');
79 if (valueStr == NULL) {
80 continue;
81 }
82 *valueStr = '\0';
83 valueStr++;
84 keyStr = itemStr;
85 if (!strcmp(keyStr, key)) {
86 if (strcpy_s(targetStr, len, valueStr) != EOK) {
87 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "strpcy_s failed.");
88 break;
89 }
90 return;
91 }
92 itemStr = strtok_s(NULL, itemDelimit, &saveItemPtr);
93 }
94 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "not find key in service data.");
95 return;
96 }
97
ParseServiceData(const cJSON * data,DeviceInfo * device)98 static void ParseServiceData(const cJSON *data, DeviceInfo *device)
99 {
100 char serviceData[NSTACKX_MAX_SERVICE_DATA_LEN] = {0};
101 if (!GetJsonObjectStringItem(data, JSON_SERVICE_DATA, serviceData, sizeof(serviceData))) {
102 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse service data failed.");
103 return;
104 }
105 char port[AUTH_PORT_LEN] = {0};
106 ParseItemDataFromServiceData(serviceData, SERVICE_DATA_PORT, port, sizeof(port));
107 int authPort = atoi(port);
108 if (authPort > UINT16_MAX || authPort <= 0) {
109 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "not find auth port.");
110 return;
111 }
112 device->addr[0].info.ip.port = (uint16_t)authPort;
113 }
114
ParseReservedInfo(const NSTACKX_DeviceInfo * nstackxDevice,DeviceInfo * device)115 static int32_t ParseReservedInfo(const NSTACKX_DeviceInfo *nstackxDevice, DeviceInfo *device)
116 {
117 cJSON *reserveInfo = cJSON_Parse(nstackxDevice->reservedInfo);
118 if (reserveInfo == NULL) {
119 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse reserve data failed.");
120 return SOFTBUS_PARSE_JSON_ERR;
121 }
122
123 ParseWifiIpAddr(reserveInfo, device);
124 ParseHwAccountHash(reserveInfo, device);
125 ParseServiceData(reserveInfo, device);
126 cJSON_Delete(reserveInfo);
127 return SOFTBUS_OK;
128 }
129
ParseDeviceUdid(const NSTACKX_DeviceInfo * nstackxDevice,DeviceInfo * device)130 static int32_t ParseDeviceUdid(const NSTACKX_DeviceInfo *nstackxDevice, DeviceInfo *device)
131 {
132 cJSON *udid = cJSON_Parse(nstackxDevice->deviceId);
133 if (udid == NULL) {
134 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse udid failed.");
135 return SOFTBUS_ERR;
136 }
137 if (!GetJsonObjectStringItem(udid, DEVICE_UDID, device->devId, sizeof(device->devId))) {
138 cJSON_Delete(udid);
139 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse udid from remote failed.");
140 return SOFTBUS_ERR;
141 }
142 cJSON_Delete(udid);
143 return SOFTBUS_OK;
144 }
145
IsReport(uint8_t mode,uint8_t discoveryType)146 static bool IsReport(uint8_t mode, uint8_t discoveryType)
147 {
148 if (discoveryType == NSTACKX_DISCOVERY_TYPE_ACTIVE) {
149 return true;
150 }
151 if (mode == PUBLISH_MODE_PROACTIVE) {
152 return true;
153 }
154 return false;
155 }
156
ParseDiscDevInfo(const NSTACKX_DeviceInfo * nstackxDevInfo,DeviceInfo * discDevInfo)157 static int32_t ParseDiscDevInfo(const NSTACKX_DeviceInfo *nstackxDevInfo, DeviceInfo *discDevInfo)
158 {
159 if (strcpy_s(discDevInfo->devName, sizeof(discDevInfo->devName), nstackxDevInfo->deviceName) != EOK ||
160 memcpy_s(discDevInfo->capabilityBitmap, sizeof(discDevInfo->capabilityBitmap),
161 nstackxDevInfo->capabilityBitmap, sizeof(nstackxDevInfo->capabilityBitmap)) != EOK) {
162 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "strcpy_s devName or memcpy_s capabilityBitmap failed.");
163 return SOFTBUS_ERR;
164 }
165
166 discDevInfo->addrNum = 1;
167 discDevInfo->devType = (DeviceType)nstackxDevInfo->deviceType;
168 discDevInfo->capabilityBitmapNum = nstackxDevInfo->capabilityBitmapNum;
169 if (!IsReport(nstackxDevInfo->mode, nstackxDevInfo->discoveryType)) {
170 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "publishers do not need to report devices.");
171 return SOFTBUS_ERR;
172 }
173
174 if (strncmp(nstackxDevInfo->networkName, WLAN_IFACE_NAME_PREFIX, strlen(WLAN_IFACE_NAME_PREFIX)) == 0) {
175 discDevInfo->addr[0].type = CONNECTION_ADDR_WLAN;
176 } else {
177 discDevInfo->addr[0].type = CONNECTION_ADDR_ETH;
178 }
179
180 if (ParseDeviceUdid(nstackxDevInfo, discDevInfo) != SOFTBUS_OK) {
181 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse device udid failed.");
182 return SOFTBUS_ERR;
183 }
184
185 if (ParseReservedInfo(nstackxDevInfo, discDevInfo) != SOFTBUS_OK) {
186 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "parse reserve information failed.");
187 return SOFTBUS_ERR;
188 }
189 // coap not support range now, just assign -1 as unknown
190 discDevInfo->range = -1;
191
192 return SOFTBUS_OK;
193 }
194
OnDeviceFound(const NSTACKX_DeviceInfo * deviceList,uint32_t deviceCount)195 static void OnDeviceFound(const NSTACKX_DeviceInfo *deviceList, uint32_t deviceCount)
196 {
197 if ((deviceList == NULL) || (deviceCount == 0)) {
198 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "%s:invalid param.", __func__);
199 return;
200 }
201 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "Disc device found, count=%u", deviceCount);
202 DeviceInfo *discDeviceInfo = (DeviceInfo *)SoftBusCalloc(sizeof(DeviceInfo));
203 if (discDeviceInfo == NULL) {
204 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "malloc device info failed.");
205 return;
206 }
207
208 InnerDeviceInfoAddtions addtions = {
209 .medium = COAP,
210 };
211
212 for (uint32_t i = 0; i < deviceCount; i++) {
213 const NSTACKX_DeviceInfo *nstackxDeviceInfo = deviceList + i;
214
215 if (((nstackxDeviceInfo->update) & 0x1) == 0) {
216 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "duplicate device is not reported.");
217 continue;
218 }
219 (void)memset_s(discDeviceInfo, sizeof(DeviceInfo), 0, sizeof(DeviceInfo));
220 if (ParseDiscDevInfo(nstackxDeviceInfo, discDeviceInfo) != SOFTBUS_OK) {
221 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "parse discovery device info failed.");
222 continue;
223 }
224
225 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "Disc device found, devName=%s, localNetIfName=%s",
226 discDeviceInfo->devName, nstackxDeviceInfo->networkName);
227 if ((g_discCoapInnerCb != NULL) && (g_discCoapInnerCb->OnDeviceFound != NULL)) {
228 g_discCoapInnerCb->OnDeviceFound(discDeviceInfo, &addtions);
229 }
230 }
231
232 SoftBusFree(discDeviceInfo);
233 }
234
235 static NSTACKX_Parameter g_nstackxCallBack = {
236 .onDeviceListChanged = OnDeviceFound,
237 .onDeviceFound = NULL,
238 .onMsgReceived = NULL,
239 .onDFinderMsgReceived = NULL
240 };
241
DiscCoapRegisterCb(const DiscInnerCallback * discCoapCb)242 int32_t DiscCoapRegisterCb(const DiscInnerCallback *discCoapCb)
243 {
244 if (discCoapCb == NULL || g_discCoapInnerCb == NULL) {
245 return SOFTBUS_INVALID_PARAM;
246 }
247 if (memcpy_s(g_discCoapInnerCb, sizeof(DiscInnerCallback), discCoapCb, sizeof(DiscInnerCallback)) != EOK) {
248 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "memcpy_s failed.");
249 return SOFTBUS_MEM_ERR;
250 }
251 return SOFTBUS_OK;
252 }
253
DiscCoapRegisterCapability(uint32_t capabilityBitmapNum,uint32_t capabilityBitmap[])254 int32_t DiscCoapRegisterCapability(uint32_t capabilityBitmapNum, uint32_t capabilityBitmap[])
255 {
256 if (capabilityBitmapNum == 0) {
257 return SOFTBUS_INVALID_PARAM;
258 }
259 if (NSTACKX_RegisterCapability(capabilityBitmapNum, capabilityBitmap) != 0) {
260 return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL;
261 }
262 return SOFTBUS_OK;
263 }
264
DiscCoapSetFilterCapability(uint32_t capabilityBitmapNum,uint32_t capabilityBitmap[])265 int32_t DiscCoapSetFilterCapability(uint32_t capabilityBitmapNum, uint32_t capabilityBitmap[])
266 {
267 if (capabilityBitmapNum == 0) {
268 return SOFTBUS_INVALID_PARAM;
269 }
270 if (NSTACKX_SetFilterCapability(capabilityBitmapNum, capabilityBitmap) != SOFTBUS_OK) {
271 SoftbusRecordDiscFault(COAP, SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL);
272 return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL;
273 }
274 return SOFTBUS_OK;
275 }
276
DiscCoapRegisterServiceData(const unsigned char * serviceData,uint32_t dataLen)277 int32_t DiscCoapRegisterServiceData(const unsigned char *serviceData, uint32_t dataLen)
278 {
279 (void)serviceData;
280 (void)dataLen;
281 if (g_capabilityData == NULL) {
282 return SOFTBUS_DISCOVER_COAP_INIT_FAIL;
283 }
284
285 int32_t authPort = 0;
286 if (LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &authPort) != SOFTBUS_OK) {
287 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get auth port from lnn failed.");
288 }
289 (void)memset_s(g_capabilityData, NSTACKX_MAX_SERVICE_DATA_LEN, 0, NSTACKX_MAX_SERVICE_DATA_LEN);
290 int32_t ret = sprintf_s(g_capabilityData, NSTACKX_MAX_SERVICE_DATA_LEN, "port:%d,", authPort);
291 if (ret == -1) {
292 return SOFTBUS_ERR;
293 }
294 if (NSTACKX_RegisterServiceData(g_capabilityData) != SOFTBUS_OK) {
295 return SOFTBUS_ERR;
296 }
297 return SOFTBUS_OK;
298 }
299
GetDiscFreq(int32_t freq,uint32_t * discFreq)300 static int32_t GetDiscFreq(int32_t freq, uint32_t *discFreq)
301 {
302 uint32_t arrayFreq[FREQ_BUTT] = {0};
303 if (SoftbusGetConfig(SOFTBUS_INT_DISC_FREQ, (unsigned char *)arrayFreq, sizeof(arrayFreq)) != SOFTBUS_OK) {
304 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "disc get freq failed");
305 return SOFTBUS_ERR;
306 }
307 *discFreq = arrayFreq[freq];
308 return SOFTBUS_OK;
309 }
310
ConvertDiscoverySettings(NSTACKX_DiscoverySettings * discSet,const DiscCoapOption * option)311 static int32_t ConvertDiscoverySettings(NSTACKX_DiscoverySettings *discSet, const DiscCoapOption *option)
312 {
313 if (option->mode == ACTIVE_PUBLISH) {
314 discSet->discoveryMode = PUBLISH_MODE_PROACTIVE;
315 } else {
316 discSet->discoveryMode = DISCOVER_MODE;
317 }
318 uint32_t discFreq;
319 if (GetDiscFreq(option->freq, &discFreq) != SOFTBUS_OK) {
320 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get discovery freq config failed");
321 return SOFTBUS_ERR;
322 }
323 discSet->businessType = (uint8_t)NSTACKX_BUSINESS_TYPE_NULL;
324 discSet->advertiseCount = discFreq & DISC_FREQ_COUNT_MASK;
325 discSet->advertiseDuration = (discFreq >> DISC_FREQ_DURATION_BIT) * DISC_USECOND;
326 return SOFTBUS_OK;
327 }
328
DiscCoapStartDiscovery(DiscCoapOption * option)329 int32_t DiscCoapStartDiscovery(DiscCoapOption *option)
330 {
331 if (option == NULL) {
332 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "invalid param: option");
333 return SOFTBUS_INVALID_PARAM;
334 }
335 if (option->mode < ACTIVE_PUBLISH || option->mode > ACTIVE_DISCOVERY) {
336 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "invalid param: option->mode");
337 return SOFTBUS_INVALID_PARAM;
338 }
339 NSTACKX_DiscoverySettings discSet;
340 if (memset_s(&discSet, sizeof(NSTACKX_DiscoverySettings), 0, sizeof(NSTACKX_DiscoverySettings)) != EOK) {
341 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "memset failed");
342 return SOFTBUS_MEM_ERR;
343 }
344 if (ConvertDiscoverySettings(&discSet, option) != SOFTBUS_OK) {
345 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "set discovery settings failed");
346 return SOFTBUS_ERR;
347 }
348 if (NSTACKX_StartDeviceDiscovery(&discSet) != SOFTBUS_OK) {
349 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "start device discovery failed");
350 if (option->mode == ACTIVE_PUBLISH) {
351 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;
352 } else {
353 return SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL;
354 }
355 }
356 return SOFTBUS_OK;
357 }
358
DiscCoapStopDiscovery(void)359 int32_t DiscCoapStopDiscovery(void)
360 {
361 if (NSTACKX_StopDeviceFind() != SOFTBUS_OK) {
362 return SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL;
363 }
364
365 return SOFTBUS_OK;
366 }
367
GetDeviceId(void)368 static char *GetDeviceId(void)
369 {
370 char *formatString = NULL;
371 char udid[UDID_BUF_LEN] = {0};
372 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, sizeof(udid)) != SOFTBUS_OK) {
373 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get udid failed.");
374 return NULL;
375 }
376 cJSON *deviceId = cJSON_CreateObject();
377 if (deviceId == NULL) {
378 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "crate json object failed.");
379 return NULL;
380 }
381 if (!AddStringToJsonObject(deviceId, DEVICE_UDID, udid)) {
382 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "add udid to device id json object failed.");
383 goto GET_DEVICE_ID_END;
384 }
385 formatString = cJSON_PrintUnformatted(deviceId);
386 if (formatString == NULL) {
387 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "format device id json object failed.");
388 }
389
390 GET_DEVICE_ID_END:
391 cJSON_Delete(deviceId);
392 return formatString;
393 }
394
SetLocalDeviceInfo(void)395 static int32_t SetLocalDeviceInfo(void)
396 {
397 if (g_localDeviceInfo == NULL) {
398 return SOFTBUS_DISCOVER_COAP_NOT_INIT;
399 }
400
401 (void)memset_s(g_localDeviceInfo, sizeof(NSTACKX_LocalDeviceInfo), 0, sizeof(NSTACKX_LocalDeviceInfo));
402 char *deviceIdStr = GetDeviceId();
403 if (deviceIdStr == NULL) {
404 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get device id string failed.");
405 return SOFTBUS_ERR;
406 }
407 if (strcpy_s(g_localDeviceInfo->deviceId, sizeof(g_localDeviceInfo->deviceId), deviceIdStr) != EOK) {
408 cJSON_free(deviceIdStr);
409 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "strcpy_s failed.");
410 return SOFTBUS_ERR;
411 }
412 cJSON_free(deviceIdStr);
413 int32_t deviceType = 0;
414 if (LnnGetLocalNumInfo(NUM_KEY_DEV_TYPE_ID, &deviceType) != SOFTBUS_OK) {
415 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get local device type failed.");
416 return SOFTBUS_ERR;
417 }
418 g_localDeviceInfo->deviceType = (uint8_t)deviceType;
419 g_localDeviceInfo->businessType = (uint8_t)NSTACKX_BUSINESS_TYPE_NULL;
420 if (LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, g_localDeviceInfo->name,
421 sizeof(g_localDeviceInfo->name)) != SOFTBUS_OK ||
422 LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, g_localDeviceInfo->localIfInfo[0].networkIpAddr,
423 sizeof(g_localDeviceInfo->localIfInfo[0].networkIpAddr)) != SOFTBUS_OK ||
424 LnnGetLocalStrInfo(STRING_KEY_HICE_VERSION, g_localDeviceInfo->version,
425 sizeof(g_localDeviceInfo->version)) != SOFTBUS_OK ||
426 LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, g_localDeviceInfo->localIfInfo[0].networkName,
427 sizeof(g_localDeviceInfo->localIfInfo[0].networkName)) != SOFTBUS_OK) {
428 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get local device info from lnn failed.");
429 return SOFTBUS_ERR;
430 }
431 g_localDeviceInfo->ifNums = 1;
432
433 return SOFTBUS_OK;
434 }
435
DiscCoapUpdateLocalIp(LinkStatus status)436 void DiscCoapUpdateLocalIp(LinkStatus status)
437 {
438 if (status == LINK_STATUS_UP) {
439 int32_t ret = SetLocalDeviceInfo();
440 if (ret != SOFTBUS_OK) {
441 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "set local device info failed, ret = %d.", ret);
442 return;
443 }
444 } else if (status == LINK_STATUS_DOWN) {
445 if (strcpy_s(g_localDeviceInfo->localIfInfo[0].networkIpAddr,
446 sizeof(g_localDeviceInfo->localIfInfo[0].networkIpAddr), INVALID_IP_ADDR) != EOK) {
447 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "strcpy_s networkIpAddr failed.");
448 return;
449 }
450 } else {
451 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "invlaid link status, status = %d.", status);
452 return;
453 }
454
455 if (NSTACKX_RegisterDevice(g_localDeviceInfo) != SOFTBUS_OK) {
456 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "register new ip to dfinder failed.");
457 }
458 }
459
DiscCoapUpdateDevName(void)460 void DiscCoapUpdateDevName(void)
461 {
462 char localDevName[NSTACKX_MAX_DEVICE_NAME_LEN] = {0};
463 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, localDevName, sizeof(localDevName));
464 if (ret != SOFTBUS_OK) {
465 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "get local device name failed, ret = %d.", ret);
466 return;
467 }
468 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_INFO, "register new local device name: %s", localDevName);
469 ret = NSTACKX_RegisterDeviceName(localDevName);
470 if (ret != SOFTBUS_OK) {
471 SoftBusLog(SOFTBUS_LOG_DISC, SOFTBUS_LOG_ERROR, "register local device name failed, ret = %d.", ret);
472 }
473 }
474
DeinitLocalInfo(void)475 static void DeinitLocalInfo(void)
476 {
477 if (g_localDeviceInfo != NULL) {
478 SoftBusFree(g_localDeviceInfo);
479 g_localDeviceInfo = NULL;
480 }
481
482 if (g_capabilityData != NULL) {
483 SoftBusFree(g_capabilityData);
484 g_capabilityData = NULL;
485 }
486
487 if (g_discCoapInnerCb != NULL) {
488 SoftBusFree(g_discCoapInnerCb);
489 g_discCoapInnerCb = NULL;
490 }
491 }
492
InitLocalInfo(void)493 static int32_t InitLocalInfo(void)
494 {
495 if (g_localDeviceInfo == NULL) {
496 g_localDeviceInfo = (NSTACKX_LocalDeviceInfo*)SoftBusCalloc(sizeof(NSTACKX_LocalDeviceInfo));
497 if (g_localDeviceInfo == NULL) {
498 return SOFTBUS_MEM_ERR;
499 }
500 }
501 if (g_capabilityData == NULL) {
502 g_capabilityData = (char*)SoftBusCalloc(NSTACKX_MAX_SERVICE_DATA_LEN);
503 if (g_capabilityData == NULL) {
504 DeinitLocalInfo();
505 return SOFTBUS_MEM_ERR;
506 }
507 }
508 if (g_discCoapInnerCb == NULL) {
509 g_discCoapInnerCb = (DiscInnerCallback*)SoftBusCalloc(sizeof(DiscInnerCallback));
510 if (g_discCoapInnerCb == NULL) {
511 DeinitLocalInfo();
512 return SOFTBUS_MEM_ERR;
513 }
514 }
515 return SOFTBUS_OK;
516 }
517
DiscNstackxInit(void)518 int32_t DiscNstackxInit(void)
519 {
520 if (InitLocalInfo() != SOFTBUS_OK) {
521 return SOFTBUS_DISCOVER_COAP_INIT_FAIL;
522 }
523
524 NSTACKX_DFinderRegisterLog(NstackxLog);
525 if (NSTACKX_Init(&g_nstackxCallBack) != SOFTBUS_OK) {
526 DeinitLocalInfo();
527 return SOFTBUS_DISCOVER_COAP_INIT_FAIL;
528 }
529 SoftBusRegDiscVarDump((char *)NSTACKX_LOCAL_DEV_INFO, &NstackxLocalDevInfoDump);
530 return SOFTBUS_OK;
531 }
532
DiscNstackxDeinit(void)533 void DiscNstackxDeinit(void)
534 {
535 NSTACKX_Deinit();
536 DeinitLocalInfo();
537 }
538
NstackxLocalDevInfoDump(int fd)539 static int32_t NstackxLocalDevInfoDump(int fd)
540 {
541 char deviceId[NSTACKX_MAX_DEVICE_ID_LEN] = {0};
542 char btMacAddr[NSTACKX_MAX_MAC_STRING_LEN] = {0};
543 char wifiMacAddr[NSTACKX_MAX_MAC_STRING_LEN] = {0};
544 char ip[NSTACKX_MAX_IP_STRING_LEN] = {0};
545 char networkIpAddr[NSTACKX_MAX_IP_STRING_LEN] = {0};
546 SOFTBUS_DPRINTF(fd, "\n-----------------NstackxLocalDevInfo-------------------\n");
547 SOFTBUS_DPRINTF(fd, "name : %s\n", g_localDeviceInfo->name);
548 DataMasking(g_localDeviceInfo->deviceId, NSTACKX_MAX_DEVICE_ID_LEN, ID_DELIMITER, deviceId);
549 SOFTBUS_DPRINTF(fd, "deviceId : %s\n", deviceId);
550 DataMasking(g_localDeviceInfo->btMacAddr, NSTACKX_MAX_MAC_STRING_LEN, MAC_DELIMITER, btMacAddr);
551 SOFTBUS_DPRINTF(fd, "btMacAddr : %s\n", btMacAddr);
552 DataMasking(g_localDeviceInfo->wifiMacAddr, NSTACKX_MAX_MAC_STRING_LEN, MAC_DELIMITER, wifiMacAddr);
553 SOFTBUS_DPRINTF(fd, "wifiMacAddr : %s\n", wifiMacAddr);
554 SOFTBUS_DPRINTF(fd, "localIfInfo networkName : %s\n", g_localDeviceInfo->localIfInfo->networkName);
555 DataMasking(g_localDeviceInfo->localIfInfo->networkIpAddr, NSTACKX_MAX_IP_STRING_LEN, IP_DELIMITER, ip);
556 SOFTBUS_DPRINTF(fd, "localIfInfo networkIpAddr : %s\n", ip);
557 SOFTBUS_DPRINTF(fd, "ifNums : %d\n", g_localDeviceInfo->ifNums);
558 DataMasking(g_localDeviceInfo->networkIpAddr, NSTACKX_MAX_IP_STRING_LEN, IP_DELIMITER, networkIpAddr);
559 SOFTBUS_DPRINTF(fd, "networkIpAddr : %s\n", networkIpAddr);
560 SOFTBUS_DPRINTF(fd, "networkName : %s\n", g_localDeviceInfo->networkName);
561 SOFTBUS_DPRINTF(fd, "is5GHzBandSupported : %d\n", g_localDeviceInfo->is5GHzBandSupported);
562 SOFTBUS_DPRINTF(fd, "deviceType : %d\n", g_localDeviceInfo->deviceType);
563 SOFTBUS_DPRINTF(fd, "version : %s\n", g_localDeviceInfo->version);
564 SOFTBUS_DPRINTF(fd, "businessType : %d\n", g_localDeviceInfo->businessType);
565 SOFTBUS_DPRINTF(fd, "\n-----------------NstackxCapDataInfo-------------------\n");
566 SOFTBUS_DPRINTF(fd, "capabilityData : %s\n", g_capabilityData);
567
568 return SOFTBUS_OK;
569 }
570