l1-disc_add_custom_field-communication

Madapter/feature_config/public_feature/public_feature.gni+1-0

	@@ -19,6 +19,7 @@ declare_args() {
19	dsoftbus_feature_disc_usb = true	19	dsoftbus_feature_disc_usb = true
20	dsoftbus_feature_disc_nfc = true	20	dsoftbus_feature_disc_nfc = true
21	dsoftbus_feature_disc_virlink = true	21	dsoftbus_feature_disc_virlink = true
		22	+ dsoftbus_feature_disc_coap_custdata = false
22		23
23	dsoftbus_feature_conn_tcp_proxy = true	24	dsoftbus_feature_conn_tcp_proxy = true
24	dsoftbus_feature_conn_tcp_comm = true	25	dsoftbus_feature_conn_tcp_comm = true

Mcore/bus_center/ipc/small/src/bus_center_client_proxy.c+6-4

	@@ -323,10 +323,12 @@ int32_t ClientOnRefreshDeviceFound(const char *pkgName, int32_t pid, const void
323	return SOFTBUS_INVALID_PARAM;	323	return SOFTBUS_INVALID_PARAM;
324	}	324	}
325	IpcIo io;	325	IpcIo io;
326	- uint8_t tmpData[MAX_SOFT_BUS_IPC_LEN_EX];	326	+ uint8_t tmpData[sizeof(DeviceInfo) + sizeof(uint32_t)];
327	- IpcIoInit(&io, tmpData, MAX_SOFT_BUS_IPC_LEN_EX, 0);	327	+ IpcIoInit(&io, tmpData, sizeof(tmpData), 0);
328	- WriteUint32(&io, deviceLen);	328	+ if (!WriteUint32(&io, deviceLen) \|\| !WriteBuffer(&io, device, deviceLen)) {
329	- WriteBuffer(&io, device, deviceLen);	329	+ LNN_LOGE(LNN_EVENT, "write device info failed, deviceLen=%{public}u", deviceLen);
		330	+ return SOFTBUS_NETWORK_PACK_DATA_FAILED;
		331	+ }
330	SvcIdentity svc = {0};	332	SvcIdentity svc = {0};
331	if (GetSvcIdentityByPkgName(pkgName, &svc) != SOFTBUS_OK) {	333	if (GetSvcIdentityByPkgName(pkgName, &svc) != SOFTBUS_OK) {
332	LNN_LOGE(LNN_EVENT, "get svc failed");	334	LNN_LOGE(LNN_EVENT, "get svc failed");

Mcore/discovery/coap/common/include/disc_coap_parser.h+4-0

	@@ -33,6 +33,10 @@ void DiscCoapParseHwAccountHash(const cJSON data, DeviceInfo device);
33	void DiscCoapParseNickname(const cJSON data, char nickName, int32_t length);	33	void DiscCoapParseNickname(const cJSON data, char nickName, int32_t length);
34	int32_t DiscCoapParseKeyValueStr(const char src, const char key, char *outValue, uint32_t outLen);	34	int32_t DiscCoapParseKeyValueStr(const char src, const char key, char *outValue, uint32_t outLen);
35		35
		36	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		37	+void DiscCoapParseCustData(const cJSON data, DeviceInfo device);
		38	+#endif
		39	+
36	#ifdef __cplusplus	40	#ifdef __cplusplus
37	}	41	}
38	#endif /* __cplusplus */	42	#endif /* __cplusplus */

Mcore/discovery/coap/common/src/disc_coap_parser.c+22-1

	@@ -168,4 +168,25 @@ void DiscCoapParseNickname(const cJSON data, char nickName, int32_t length)
168	return;	168	return;
169	}	169	}
170	cJSON_Delete(bDataInfo);	170	cJSON_Delete(bDataInfo);
171	-}	171	+}
		172	+
		173	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		174	+#define JSON_KEY_CUST_DATA "custData"
		175	+
		176	+void DiscCoapParseCustData(const cJSON data, DeviceInfo device)
		177	+{
		178	+ DISC_CHECK_AND_RETURN_LOGE(data != NULL, DISC_COAP, "json data is NULL");
		179	+ DISC_CHECK_AND_RETURN_LOGE(device != NULL, DISC_COAP, "device info is NULL");
		180	+ char bData[MAX_BDATA_LEN] = {0};
		181	+ if (!GetJsonObjectStringItem(data, JSON_KEY_BDATA, bData, MAX_BDATA_LEN)) {
		182	+ DISC_LOGD(DISC_COAP, "parse bData fail, skip custData");
		183	+ return;
		184	+ }
		185	+ cJSON *bDataInfo = cJSON_Parse(bData);
		186	+ DISC_CHECK_AND_RETURN_LOGE(bDataInfo != NULL, DISC_COAP, "parse bData json fail");
		187	+ if (!GetJsonObjectStringItem(bDataInfo, JSON_KEY_CUST_DATA, device->custData, DISC_MAX_CUST_DATA_LEN)) {
		188	+ DISC_LOGD(DISC_COAP, "no custData in bData, skip");
		189	+ }
		190	+ cJSON_Delete(bDataInfo);
		191	+}
		192	+#endif

