Star31
480
代码
代码
Issues124
Pull Requests64
项目讨论
Wiki
分析
Star31
480
已合并
fix coap lock problem #11173
wangJE创建于 2025年10月28日
fix coap lock problem #11173
已合并
wangJE创建于 2025年10月28日
从wangJE/communication_dsoftbusmaster合入到openharmony/communication_dsoftbusmaster
共 2 个文件变更+91-145
Mcore/discovery/coap/nstackx_coap/src/disc_coap.c+83-137
@@ -39,14 +39,18 @@ typedef struct {
39 bool isEmpty;39 bool isEmpty;
40 int16_t capCount[MAX_CAP_NUM];40 int16_t capCount[MAX_CAP_NUM];
41 uint32_t allCap[CAPABILITY_NUM];41 uint32_t allCap[CAPABILITY_NUM];
42- SoftBusMutex lock;
43} DiscCoapInfo;42} DiscCoapInfo;
44 43 
45-static DiscCoapInfo *g_publishMgr = NULL;44+typedef struct {
46-static DiscCoapInfo *g_subscribeMgr = NULL;45+ DiscCoapInfo publishInfo;
46+ DiscCoapInfo subscribeInfo;
47+ SoftBusMutex lock;
48+} DiscCoapManager;
49+ 
50+static DiscCoapManager g_discCoapMgr = {0};
47static int CoapPubInfoDump(int fd);51static int CoapPubInfoDump(int fd);
48static int CoapSubInfoDump(int fd);52static int CoapSubInfoDump(int fd);
49-static bool UpdateFilter(bool isSubscribe);53+static bool UpdateFilter(void);
50 54 
51static int32_t RegisterAllCapBitmap(uint32_t capBitmapNum, const uint32_t inCapBitmap[], DiscCoapInfo *info,55static int32_t RegisterAllCapBitmap(uint32_t capBitmapNum, const uint32_t inCapBitmap[], DiscCoapInfo *info,
52 uint32_t count)56 uint32_t count)
@@ -205,7 +209,6 @@ static bool CheckParam(const PublishOption *pubOption, const SubscribeOption *su
205{209{
206 if (isPublish) {210 if (isPublish) {
207 DISC_CHECK_AND_RETURN_RET_LOGE(pubOption != NULL, false, DISC_COAP, "publish option is null");211 DISC_CHECK_AND_RETURN_RET_LOGE(pubOption != NULL, false, DISC_COAP, "publish option is null");
208- DISC_CHECK_AND_RETURN_RET_LOGE(g_publishMgr != NULL, false, DISC_COAP, "g_publishMgr is null");
209 DISC_CHECK_AND_RETURN_RET_LOGE(LOW <= pubOption->freq && pubOption->freq < FREQ_BUTT, false, DISC_COAP,212 DISC_CHECK_AND_RETURN_RET_LOGE(LOW <= pubOption->freq && pubOption->freq < FREQ_BUTT, false, DISC_COAP,
210 "invalid publish freq. freq=%{public}d", pubOption->freq);213 "invalid publish freq. freq=%{public}d", pubOption->freq);
211 if (pubOption->ranging) {214 if (pubOption->ranging) {
@@ -213,7 +216,6 @@ static bool CheckParam(const PublishOption *pubOption, const SubscribeOption *su
213 }216 }
214 } else {217 } else {
215 DISC_CHECK_AND_RETURN_RET_LOGE(subOption != NULL, false, DISC_COAP, "discovery option is null");218 DISC_CHECK_AND_RETURN_RET_LOGE(subOption != NULL, false, DISC_COAP, "discovery option is null");
216- DISC_CHECK_AND_RETURN_RET_LOGE(g_subscribeMgr != NULL, false, DISC_COAP, "g_subscribeMgr is null");
217 DISC_CHECK_AND_RETURN_RET_LOGE(LOW <= subOption->freq && subOption->freq < FREQ_BUTT, false, DISC_COAP,219 DISC_CHECK_AND_RETURN_RET_LOGE(LOW <= subOption->freq && subOption->freq < FREQ_BUTT, false, DISC_COAP,
218 "invalid discovery freq. freq=%{public}d", subOption->freq);220 "invalid discovery freq. freq=%{public}d", subOption->freq);
219 }221 }
@@ -253,18 +255,19 @@ static int32_t RegisterInfoToDfinder(const PublishOption *option, bool isActive)
253{255{
254 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(option, NULL, true), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");256 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(option, NULL, true), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
255 DISC_CHECK_AND_RETURN_RET_LOGE(CheckFeature(option), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");257 DISC_CHECK_AND_RETURN_RET_LOGE(CheckFeature(option), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
256- if (RegisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap, g_publishMgr, MAX_CAP_NUM) != SOFTBUS_OK) {258+ if (RegisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap,
259+ &g_discCoapMgr.publishInfo, MAX_CAP_NUM) != SOFTBUS_OK) {
257 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_MERGE_CAP_FAIL);260 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_MERGE_CAP_FAIL);
258 DISC_LOGE(DISC_COAP, "merge publish capability failed. isActive=%{public}s", isActive ? "active" : "passive");261 DISC_LOGE(DISC_COAP, "merge publish capability failed. isActive=%{public}s", isActive ? "active" : "passive");
259 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;262 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;
260 }263 }
261- if (!UpdateFilter(false)) {264+ if (!UpdateFilter()) {
262 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_REGISTER_CAP_FAIL);265 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_REGISTER_CAP_FAIL);
263 DISC_LOGE(DISC_COAP, "register all capability to dfinder failed.");266 DISC_LOGE(DISC_COAP, "register all capability to dfinder failed.");
264 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;267 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;
265 }268 }
266 uint32_t curCap = option->capabilityBitmap[0];269 uint32_t curCap = option->capabilityBitmap[0];
267- if (DiscCoapRegisterServiceData(option, g_publishMgr->allCap[0]) != SOFTBUS_OK) {270+ if (DiscCoapRegisterServiceData(option, g_discCoapMgr.publishInfo.allCap[0]) != SOFTBUS_OK) {
268 DfxRecordRegisterEnd(curCap, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);271 DfxRecordRegisterEnd(curCap, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
269 DISC_LOGE(DISC_COAP, "register service data to dfinder failed.");272 DISC_LOGE(DISC_COAP, "register service data to dfinder failed.");
270 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;273 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;
@@ -284,7 +287,7 @@ static int32_t Publish(const PublishOption *option, bool isActive)
284{287{
285 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(option, NULL, true), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");288 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(option, NULL, true), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
286 DISC_CHECK_AND_RETURN_RET_LOGE(CheckFeature(option), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");289 DISC_CHECK_AND_RETURN_RET_LOGE(CheckFeature(option), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
287- DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_publishMgr->lock)) == 0, SOFTBUS_LOCK_ERR, DISC_COAP,290+ DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discCoapMgr.lock)) == 0, SOFTBUS_LOCK_ERR, DISC_COAP,
288 "publish mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");291 "publish mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");
289 if (RegisterInfoToDfinder(option, isActive) != SOFTBUS_OK) {292 if (RegisterInfoToDfinder(option, isActive) != SOFTBUS_OK) {
290 DISC_LOGE(DISC_COAP, "register info to dfinder failed.");293 DISC_LOGE(DISC_COAP, "register info to dfinder failed.");
@@ -304,16 +307,16 @@ static int32_t Publish(const PublishOption *option, bool isActive)
304 if (DiscCoapStartDiscovery(&discCoapOption) != SOFTBUS_OK) {307 if (DiscCoapStartDiscovery(&discCoapOption) != SOFTBUS_OK) {
305 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,308 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,
306 SOFTBUS_HISYSEVT_DISCOVER_COAP_START_DISCOVER_FAIL);309 SOFTBUS_HISYSEVT_DISCOVER_COAP_START_DISCOVER_FAIL);
307- DISC_LOGE(DISC_COAP, "coap active publish failed, allCap=%{public}u", g_publishMgr->allCap[0]);310+ DISC_LOGE(DISC_COAP, "coap active publish failed, allCap=%{public}u", g_discCoapMgr.publishInfo.allCap[0]);
308 goto PUB_FAIL;311 goto PUB_FAIL;
309 }312 }
310 }313 }
311- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));314+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
312 DISC_LOGI(DISC_COAP, "coap publish succ, isActive=%{public}s, allCap=%{public}u ", isActive ? "active" : "passive",315 DISC_LOGI(DISC_COAP, "coap publish succ, isActive=%{public}s, allCap=%{public}u ", isActive ? "active" : "passive",
313- g_publishMgr->allCap[0]);316+ g_discCoapMgr.publishInfo.allCap[0]);
314 return SOFTBUS_OK;317 return SOFTBUS_OK;
315PUB_FAIL:318PUB_FAIL:
316- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));319+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
317 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;320 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;
318}321}
319 322 
@@ -348,11 +351,12 @@ static int32_t UnPublish(const PublishOption *option, bool isActive)
348{351{
349 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(option, NULL, true), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");352 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(option, NULL, true), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
350 DISC_CHECK_AND_RETURN_RET_LOGE(CheckFeature(option), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");353 DISC_CHECK_AND_RETURN_RET_LOGE(CheckFeature(option), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
351- DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_publishMgr->lock)) == 0, SOFTBUS_LOCK_ERR, DISC_COAP,354+ DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discCoapMgr.lock)) == 0, SOFTBUS_LOCK_ERR, DISC_COAP,
352 "unPublish mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");355 "unPublish mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");
353 356 
354- if (UnregisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap, g_publishMgr, MAX_CAP_NUM) != SOFTBUS_OK) {357+ if (UnregisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap,
355- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));358+ &g_discCoapMgr.publishInfo, MAX_CAP_NUM) != SOFTBUS_OK) {
359+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
356 DISC_LOGE(DISC_COAP,360 DISC_LOGE(DISC_COAP,
357 "unRegister publish capability failed. isActive=%{public}s", isActive ? "active" : "passive");361 "unRegister publish capability failed. isActive=%{public}s", isActive ? "active" : "passive");
358 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_CANCEL_CAP_FAIL);362 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_CANCEL_CAP_FAIL);
@@ -362,31 +366,31 @@ static int32_t UnPublish(const PublishOption *option, bool isActive)
362 DiscCoapUpdateAbilityPacked(option->capabilityBitmap[0], (const char *)option->capabilityData,366 DiscCoapUpdateAbilityPacked(option->capabilityBitmap[0], (const char *)option->capabilityData,
363 option->dataLen, true, false);367 option->dataLen, true, false);
364#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */368#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */
365- if (!UpdateFilter(false)) {369+ if (!UpdateFilter()) {
366- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));370+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
367 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,371 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,
368 SOFTBUS_HISYSEVT_DISCOVER_COAP_REGISTER_CAP_FAIL);372 SOFTBUS_HISYSEVT_DISCOVER_COAP_REGISTER_CAP_FAIL);
369 return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL;373 return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL;
370 }374 }
371 uint32_t curCap = option->capabilityBitmap[0];375 uint32_t curCap = option->capabilityBitmap[0];
372- if (DiscCoapRegisterServiceData(option, g_publishMgr->allCap[0]) != SOFTBUS_OK) {376+ if (DiscCoapRegisterServiceData(option, g_discCoapMgr.publishInfo.allCap[0]) != SOFTBUS_OK) {
373- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));377+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
374 DfxRecordRegisterEnd(curCap, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);378 DfxRecordRegisterEnd(curCap, SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL);
375 DISC_LOGE(DISC_COAP, "register service data to dfinder failed.");379 DISC_LOGE(DISC_COAP, "register service data to dfinder failed.");
376 return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL;380 return SOFTBUS_DISCOVER_COAP_REGISTER_CAP_FAIL;
377 }381 }
378- if (isActive && g_publishMgr->isEmpty) {382+ if (isActive && g_discCoapMgr.publishInfo.isEmpty) {
379 if (DiscCoapStopDiscovery() != SOFTBUS_OK) {383 if (DiscCoapStopDiscovery() != SOFTBUS_OK) {
380- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));384+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
381- DISC_LOGE(DISC_COAP, "coap unpublish failed, allCap=%{public}u", g_publishMgr->allCap[0]);385+ DISC_LOGE(DISC_COAP, "coap unpublish failed, allCap=%{public}u", g_discCoapMgr.publishInfo.allCap[0]);
382 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,386 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,
383 SOFTBUS_HISYSEVT_DISCOVER_COAP_STOP_DISCOVER_FAIL);387 SOFTBUS_HISYSEVT_DISCOVER_COAP_STOP_DISCOVER_FAIL);
384 return SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL;388 return SOFTBUS_DISCOVER_COAP_STOP_PUBLISH_FAIL;
385 }389 }
386 }390 }
387- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));391+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
388 DISC_LOGI(DISC_COAP, "coap unPublish succ, isActive=%{public}s, allCap=%{public}u", isActive ?392 DISC_LOGI(DISC_COAP, "coap unPublish succ, isActive=%{public}s, allCap=%{public}u", isActive ?
389- "active" : "passive", g_publishMgr->allCap[0]);393+ "active" : "passive", g_discCoapMgr.publishInfo.allCap[0]);
390 return SOFTBUS_OK;394 return SOFTBUS_OK;
391}395}
392 396 
@@ -406,50 +410,14 @@ static int32_t CoapStopScan(const PublishOption *option)
406 return ret;410 return ret;
407}411}
408 412 
409-static void GetPubCapability(uint32_t *capability, uint32_t capLen, bool *isNeedUpdate)413+static bool UpdateFilter(void)
410{414{
411- DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&(g_publishMgr->lock)) == SOFTBUS_OK,415+ if (!g_discCoapMgr.publishInfo.isUpdate && !g_discCoapMgr.subscribeInfo.isUpdate) {
412- DISC_COAP, "mutex lock failed.");416+ return true;
413- if (memcpy_s(capability, capLen * sizeof(uint32_t),
414- g_publishMgr->allCap, sizeof(g_publishMgr->allCap)) == EOK) {
415- *isNeedUpdate = g_publishMgr->isUpdate;
416- } else {
417- DISC_LOGE(DISC_COAP, "cpy pub allCap failed");
418 }417 }
419- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));
420-}
421- 
422-static void GetSubscribeCapability(uint32_t *capability, uint32_t capLen, bool *isNeedUpdate)
423-{
424- DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&(g_subscribeMgr->lock)) == SOFTBUS_OK,
425- DISC_COAP, "mutex lock failed.");
426- if (memcpy_s(capability, capLen * sizeof(uint32_t),
427- g_subscribeMgr->allCap, sizeof(g_subscribeMgr->allCap)) == EOK) {
428- *isNeedUpdate = g_subscribeMgr->isUpdate;
429- } else {
430- DISC_LOGE(DISC_COAP, "cpy pub allCap failed");
431- }
432- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));
433-}
434- 
435-static bool UpdateFilter(bool isSubscribe)
436-{
437- uint32_t pubCap[CAPABILITY_NUM] = {0};
438- uint32_t subCap[CAPABILITY_NUM] = {0};
439- bool pubIsNeedUpdate = false;
440- bool subIsNeedUpdate = false;
441- if (isSubscribe) {
442- subIsNeedUpdate = g_subscribeMgr->isUpdate;
443- (void)memcpy_s(subCap, sizeof(subCap), g_subscribeMgr->allCap, sizeof(g_subscribeMgr->allCap));
444- GetPubCapability(pubCap, CAPABILITY_NUM, &pubIsNeedUpdate);
445- } else {
446- pubIsNeedUpdate = g_publishMgr->isUpdate;
447- (void)memcpy_s(pubCap, sizeof(pubCap), g_publishMgr->allCap, sizeof(g_publishMgr->allCap));
448- GetSubscribeCapability(subCap, CAPABILITY_NUM, &subIsNeedUpdate);
449- }
450- DISC_CHECK_AND_RETURN_RET_LOGW(pubIsNeedUpdate || subIsNeedUpdate, true, DISC_COAP, "no need update");
451 uint32_t allCap[CAPABILITY_NUM] = {0};418 uint32_t allCap[CAPABILITY_NUM] = {0};
452- AggregateAllCap(allCap, CAPABILITY_NUM, pubCap, subCap, CAPABILITY_NUM);419+ AggregateAllCap(allCap, CAPABILITY_NUM, g_discCoapMgr.subscribeInfo.allCap,
420+ g_discCoapMgr.publishInfo.allCap, CAPABILITY_NUM);
453 int32_t ret = DiscCoapSetFilterCapability(CAPABILITY_NUM, allCap);421 int32_t ret = DiscCoapSetFilterCapability(CAPABILITY_NUM, allCap);
454 if (ret != SOFTBUS_OK || DiscCoapRegisterCapability(CAPABILITY_NUM, allCap) != SOFTBUS_OK) {422 if (ret != SOFTBUS_OK || DiscCoapRegisterCapability(CAPABILITY_NUM, allCap) != SOFTBUS_OK) {
455 DfxRecordSetFilterEnd(allCap[0], ret);423 DfxRecordSetFilterEnd(allCap[0], ret);
@@ -463,7 +431,8 @@ static bool UpdateFilter(bool isSubscribe)
463 431 
464static int32_t CoapUpdateSubscribeCapBitmap(const SubscribeOption *option, bool isActive)432static int32_t CoapUpdateSubscribeCapBitmap(const SubscribeOption *option, bool isActive)
465{433{
466- if (RegisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap, g_subscribeMgr, MAX_CAP_NUM) != SOFTBUS_OK) {434+ if (RegisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap,
435+ &g_discCoapMgr.subscribeInfo, MAX_CAP_NUM) != SOFTBUS_OK) {
467 DISC_LOGE(DISC_COAP, "merge discovery capability failed. isActive=%{public}s", isActive ? "active" : "passive");436 DISC_LOGE(DISC_COAP, "merge discovery capability failed. isActive=%{public}s", isActive ? "active" : "passive");
468 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_MERGE_CAP_FAIL);437 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_MERGE_CAP_FAIL);
469 return SOFTBUS_DISCOVER_COAP_MERGE_CAP_FAIL;438 return SOFTBUS_DISCOVER_COAP_MERGE_CAP_FAIL;
@@ -472,7 +441,7 @@ static int32_t CoapUpdateSubscribeCapBitmap(const SubscribeOption *option, bool
472 DiscCoapUpdateAbilityPacked(option->capabilityBitmap[0], (const char *)option->capabilityData,441 DiscCoapUpdateAbilityPacked(option->capabilityBitmap[0], (const char *)option->capabilityData,
473 option->dataLen, false, true);442 option->dataLen, false, true);
474#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */443#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */
475- if (!UpdateFilter(true)) {444+ if (!UpdateFilter()) {
476 return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL;445 return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL;
477 }446 }
478 return SOFTBUS_OK;447 return SOFTBUS_OK;
@@ -481,21 +450,22 @@ static int32_t CoapUpdateSubscribeCapBitmap(const SubscribeOption *option, bool
481static int32_t Discovery(const SubscribeOption *option, bool isActive)450static int32_t Discovery(const SubscribeOption *option, bool isActive)
482{451{
483 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(NULL, option, false), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");452 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(NULL, option, false), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
484- DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_subscribeMgr->lock)) == 0, SOFTBUS_LOCK_ERR, DISC_COAP,453+ DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discCoapMgr.lock)) == 0, SOFTBUS_LOCK_ERR, DISC_COAP,
485 "discovery mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");454 "discovery mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");
486 int32_t ret = CoapUpdateSubscribeCapBitmap(option, isActive);455 int32_t ret = CoapUpdateSubscribeCapBitmap(option, isActive);
487 if (ret != SOFTBUS_OK) {456 if (ret != SOFTBUS_OK) {
488- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));457+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
489 return ret;458 return ret;
490 }459 }
491 if (!isActive) {460 if (!isActive) {
492- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));461+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
493- DISC_LOGI(DISC_COAP, "coap start passive discovery succ, filters=%{public}u", g_subscribeMgr->allCap[0]);462+ DISC_LOGI(DISC_COAP, "coap start passive discovery succ, filters=%{public}u",
463+ g_discCoapMgr.subscribeInfo.allCap[0]);
494 return SOFTBUS_OK;464 return SOFTBUS_OK;
495 }465 }
496 if (DiscCoapStopDiscovery() != SOFTBUS_OK) {466 if (DiscCoapStopDiscovery() != SOFTBUS_OK) {
497- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));467+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
498- DISC_LOGE(DISC_COAP, "coap stop discovery failed, filters=%{public}u", g_subscribeMgr->allCap[0]);468+ DISC_LOGE(DISC_COAP, "coap stop discovery failed, filters=%{public}u", g_discCoapMgr.subscribeInfo.allCap[0]);
499 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_STOP_DISCOVER_FAIL);469 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_STOP_DISCOVER_FAIL);
500 return SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL;470 return SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL;
501 }471 }
@@ -508,19 +478,19 @@ static int32_t Discovery(const SubscribeOption *option, bool isActive)
508 uint32_t curCap = option->capabilityBitmap[0];478 uint32_t curCap = option->capabilityBitmap[0];
509 if (DiscCoapRegisterCapabilityData(option->capabilityData, option->dataLen, curCap) != SOFTBUS_OK) {479 if (DiscCoapRegisterCapabilityData(option->capabilityData, option->dataLen, curCap) != SOFTBUS_OK) {
510 DISC_LOGW(DISC_COAP, "register capability data to dfinder failed.");480 DISC_LOGW(DISC_COAP, "register capability data to dfinder failed.");
511- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));481+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
512 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;482 return SOFTBUS_DISCOVER_COAP_START_PUBLISH_FAIL;
513 }483 }
514#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */484#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */
515- SetDiscCoapOption(&discCoapOption, &discOption, g_subscribeMgr->allCap[0]);485+ SetDiscCoapOption(&discCoapOption, &discOption, g_discCoapMgr.subscribeInfo.allCap[0]);
516 if (DiscCoapStartDiscovery(&discCoapOption) != SOFTBUS_OK) {486 if (DiscCoapStartDiscovery(&discCoapOption) != SOFTBUS_OK) {
517- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));487+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
518- DISC_LOGE(DISC_COAP, "coap start discovery failed, filters=%{public}u", g_subscribeMgr->allCap[0]);488+ DISC_LOGE(DISC_COAP, "coap start discovery failed, filters=%{public}u", g_discCoapMgr.subscribeInfo.allCap[0]);
519 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_START_DISCOVER_FAIL);489 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_START_DISCOVER_FAIL);
520 return SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL;490 return SOFTBUS_DISCOVER_COAP_START_DISCOVER_FAIL;
521 }491 }
522- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));492+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
523- DISC_LOGI(DISC_COAP, "coap start active discovery succ, filters=%{public}u", g_subscribeMgr->allCap[0]);493+ DISC_LOGI(DISC_COAP, "coap start active discovery succ, filters=%{public}u", g_discCoapMgr.subscribeInfo.allCap[0]);
524 return SOFTBUS_OK;494 return SOFTBUS_OK;
525}495}
526 496 
@@ -554,11 +524,12 @@ static int32_t CoapSubscribe(const SubscribeOption *option)
554static int32_t StopDisc(const SubscribeOption *option, bool isActive)524static int32_t StopDisc(const SubscribeOption *option, bool isActive)
555{525{
556 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(NULL, option, false), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");526 DISC_CHECK_AND_RETURN_RET_LOGE(CheckParam(NULL, option, false), SOFTBUS_INVALID_PARAM, DISC_COAP, "invalid param");
557- DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_subscribeMgr->lock)) == 0, SOFTBUS_LOCK_ERR,527+ DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&(g_discCoapMgr.lock)) == 0, SOFTBUS_LOCK_ERR,
558 DISC_COAP, "stop discovery mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");528 DISC_COAP, "stop discovery mutex lock failed. isActive=%{public}s", isActive ? "active" : "passive");
559 529 
560- if (UnregisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap, g_subscribeMgr, MAX_CAP_NUM) != SOFTBUS_OK) {530+ if (UnregisterAllCapBitmap(CAPABILITY_NUM, option->capabilityBitmap,
561- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));531+ &g_discCoapMgr.subscribeInfo, MAX_CAP_NUM) != SOFTBUS_OK) {
532+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
562 DISC_LOGE(DISC_COAP, "unRegister discovery capability failed. isActive=%{public}s",533 DISC_LOGE(DISC_COAP, "unRegister discovery capability failed. isActive=%{public}s",
563 isActive ? "active" : "passive");534 isActive ? "active" : "passive");
564 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_CANCEL_CAP_FAIL);535 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP, SOFTBUS_HISYSEVT_DISCOVER_COAP_CANCEL_CAP_FAIL);
@@ -568,22 +539,23 @@ static int32_t StopDisc(const SubscribeOption *option, bool isActive)
568 DiscCoapUpdateAbilityPacked(option->capabilityBitmap[0], (const char *)option->capabilityData,539 DiscCoapUpdateAbilityPacked(option->capabilityBitmap[0], (const char *)option->capabilityData,
569 option->dataLen, false, false);540 option->dataLen, false, false);
570#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */541#endif /* DSOFTBUS_FEATURE_DISC_SHARE_COAP */
571- if (!UpdateFilter(true)) {542+ if (!UpdateFilter()) {
572- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));543+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
573 return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL;544 return SOFTBUS_DISCOVER_COAP_SET_FILTER_CAP_FAIL;
574 }545 }
575- if (isActive && g_subscribeMgr->isEmpty) {546+ if (isActive && g_discCoapMgr.subscribeInfo.isEmpty) {
576 if (DiscCoapStopDiscovery() != SOFTBUS_OK) {547 if (DiscCoapStopDiscovery() != SOFTBUS_OK) {
577- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));548+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
578- DISC_LOGE(DISC_COAP, "coap stop active discovery failed, filters=%{public}u", g_subscribeMgr->allCap[0]);549+ DISC_LOGE(DISC_COAP, "coap stop active discovery failed, filters=%{public}u",
550+ g_discCoapMgr.subscribeInfo.allCap[0]);
579 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,551 SoftbusReportDiscFault(SOFTBUS_HISYSEVT_DISC_MEDIUM_COAP,
580 SOFTBUS_HISYSEVT_DISCOVER_COAP_STOP_DISCOVER_FAIL);552 SOFTBUS_HISYSEVT_DISCOVER_COAP_STOP_DISCOVER_FAIL);
581 return SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL;553 return SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL;
582 }554 }
583 }555 }
584- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));556+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
585 DISC_LOGI(DISC_COAP, "coap stop discovery succ, isActive=%{public}s, filters=%{public}u",557 DISC_LOGI(DISC_COAP, "coap stop discovery succ, isActive=%{public}s, filters=%{public}u",
586- isActive ? "active" : "passive", g_subscribeMgr->allCap[0]);558+ isActive ? "active" : "passive", g_discCoapMgr.subscribeInfo.allCap[0]);
587 return SOFTBUS_OK;559 return SOFTBUS_OK;
588}560}
589 561 
@@ -634,43 +606,17 @@ static DiscoveryFuncInterface g_discCoapFuncInterface = {
634 .UpdateLocalDeviceInfo = CoapUpdateLocalDeviceInfo606 .UpdateLocalDeviceInfo = CoapUpdateLocalDeviceInfo
635};607};
636 608 
637-static DiscCoapInfo *NewDiscCoapInfo(void)
638-{
639- DiscCoapInfo *coapInfo = (DiscCoapInfo*)SoftBusCalloc(sizeof(DiscCoapInfo));
640- DISC_CHECK_AND_RETURN_RET_LOGE(coapInfo != NULL, NULL, DISC_INIT, "softbus malloc failed");
641- 
642- if (SoftBusMutexInit(&(coapInfo->lock), NULL) != 0) {
643- SoftBusFree(coapInfo);
644- return NULL;
645- }
646- return coapInfo;
647-}
648- 
649-static void DeleteDiscCoapInfo(DiscCoapInfo *coapInfo)
650-{
651- DISC_CHECK_AND_RETURN_LOGE(coapInfo != NULL, DISC_COAP, "coapInfo=NULL");
652- (void)SoftBusMutexDestroy(&(coapInfo->lock));
653- SoftBusFree(coapInfo);
654-}
655- 
656static void DeinitCoapManager(void)609static void DeinitCoapManager(void)
657{610{
658- DeleteDiscCoapInfo(g_publishMgr);611+ (void)SoftBusMutexDestroy(&(g_discCoapMgr.lock));
659- g_publishMgr = NULL;
660- DeleteDiscCoapInfo(g_subscribeMgr);
661- g_subscribeMgr = NULL;
662}612}
663 613 
664static int32_t InitCoapManager(void)614static int32_t InitCoapManager(void)
665{615{
666- if (g_publishMgr == NULL) {616+ SoftBusMutexAttr mutexAttr = {
667- g_publishMgr = NewDiscCoapInfo();617+ .type = SOFTBUS_MUTEX_RECURSIVE,
668- }618+ };
669- if (g_subscribeMgr == NULL) {619+ if (SoftBusMutexInit(&(g_discCoapMgr.lock), &mutexAttr) != SOFTBUS_OK) {
670- g_subscribeMgr = NewDiscCoapInfo();
671- }
672- if (g_publishMgr == NULL || g_subscribeMgr == NULL) {
673- DeinitCoapManager();
674 return SOFTBUS_DISCOVER_COAP_INIT_FAIL;620 return SOFTBUS_DISCOVER_COAP_INIT_FAIL;
675 }621 }
676 return SOFTBUS_OK;622 return SOFTBUS_OK;
@@ -688,7 +634,7 @@ static void DfxRecordCoapInitEnd(int32_t reason)
688 634 
689uint32_t GetDiscCapability(void)635uint32_t GetDiscCapability(void)
690{636{
691- return g_subscribeMgr == NULL ? 0 : g_subscribeMgr->allCap[0];637+ return g_discCoapMgr.subscribeInfo.allCap[0];
692}638}
693 639 
694DiscoveryFuncInterface *DiscCoapInit(DiscInnerCallback *discInnerCb)640DiscoveryFuncInterface *DiscCoapInit(DiscInnerCallback *discInnerCb)
@@ -728,30 +674,30 @@ void DiscCoapDeinit(void)
728 674 
729static int CoapPubInfoDump(int fd)675static int CoapPubInfoDump(int fd)
730{676{
731- if (SoftBusMutexLock(&(g_publishMgr->lock)) != SOFTBUS_OK) {677+ if (SoftBusMutexLock(&(g_discCoapMgr.lock)) != SOFTBUS_OK) {
732- DISC_LOGE(DISC_COAP, "g_publishMgr mutex lock failed.");678+ DISC_LOGE(DISC_COAP, "g_discCoapMgr.publishInfo mutex lock failed.");
733 return SOFTBUS_LOCK_ERR;679 return SOFTBUS_LOCK_ERR;
734 }680 }
735 SOFTBUS_DPRINTF(fd, "\n---------------CoapPublishInfo------------------\n");681 SOFTBUS_DPRINTF(fd, "\n---------------CoapPublishInfo------------------\n");
736- SOFTBUS_DPRINTF(fd, "publish allCap : %u\n", *(g_publishMgr->allCap));682+ SOFTBUS_DPRINTF(fd, "publish allCap : %u\n", *(g_discCoapMgr.publishInfo.allCap));
737- SOFTBUS_DPRINTF(fd, "publish capCount : %hd\n", *(g_publishMgr->capCount));683+ SOFTBUS_DPRINTF(fd, "publish capCount : %hd\n", *(g_discCoapMgr.publishInfo.capCount));
738- SOFTBUS_DPRINTF(fd, "publish isUpdate : %d\n", g_publishMgr->isUpdate);684+ SOFTBUS_DPRINTF(fd, "publish isUpdate : %d\n", g_discCoapMgr.publishInfo.isUpdate);
739- SOFTBUS_DPRINTF(fd, "publish isEmpty : %d\n", g_publishMgr->isEmpty);685+ SOFTBUS_DPRINTF(fd, "publish isEmpty : %d\n", g_discCoapMgr.publishInfo.isEmpty);
740- (void)SoftBusMutexUnlock(&(g_publishMgr->lock));686+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
741 return SOFTBUS_OK;687 return SOFTBUS_OK;
742}688}
743 689 
744static int CoapSubInfoDump(int fd)690static int CoapSubInfoDump(int fd)
745{691{
746- if (SoftBusMutexLock(&(g_subscribeMgr->lock)) != SOFTBUS_OK) {692+ if (SoftBusMutexLock(&(g_discCoapMgr.lock)) != SOFTBUS_OK) {
747- DISC_LOGE(DISC_COAP, "g_subscribeMgr mutex lock failed.");693+ DISC_LOGE(DISC_COAP, "g_discCoapMgr.subscribeInfo mutex lock failed.");
748 return SOFTBUS_LOCK_ERR;694 return SOFTBUS_LOCK_ERR;
749 }695 }
750 SOFTBUS_DPRINTF(fd, "\n---------------CoapSubscribeInfo------------------\n");696 SOFTBUS_DPRINTF(fd, "\n---------------CoapSubscribeInfo------------------\n");
751- SOFTBUS_DPRINTF(fd, "subscribe allCap : %u\n", *(g_subscribeMgr->allCap));697+ SOFTBUS_DPRINTF(fd, "subscribe allCap : %u\n", *(g_discCoapMgr.subscribeInfo.allCap));
752- SOFTBUS_DPRINTF(fd, "subscribe capCount : %hd\n", *(g_subscribeMgr->capCount));698+ SOFTBUS_DPRINTF(fd, "subscribe capCount : %hd\n", *(g_discCoapMgr.subscribeInfo.capCount));
753- SOFTBUS_DPRINTF(fd, "subscribe isUpdate : %d\n", g_subscribeMgr->isUpdate);699+ SOFTBUS_DPRINTF(fd, "subscribe isUpdate : %d\n", g_discCoapMgr.subscribeInfo.isUpdate);
754- SOFTBUS_DPRINTF(fd, "subscribe isEmpty : %d\n", g_subscribeMgr->isEmpty);700+ SOFTBUS_DPRINTF(fd, "subscribe isEmpty : %d\n", g_discCoapMgr.subscribeInfo.isEmpty);
755- (void)SoftBusMutexUnlock(&(g_subscribeMgr->lock));701+ (void)SoftBusMutexUnlock(&(g_discCoapMgr.lock));
756 return SOFTBUS_OK;702 return SOFTBUS_OK;
757}703}
Mtests/core/discovery/coap/unittest/disc_coap_test.cpp+8-8
@@ -116,9 +116,9 @@ HWTEST_F(DiscCoapTest, CoapPublish002, TestSize.Level1)
116 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);116 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
117 EXPECT_EQ(tmp, nullptr);117 EXPECT_EQ(tmp, nullptr);
118 int32_t ret = g_discCoapFuncInterface->Publish(&g_testPubOption);118 int32_t ret = g_discCoapFuncInterface->Publish(&g_testPubOption);
119- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);119+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
120 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);120 ret = g_discCoapFuncInterface->Unpublish(&g_testPubOption);
121- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);121+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
122 122 
123 DiscCoapDeinit();123 DiscCoapDeinit();
124 g_discCoapFuncInterface = nullptr;124 g_discCoapFuncInterface = nullptr;
@@ -248,9 +248,9 @@ HWTEST_F(DiscCoapTest, CoapStartScan002, TestSize.Level1)
248 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);248 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
249 EXPECT_EQ(tmp, nullptr);249 EXPECT_EQ(tmp, nullptr);
250 int32_t ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);250 int32_t ret = g_discCoapFuncInterface->StartScan(&g_testPubOption);
251- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);251+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
252 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);252 ret = g_discCoapFuncInterface->StopScan(&g_testPubOption);
253- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);253+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
254 254 
255 DiscCoapDeinit();255 DiscCoapDeinit();
256 g_discCoapFuncInterface = nullptr;256 g_discCoapFuncInterface = nullptr;
@@ -339,9 +339,9 @@ HWTEST_F(DiscCoapTest, CoapStartAdvertise002, TestSize.Level1)
339 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);339 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
340 EXPECT_EQ(tmp, nullptr);340 EXPECT_EQ(tmp, nullptr);
341 int32_t ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);341 int32_t ret = g_discCoapFuncInterface->StartAdvertise(&g_testSubOption);
342- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);342+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
343 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);343 ret = g_discCoapFuncInterface->StopAdvertise(&g_testSubOption);
344- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);344+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
345 345 
346 DiscCoapDeinit();346 DiscCoapDeinit();
347 g_discCoapFuncInterface = nullptr;347 g_discCoapFuncInterface = nullptr;
@@ -466,9 +466,9 @@ HWTEST_F(DiscCoapTest, CoapSubscribe002, TestSize.Level1)
466 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);466 DiscoveryFuncInterface *tmp = DiscCoapInit(nullptr);
467 EXPECT_EQ(tmp, nullptr);467 EXPECT_EQ(tmp, nullptr);
468 int32_t ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);468 int32_t ret = g_discCoapFuncInterface->Subscribe(&g_testSubOption);
469- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);469+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
470 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);470 ret = g_discCoapFuncInterface->Unsubscribe(&g_testSubOption);
471- EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);471+ EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
472 472 
473 DiscCoapDeinit();473 DiscCoapDeinit();
474 g_discCoapFuncInterface = nullptr;474 g_discCoapFuncInterface = nullptr;