Mcore/discovery/coap/nstackx_coap/include/disc_nstackx_adapter.h+4-0

	@@ -43,6 +43,10 @@ typedef struct {
43	DiscCoapMode mode;	43	DiscCoapMode mode;
44	uint32_t capability;	44	uint32_t capability;
45	uint32_t allCap;	45	uint32_t allCap;
		46	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		47	+ const unsigned char *capabilityData;
		48	+ uint32_t dataLen;
		49	+#endif
46	} DiscCoapOption;	50	} DiscCoapOption;
47		51
48	int32_t DiscNstackxInit(void);	52	int32_t DiscNstackxInit(void);

Mcore/discovery/coap/nstackx_coap/src/disc_coap.c+4-0

	@@ -119,6 +119,10 @@ static void SetDiscCoapOption(DiscCoapOption discCoapOption, DiscOption option
119	discCoapOption->mode = ACTIVE_PUBLISH;	119	discCoapOption->mode = ACTIVE_PUBLISH;
120	discCoapOption->freq = option->option.publishOption.freq;	120	discCoapOption->freq = option->option.publishOption.freq;
121	discCoapOption->capability = option->option.publishOption.capabilityBitmap[0];	121	discCoapOption->capability = option->option.publishOption.capabilityBitmap[0];
		122	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		123	+ discCoapOption->capabilityData = option->option.publishOption.capabilityData;
		124	+ discCoapOption->dataLen = option->option.publishOption.dataLen;
		125	+#endif
122	} else {	126	} else {
123	discCoapOption->mode = ACTIVE_DISCOVERY;	127	discCoapOption->mode = ACTIVE_DISCOVERY;
124	discCoapOption->freq = option->option.subscribeOption.freq;	128	discCoapOption->freq = option->option.subscribeOption.freq;

Mcore/discovery/coap/nstackx_coap/src/disc_coap_capability.c+50-1

	@@ -16,9 +16,12 @@
16	#include "disc_coap_capability_public.h"	16	#include "disc_coap_capability_public.h"
17		17
18	#include "anonymizer.h"	18	#include "anonymizer.h"
		19	+#include "cJSON.h"
19	#include "disc_log.h"	20	#include "disc_log.h"
20	#include "disc_nstackx_adapter.h"	21	#include "disc_nstackx_adapter.h"
		22	+#include "securec.h"
21	#include "softbus_error_code.h"	23	#include "softbus_error_code.h"
		24	+#include "softbus_utils.h"
22		25
23	int32_t DiscCoapAssembleCapData(uint32_t capability, const char capabilityData, uint32_t dataLen, char outData,	26	int32_t DiscCoapAssembleCapData(uint32_t capability, const char capabilityData, uint32_t dataLen, char outData,
24	uint32_t outLen)	27	uint32_t outLen)
	@@ -117,4 +120,50 @@ int32_t DiscCoapProcessDeviceInfo(const NSTACKX_DeviceInfo *nstackxInfo, DeviceI
117	return SOFTBUS_DISCOVER_COAP_SEND_RSP_FAIL;	120	return SOFTBUS_DISCOVER_COAP_SEND_RSP_FAIL;
118	}	121	}
119	return SOFTBUS_OK;	122	return SOFTBUS_OK;
120	-}	123	+}
		124	+
		125	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		126	+int32_t DiscCoapAssembleBdata(const unsigned char *capabilityData, uint32_t dataLen,
		127	+ char *businessData, uint32_t businessDataLen)
		128	+{
		129	+ cJSON *json = cJSON_CreateObject();
		130	+ DISC_CHECK_AND_RETURN_RET_LOGE(json != NULL, SOFTBUS_MALLOC_ERR, DISC_COAP, "create json fail");
		131	+
		132	+ char custDataStr = (char )SoftBusCalloc(dataLen + 1);
		133	+ if (custDataStr == NULL) {
		134	+ cJSON_Delete(json);
		135	+ DISC_LOGE(DISC_COAP, "malloc custDataStr fail");
		136	+ return SOFTBUS_MALLOC_ERR;
		137	+ }
		138	+ if (memcpy_s(custDataStr, dataLen + 1, capabilityData, dataLen) != EOK) {
		139	+ SoftBusFree(custDataStr);
		140	+ cJSON_Delete(json);
		141	+ DISC_LOGE(DISC_COAP, "copy capabilityData fail");
		142	+ return SOFTBUS_MEM_ERR;
		143	+ }
		144	+ cJSON_AddStringToObject(json, "custData", custDataStr);
		145	+ SoftBusFree(custDataStr);
		146	+
		147	+ char *jsonStr = cJSON_PrintUnformatted(json);
		148	+ cJSON_Delete(json);
		149	+ if (jsonStr == NULL) {
		150	+ DISC_LOGE(DISC_COAP, "print json fail");
		151	+ return SOFTBUS_MALLOC_ERR;
		152	+ }
		153	+
		154	+ if (strlen(jsonStr) >= businessDataLen - 1) {
		155	+ DISC_LOGE(DISC_COAP, "custData too long for businessData channel, dataLen=%{public}u", dataLen);
		156	+ cJSON_free(jsonStr);
		157	+ DISC_LOGE(DISC_COAP, "copy businessData fail");
		158	+ return SOFTBUS_DISCOVER_COAP_ASSEMBLE_BDATA_FAIL;
		159	+ }
		160	+
		161	+ if (strcpy_s(businessData, businessDataLen, jsonStr) != EOK) {
		162	+ cJSON_free(jsonStr);
		163	+ return SOFTBUS_STRCPY_ERR;
		164	+ }
		165	+
		166	+ cJSON_free(jsonStr);
		167	+ return SOFTBUS_OK;
		168	+}
		169	+#endif

Mcore/discovery/coap/nstackx_coap/src/disc_nstackx_adapter.c+69-2

	@@ -68,6 +68,10 @@ static SoftBusMutex g_discCoapInnerCbLock = {0};
68	static int32_t NstackxLocalDevInfoDump(int fd);	68	static int32_t NstackxLocalDevInfoDump(int fd);
69	static int32_t g_currentLinkUpNums = 0;	69	static int32_t g_currentLinkUpNums = 0;
70	static char g_serviceData[NSTACKX_MAX_SERVICE_DATA_LEN] = {0};	70	static char g_serviceData[NSTACKX_MAX_SERVICE_DATA_LEN] = {0};
		71	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		72	+ static char g_cachedBData[NSTACKX_MAX_BUSINESS_DATA_LEN] = {0};
		73	+ static uint32_t g_cachedBDataLen = 0;
		74	+#endif
71		75
72	typedef struct {	76	typedef struct {
73	char netWorkName[NSTACKX_MAX_INTERFACE_NAME_LEN];	77	char netWorkName[NSTACKX_MAX_INTERFACE_NAME_LEN];
	@@ -80,12 +84,35 @@ static DiscLinkInfo g_linkInfo[MAX_IF + 1] = {
80	};	84	};
81		85
82	#if defined(DSOFTBUS_FEATURE_DISC_LNN_COAP) \|\| defined(DSOFTBUS_FEATURE_DISC_SHARE_COAP)	86	#if defined(DSOFTBUS_FEATURE_DISC_LNN_COAP) \|\| defined(DSOFTBUS_FEATURE_DISC_SHARE_COAP)
		87	+static void FillRspBusinessData(NSTACKX_ResponseSettings *settings)
		88	+{
		89	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		90	+ if (g_cachedBDataLen > 0) {
		91	+ settings->businessData = (char *)SoftBusCalloc(g_cachedBDataLen);
		92	+ if (settings->businessData != NULL &&
		93	+ strcpy_s(settings->businessData, g_cachedBDataLen, g_cachedBData) == EOK) {
		94	+ settings->length = g_cachedBDataLen;
		95	+ } else {
		96	+ SoftBusFree(settings->businessData);
		97	+ settings->businessData = NULL;
		98	+ settings->length = 0;
		99	+ DISC_LOGE(DISC_COAP, "fill rsp businessData fail, fallback to empty");
		100	+ }
		101	+ } else {
		102	+ settings->businessData = NULL;
		103	+ settings->length = 0;
		104	+ }
		105	+#else
		106	+ settings->businessData = NULL;
		107	+ settings->length = 0;
		108	+#endif
		109	+}
		110	+
83	static int32_t FillRspSettings(NSTACKX_ResponseSettings *settings,	111	static int32_t FillRspSettings(NSTACKX_ResponseSettings *settings,
84	const DeviceInfo *deviceInfo, uint8_t bType, bool isRemoveShareCap)	112	const DeviceInfo *deviceInfo, uint8_t bType, bool isRemoveShareCap)
85	{	113	{
86	- settings->businessData = NULL;
87	- settings->length = 0;
88	settings->businessType = bType;	114	settings->businessType = bType;
		115	+ FillRspBusinessData(settings);
89		116
90	char localNetifName[NSTACKX_MAX_INTERFACE_NAME_LEN] = {0};	117	char localNetifName[NSTACKX_MAX_INTERFACE_NAME_LEN] = {0};
91	if (g_linkInfo[USB_IF].status == LINK_STATUS_UP && strlen(deviceInfo->addr[0].info.ip.ip) > IPV4_MAX_LEN) {	118	if (g_linkInfo[USB_IF].status == LINK_STATUS_UP && strlen(deviceInfo->addr[0].info.ip.ip) > IPV4_MAX_LEN) {
	@@ -116,6 +143,9 @@ static int32_t FillRspSettings(NSTACKX_ResponseSettings *settings,
116	SOFTBUS_STRCPY_ERR, DISC_COAP, "copy capBitMap fail");	143	SOFTBUS_STRCPY_ERR, DISC_COAP, "copy capBitMap fail");
117	return SOFTBUS_OK;	144	return SOFTBUS_OK;
118	EXIT:	145	EXIT:
		146	+ SoftBusFree(settings->businessData);
		147	+ settings->businessData = NULL;
		148	+ settings->length = 0;
119	return SOFTBUS_STRCPY_ERR;	149	return SOFTBUS_STRCPY_ERR;
120	}	150	}
121	#endif /* DSOFTBUS_FEATURE_DISC_LNN_COAP \|\| DSOFTBUS_FEATURE_DISC_SHARE_COAP */	151	#endif /* DSOFTBUS_FEATURE_DISC_LNN_COAP \|\| DSOFTBUS_FEATURE_DISC_SHARE_COAP */
	@@ -130,6 +160,7 @@ int32_t DiscCoapSendRsp(const DeviceInfo *deviceInfo, uint8_t bType, bool isRemo
130	int32_t ret = FillRspSettings(settings, deviceInfo, bType, isRemoveShareCap);	160	int32_t ret = FillRspSettings(settings, deviceInfo, bType, isRemoveShareCap);
131	if (ret != SOFTBUS_OK) {	161	if (ret != SOFTBUS_OK) {
132	DISC_LOGE(DISC_COAP, "fill nstackx response settings fail");	162	DISC_LOGE(DISC_COAP, "fill nstackx response settings fail");
		163	+ SoftBusFree(settings->businessData);
133	SoftBusFree(settings);	164	SoftBusFree(settings);
134	return ret;	165	return ret;
135	}	166	}
	@@ -139,6 +170,7 @@ int32_t DiscCoapSendRsp(const DeviceInfo *deviceInfo, uint8_t bType, bool isRemo
139	if (ret != SOFTBUS_OK) {	170	if (ret != SOFTBUS_OK) {
140	DISC_LOGE(DISC_COAP, "disc send response fail, ret=%{public}d", ret);	171	DISC_LOGE(DISC_COAP, "disc send response fail, ret=%{public}d", ret);
141	}	172	}
		173	+ SoftBusFree(settings->businessData);
142	SoftBusFree(settings);	174	SoftBusFree(settings);
143	return ret;	175	return ret;
144	#else	176	#else
	@@ -155,6 +187,9 @@ static int32_t ParseReservedInfo(const NSTACKX_DeviceInfo *nstackxDevice, Device
155	DiscCoapParseWifiIpAddr(reserveInfo, device);	187	DiscCoapParseWifiIpAddr(reserveInfo, device);
156	DiscCoapParseHwAccountHash(reserveInfo, device);	188	DiscCoapParseHwAccountHash(reserveInfo, device);
157	DiscCoapParseNickname(reserveInfo, nickName, DISC_MAX_NICKNAME_LEN);	189	DiscCoapParseNickname(reserveInfo, nickName, DISC_MAX_NICKNAME_LEN);
		190	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		191	+ DiscCoapParseCustData(reserveInfo, device);
		192	+#endif
158	if (DiscCoapParseServiceData(reserveInfo, device) != SOFTBUS_OK) {	193	if (DiscCoapParseServiceData(reserveInfo, device) != SOFTBUS_OK) {
159	DISC_LOGD(DISC_COAP, "parse service data fail");	194	DISC_LOGD(DISC_COAP, "parse service data fail");
160	}	195	}
	@@ -427,6 +462,15 @@ int32_t DiscCoapRegisterBusinessData(const unsigned char *capabilityData, uint32
427	DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_COAP, "assemble bdata fail, ret=%{public}d", ret);	462	DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_COAP, "assemble bdata fail, ret=%{public}d", ret);
428	ret = NSTACKX_RegisterBusinessData(businessData);	463	ret = NSTACKX_RegisterBusinessData(businessData);
429	DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_COAP, "register bdata fail, ret=%{public}d", ret);	464	DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_COAP, "register bdata fail, ret=%{public}d", ret);
		465	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		466	+ if (strcpy_s(g_cachedBData, sizeof(g_cachedBData), businessData) == EOK) {
		467	+ g_cachedBDataLen = strlen(businessData) + 1;
		468	+ DISC_LOGI(DISC_COAP, "cache bData successful");
		469	+ } else {
		470	+ g_cachedBDataLen = 0;
		471	+ DISC_LOGE(DISC_COAP, "cache bData fail");
		472	+ }
		473	+#endif
430	return SOFTBUS_OK;	474	return SOFTBUS_OK;
431	}	475	}
432		476
	@@ -489,6 +533,29 @@ static int32_t ConvertDiscoverySettings(NSTACKX_DiscoverySettings *discSet, cons
489	discSet->advertiseDuration = (discFreq >> DISC_FREQ_DURATION_BIT) * DISC_USECOND;	533	discSet->advertiseDuration = (discFreq >> DISC_FREQ_DURATION_BIT) * DISC_USECOND;
490	ret = DiscFillBtypePacked(option->capability, option->allCap, discSet);	534	ret = DiscFillBtypePacked(option->capability, option->allCap, discSet);
491	DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_COAP, "unsupport capability");	535	DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_COAP, "unsupport capability");
		536	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		537	+ if (option->mode == ACTIVE_PUBLISH && option->capabilityData != NULL && option->dataLen > 0) {
		538	+ char bData[NSTACKX_MAX_BUSINESS_DATA_LEN] = { 0 };
		539	+ int32_t bRet = DiscCoapAssembleBdataPacked(option->capabilityData, option->dataLen, bData, sizeof(bData));
		540	+ if (bRet != SOFTBUS_OK) {
		541	+ DISC_LOGE(DISC_COAP, "assemble bdata for broadcast fail, ret=%{public}d", bRet);
		542	+ return bRet;
		543	+ }
		544	+ size_t bDataLen = strlen(bData);
		545	+ if (bDataLen > 0) {
		546	+ discSet->businessData = (char *)SoftBusCalloc(bDataLen + 1);
		547	+ DISC_CHECK_AND_RETURN_RET_LOGE(discSet->businessData != NULL, SOFTBUS_MALLOC_ERR, DISC_COAP,
		548	+ "malloc businessData fail");
		549	+ if (strcpy_s(discSet->businessData, bDataLen + 1, bData) != EOK) {
		550	+ SoftBusFree(discSet->businessData);
		551	+ discSet->businessData = NULL;
		552	+ DISC_LOGE(DISC_COAP, "copy businessData fail");
		553	+ return SOFTBUS_STRCPY_ERR;
		554	+ }
		555	+ discSet->length = bDataLen + 1;
		556	+ }
		557	+ }
		558	+#endif
492	return SOFTBUS_OK;	559	return SOFTBUS_OK;
493	}	560	}
494		561

Mcore/frame/init/src/g_enhance_disc_func_pack.c+4-0

	@@ -104,10 +104,14 @@ int32_t DiscCoapProcessDeviceInfoPacked(const NSTACKX_DeviceInfo *nstackxInfo, D
104	int32_t DiscCoapAssembleBdataPacked(const unsigned char capabilityData, uint32_t dataLen, char businessData,	104	int32_t DiscCoapAssembleBdataPacked(const unsigned char capabilityData, uint32_t dataLen, char businessData,
105	uint32_t businessDataLen)	105	uint32_t businessDataLen)
106	{	106	{
		107	+#ifdef DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA
		108	+ return DiscCoapAssembleBdata(capabilityData, dataLen, businessData, businessDataLen);
		109	+#else
107	DiscEnhanceFuncList *pfnDiscEnhanceFuncList = DiscEnhanceFuncListGet();	110	DiscEnhanceFuncList *pfnDiscEnhanceFuncList = DiscEnhanceFuncListGet();
108	int32_t ret = DiscCheckFuncPointer((void *)pfnDiscEnhanceFuncList->discCoapAssembleBdata);	111	int32_t ret = DiscCheckFuncPointer((void *)pfnDiscEnhanceFuncList->discCoapAssembleBdata);
109	DISC_CHECK_AND_RETURN_RET_LOGD(ret == SOFTBUS_OK, SOFTBUS_OK, DISC_COAP, "not find DiscCoapAssembleBdata");	112	DISC_CHECK_AND_RETURN_RET_LOGD(ret == SOFTBUS_OK, SOFTBUS_OK, DISC_COAP, "not find DiscCoapAssembleBdata");
110	return pfnDiscEnhanceFuncList->discCoapAssembleBdata(capabilityData, dataLen, businessData, businessDataLen);	113	return pfnDiscEnhanceFuncList->discCoapAssembleBdata(capabilityData, dataLen, businessData, businessDataLen);
		114	+#endif
111	}	115	}
112		116
113	#ifdef DSOFTBUS_FEATURE_DISC_SHARE_COAP	117	#ifdef DSOFTBUS_FEATURE_DISC_SHARE_COAP

Mdsoftbus.gni+4-0

	@@ -130,6 +130,10 @@ if (dsoftbus_feature_disc_coap && dsoftbus_feature_inner_disc_coap) {
130	defines += [ "DSOFTBUS_FEATURE_DISC_COAP" ]	130	defines += [ "DSOFTBUS_FEATURE_DISC_COAP" ]
131	}	131	}
132		132
		133	+if (dsoftbus_feature_disc_coap_custdata && dsoftbus_feature_inner_disc_coap) {
		134	+ defines += [ "DSOFTBUS_FEATURE_DISC_COAP_CUSTDATA"]
		135	+}
		136	+
133	if (dsoftbus_feature_disc_lnn_coap && dsoftbus_feature_inner_disc_coap) {	137	if (dsoftbus_feature_disc_lnn_coap && dsoftbus_feature_inner_disc_coap) {
134	defines += [ "DSOFTBUS_FEATURE_DISC_LNN_COAP" ]	138	defines += [ "DSOFTBUS_FEATURE_DISC_LNN_COAP" ]
135	}	139	}

Minterfaces/kits/common/softbus_error_code.h+1-0

	@@ -1644,6 +1644,7 @@ enum SoftBusErrNo {
1644	SOFTBUS_DISCOVER_COAP_PARSE_DATA_FAIL,	1644	SOFTBUS_DISCOVER_COAP_PARSE_DATA_FAIL,
1645	SOFTBUS_DISCOVER_COAP_REGISTER_CAP_DATA_FAIL,	1645	SOFTBUS_DISCOVER_COAP_REGISTER_CAP_DATA_FAIL,
1646	SOFTBUS_DISCOVER_COAP_GET_DEVICE_INFO_FAIL,	1646	SOFTBUS_DISCOVER_COAP_GET_DEVICE_INFO_FAIL,
		1647	+ SOFTBUS_DISCOVER_COAP_ASSEMBLE_BDATA_FAIL,
1647	/* errno begin: -((203 << 21) \| (1 << 16) \| (5 << 12) \| 0x0FFF) */	1648	/* errno begin: -((203 << 21) \| (1 << 16) \| (5 << 12) \| 0x0FFF) */
1648	SOFTBUS_DISCOVER_BC_MGR_ERR_BASE = SOFTBUS_SUB_ERRNO(DISC_SUB_MODULE_CODE, DISC_BC_MGR_SUB_MODULE_CODE),	1649	SOFTBUS_DISCOVER_BC_MGR_ERR_BASE = SOFTBUS_SUB_ERRNO(DISC_SUB_MODULE_CODE, DISC_BC_MGR_SUB_MODULE_CODE),
1649	SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, // no medium has registered	1650	SOFTBUS_BC_MGR_NO_FUNC_REGISTERED, // no medium has registered