统一互联3.0 WiFi Only：完善设备SoftAP设备信息与安全配置-communication_iot

Madapter/socket/iotc_socket.c+31-2

	@@ -27,6 +27,9 @@
27	#include "lwip/inet.h"	27	#include "lwip/inet.h"
28	#include "lwip/igmp.h"	28	#include "lwip/igmp.h"
29	#include "lwip/sockets.h"	29	#include "lwip/sockets.h"
		30	+#define IOTC_FCNTL lwip_fcntl
		31	+#else
		32	+#define IOTC_FCNTL fcntl
30	#endif	33	#endif
31		34
32	#ifdef __MINGW32__	35	#ifdef __MINGW32__
	@@ -44,6 +47,14 @@
44	#include <fcntl.h>	47	#include <fcntl.h>
45	#endif	48	#endif
46		49
		50	+#if IOTC_CONF_ADAPTER_SOCKET_LWIP_FDS
		51	+#define IOTC_LWIP_SOCKET_FD_BASE 256
		52	+#undef lwip_select
		53	+extern int32_t lwip_select(int32_t maxfdp1, fd_set readset, fd_set writeset, fd_set *exceptset,
		54	+ struct timeval *timeout);
		55	+extern int32_t closesocket(int32_t fd);
		56	+#endif
		57	+
47		58
48	#ifndef ARRAY_SIZE	59	#ifndef ARRAY_SIZE
49	#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))	60	#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
	@@ -264,7 +275,15 @@ int32_t IotcSocket(IotcSocketDomain domain, IotcSocketType type, IotcSocketProto
264		275
265	void IotcClose(int32_t fd)	276	void IotcClose(int32_t fd)
266	{	277	{
		278	+#if IOTC_CONF_ADAPTER_SOCKET_LWIP_FDS
		279	+ if (fd >= IOTC_LWIP_SOCKET_FD_BASE) {
		280	+ (void)closesocket(fd);
		281	+ } else {
		282	+ (void)close(fd);
		283	+ }
		284	+#else
267	(void)close(fd);	285	(void)close(fd);
		286	+#endif
268	return;	287	return;
269	}	288	}
270		289
	@@ -285,7 +304,7 @@ static int32_t SetFcntl(int32_t fd, bool isBlock)
285	}	304	}
286	return IOTC_OK;	305	return IOTC_OK;
287	#else	306	#else
288	- int32_t flags = fcntl(fd, F_GETFL, 0);	307	+ int32_t flags = IOTC_FCNTL(fd, F_GETFL, 0);
289	if (flags < 0) {	308	if (flags < 0) {
290	IOTC_LOGE("fcntl get failed, ret %d", flags);	309	IOTC_LOGE("fcntl get failed, ret %d", flags);
291	return IOTC_ADAPTER_SOCKET_ERR_FCNTL;	310	return IOTC_ADAPTER_SOCKET_ERR_FCNTL;
	@@ -295,7 +314,7 @@ static int32_t SetFcntl(int32_t fd, bool isBlock)
295	} else {	314	} else {
296	flags \|= O_NONBLOCK;	315	flags \|= O_NONBLOCK;
297	}	316	}
298	- if (fcntl(fd, F_SETFL, flags) < 0) {	317	+ if (IOTC_FCNTL(fd, F_SETFL, flags) < 0) {
299	IOTC_LOGE("fcntl set failed");	318	IOTC_LOGE("fcntl set failed");
300	return IOTC_ADAPTER_SOCKET_ERR_FCNTL;	319	return IOTC_ADAPTER_SOCKET_ERR_FCNTL;
301	}	320	}
	@@ -654,9 +673,19 @@ int32_t IotcSelect(IotcFdSet readSet, IotcFdSet writeSet, IotcFdSet *exceptSet
654	struct timeval timeout;	673	struct timeval timeout;
655	timeout.tv_sec = ms / MS_PER_SEC;	674	timeout.tv_sec = ms / MS_PER_SEC;
656	timeout.tv_usec = ms % MS_PER_SEC * US_PER_MS;	675	timeout.tv_usec = ms % MS_PER_SEC * US_PER_MS;
		676	+#if IOTC_CONF_ADAPTER_SOCKET_LWIP_FDS
		677	+ int32_t ret = (maxFd >= IOTC_LWIP_SOCKET_FD_BASE) ?
		678	+ lwip_select(maxFd + 1, (readSet == NULL) ? NULL : &read,
		679	+ (writeSet == NULL) ? NULL : &write,
		680	+ (exceptSet == NULL) ? NULL : &except, &timeout) :
		681	+ select(maxFd + 1, (readSet == NULL) ? NULL : &read,
		682	+ (writeSet == NULL) ? NULL : &write,
		683	+ (exceptSet == NULL) ? NULL : &except, &timeout);
		684	+#else
657	int32_t ret = select(maxFd + 1, (readSet == NULL) ? NULL : &read,	685	int32_t ret = select(maxFd + 1, (readSet == NULL) ? NULL : &read,
658	(writeSet == NULL) ? NULL : &write,	686	(writeSet == NULL) ? NULL : &write,
659	(exceptSet == NULL) ? NULL : &except, &timeout);	687	(exceptSet == NULL) ? NULL : &except, &timeout);
		688	+#endif
660	if (ret <= 0) {	689	if (ret <= 0) {
661	return ret;	690	return ret;
662	}	691	}

Mcore/infrastructure/utils/utils_json.c+2-2

	@@ -74,7 +74,7 @@ int32_t UtilsJsonGetNum(const IotcJson json, const char name, int32_t *num)
74	if (ret != IOTC_OK) {	74	if (ret != IOTC_OK) {
75	return ret;	75	return ret;
76	}	76	}
77	- if (err > INT32_MAX) {	77	+ if (err > INT32_MAX \|\| err < INT32_MIN) {
78	IOTC_LOGW("invalid num");	78	IOTC_LOGW("invalid num");
79	return IOTC_CORE_COMM_UTILS_ERR_JSON_INVALID_ERRCODE;	79	return IOTC_CORE_COMM_UTILS_ERR_JSON_INVALID_ERRCODE;
80	}	80	}
	@@ -236,4 +236,4 @@ int32_t UtilsGenKeyIntValueJsonStr(const char key, int32_t value, char *out, u
236	outLen = strlen(out);	236	outLen = strlen(out);
237		237
238	return IOTC_OK;	238	return IOTC_OK;
239	-}	239	+}

Mcore/security/config/include/sec_conf_info.h+2-0

	@@ -72,6 +72,8 @@ int32_t SecConfInfoSet(SecConfInfoKey key, const uint8_t *buf, uint32_t len);
72	int32_t SecConfInfoClear(SecConfInfoKey key);	72	int32_t SecConfInfoClear(SecConfInfoKey key);
73	int32_t SecConfInfoSave(void);	73	int32_t SecConfInfoSave(void);
74		74
		75	+int32_t SecConfInfoFactoryReset(void);
		76	+
75	#ifdef __cplusplus	77	#ifdef __cplusplus
76	}	78	}
77	#endif	79	#endif

Mcore/security/config/include/sec_conf_key_cert.h+2-0

	@@ -30,6 +30,8 @@ int32_t SecConfSetKeyCert(const SecKeyCert *keyCert);
30		30
31	int32_t SecConfSaveKeyCert(void);	31	int32_t SecConfSaveKeyCert(void);
32		32
		33	+int32_t SecConfKeyCertFactoryReset(void);
		34	+
33	const SecKeyCert *SecConfGetKeyCert(void);	35	const SecKeyCert *SecConfGetKeyCert(void);
34		36
35	#ifdef __cplusplus	37	#ifdef __cplusplus

Mcore/security/config/include/sec_conf_provision_data.h+1-1

	@@ -26,7 +26,7 @@ extern "C" {
26		26
27	bool SecConfCheckProvisionData(const IotcProvisionData *provision);	27	bool SecConfCheckProvisionData(const IotcProvisionData *provision);
28		28
29	-char *SecConfReadRawProvisionData();	29	+char *SecConfReadRawProvisionData(void);
30		30
31	int32_t SecConfWriteRawProvisionData(const char *provisionData);	31	int32_t SecConfWriteRawProvisionData(const char *provisionData);
32		32

Mcore/security/config/sec_conf_info.c+6-0

	@@ -170,3 +170,9 @@ int32_t SecConfInfoSave(void)
170	g_storeItem[0].len = sizeof(SecConfInfoV1Padd);	170	g_storeItem[0].len = sizeof(SecConfInfoV1Padd);
171	return SecurityStoreCommit(IOTC_STORE_KEY_INT_SECURITY_CONFIG);	171	return SecurityStoreCommit(IOTC_STORE_KEY_INT_SECURITY_CONFIG);
172	}	172	}
		173	+
		174	+int32_t SecConfInfoFactoryReset(void)
		175	+{
		176	+ (void)memset_s(&g_secConfInfoPadd, sizeof(g_secConfInfoPadd), 0, sizeof(g_secConfInfoPadd));
		177	+ return SecurityStoreDel(IOTC_STORE_KEY_INT_SECURITY_CONFIG);
		178	+}

Mcore/security/config/sec_conf_key_cert.c+14-1

	@@ -108,6 +108,7 @@ static void ResetKeyCert(SecKeyCert *keyCert)
108	};	108	};
109	for (uint32_t i = 0; i < ARRAY_SIZE(items); ++i) {	109	for (uint32_t i = 0; i < ARRAY_SIZE(items); ++i) {
110	if (items[i] != NULL && strlen(items[i]) > 0) {	110	if (items[i] != NULL && strlen(items[i]) > 0) {
		111	+ (void)memset_s((void )items[i], strlen(items[i]), 0, strlen(items[i]));
111	IotcFree((void )items[i]);	112	IotcFree((void )items[i]);
112	*items[i] = NULL;	113	*items[i] = NULL;
113	}	114	}
	@@ -213,7 +214,19 @@ int32_t SecConfSaveKeyCert(void)
213	return ret;	214	return ret;
214	}	215	}
215		216
		217	+int32_t SecConfKeyCertFactoryReset(void)
		218	+{
		219	+ ResetKeyCert(&g_keyCert);
		220	+ int32_t ret = SecurityStoreRegStoreList(&g_storeItem, 1);
		221	+ if (ret != IOTC_OK) {
		222	+ return ret;
		223	+ }
		224	+ ret = SecurityStoreDel(IOTC_STORE_KEY_INT_KEY_CERT_CONFIG);
		225	+ SecurityStoreUnregStoreList(&g_storeItem);
		226	+ return ret;
		227	+}
		228	+
216	const SecKeyCert *SecConfGetKeyCert(void)	229	const SecKeyCert *SecConfGetKeyCert(void)
217	{	230	{
218	return &g_keyCert;	231	return &g_keyCert;
219	-}	232	+}

Mcore/security/config/sec_conf_provision_data.c+2-2

	@@ -62,7 +62,7 @@ bool SecConfCheckProvisionData(const IotcProvisionData *provision)
62	return true;	62	return true;
63	}	63	}
64		64
65	-char *SecConfReadRawProvisionData()	65	+char *SecConfReadRawProvisionData(void)
66	{	66	{
67	int32_t ret = SecurityStoreRegStoreList(&g_storeItem, 1);	67	int32_t ret = SecurityStoreRegStoreList(&g_storeItem, 1);
68	if (ret != IOTC_OK) {	68	if (ret != IOTC_OK) {
	@@ -132,4 +132,4 @@ int32_t SecConfWriteRawProvisionData(const char *provisionData)
132	SecurityStoreUnregStoreList(&g_storeItem);	132	SecurityStoreUnregStoreList(&g_storeItem);
133	UTILS_FREE_2_NULL(g_storeItem.buffer);	133	UTILS_FREE_2_NULL(g_storeItem.buffer);
134	return ret;	134	return ret;
135	-}	135	+}

Mcore/security/service/sec_svc_provision.c+46-1

	@@ -24,7 +24,7 @@
24	#include "utils_common.h"	24	#include "utils_common.h"
25	#include "utils_ecdsa.h"	25	#include "utils_ecdsa.h"
26		26
27	-#define PROVISION_REQUEST_VERSION IOTC_ONECONNECT_VERSION_NAME	27	+#define PROVISION_REQUEST_VERSION "1.0"
28	#define PROVISION_REQUEST_SOFTWARE_VERSION "1.0"	28	#define PROVISION_REQUEST_SOFTWARE_VERSION "1.0"
29	#define PROVISION_REQUEST_CIPHER_SUITE 1	29	#define PROVISION_REQUEST_CIPHER_SUITE 1
30		30
	@@ -502,6 +502,46 @@ IotcJson SecSvcRecvProvisionCert(const IotcJson json)
502	return UtilsJsonCreateCodeDesc(ret, NULL);	502	return UtilsJsonCreateCodeDesc(ret, NULL);
503	}	503	}
504		504
		505	+static bool IsUpperHexString(const char *value, uint32_t expectedLen)
		506	+{
		507	+ if (value == NULL \|\| strlen(value) != expectedLen) {
		508	+ return false;
		509	+ }
		510	+ for (uint32_t i = 0; i < expectedLen; ++i) {
		511	+ if (!((value[i] >= '0' && value[i] <= '9') \|\| (value[i] >= 'A' && value[i] <= 'F'))) {
		512	+ return false;
		513	+ }
		514	+ }
		515	+ return true;
		516	+}
		517	+
		518	+static bool IsPskValidityFormat(const char *valid)
		519	+{
		520	+ static const uint8_t separatorPos[] = {4, 7, 10, 13, 16};
		521	+ static const char separators[] = {'-', '-', ' ', ':', ':'};
		522	+ if (valid == NULL \|\| strlen(valid) != PSK_VALID_MAX_LEN) {
		523	+ return false;
		524	+ }
		525	+ uint32_t separatorIdx = 0;
		526	+ for (uint32_t i = 0; i < PSK_VALID_MAX_LEN; ++i) {
		527	+ if (separatorIdx < ARRAY_SIZE(separatorPos) && i == separatorPos[separatorIdx]) {
		528	+ if (valid[i] != separators[separatorIdx]) {
		529	+ return false;
		530	+ }
		531	+ separatorIdx++;
		532	+ } else if (valid[i] < '0' \|\| valid[i] > '9') {
		533	+ return false;
		534	+ }
		535	+ }
		536	+ return true;
		537	+}
		538	+
		539	+static bool IsProvisionPskRequestValid(const char domainId, const SecPsk psk, const char *pskHex)
		540	+{
		541	+ return !UtilsIsEmptyStr(domainId) && psk != NULL && strlen(psk->pskId) == SEC_PSK_ID_LEN &&
		542	+ IsUpperHexString(pskHex, HEXIFY_LEN(sizeof(psk->psk))) && IsPskValidityFormat(psk->valid);
		543	+}
		544	+
505	IotcJson SecSvcRecvProvisionPsk(const IotcJson json)	545	IotcJson SecSvcRecvProvisionPsk(const IotcJson json)
506	{	546	{
507	CHECK_RETURN_LOGW(json != NULL, NULL, "param invalid");	547	CHECK_RETURN_LOGW(json != NULL, NULL, "param invalid");
	@@ -522,6 +562,11 @@ IotcJson SecSvcRecvProvisionPsk(const IotcJson json)
522	IOTC_LOGE("parse provisionPsk error %d", ret);	562	IOTC_LOGE("parse provisionPsk error %d", ret);
523	break;	563	break;
524	}	564	}
		565	+ if (!IsProvisionPskRequestValid(domainId, &secPsk, pskHex)) {
		566	+ IOTC_LOGE("provisionPsk field format invalid");
		567	+ ret = IOTC_ERR_INVALID_PARAM;
		568	+ break;
		569	+ }
525	if (!UtilsUnhexify(pskHex, HEXIFY_LEN(sizeof(secPsk.psk)), secPsk.psk, sizeof(secPsk.psk))) {	570	if (!UtilsUnhexify(pskHex, HEXIFY_LEN(sizeof(secPsk.psk)), secPsk.psk, sizeof(secPsk.psk))) {
526	IOTC_LOGE("unhexify psk error");	571	IOTC_LOGE("unhexify psk error");
527	ret = IOTC_CORE_COMM_UTILS_ERR_UNHEXIFY;	572	ret = IOTC_CORE_COMM_UTILS_ERR_UNHEXIFY;

Mcore/security/utils/sec_utils_conf.c+102-3

	@@ -47,6 +47,101 @@ bool SecUtilsConfIsValidDevAuthType(void)
47	return devAuthType == IOTC_DEV_AUTH_TYPE_CERT \|\| devAuthType == IOTC_DEV_AUTH_TYPE_PSK;	47	return devAuthType == IOTC_DEV_AUTH_TYPE_CERT \|\| devAuthType == IOTC_DEV_AUTH_TYPE_PSK;
48	}	48	}
49		49
		50	+static bool IsPskConfigured(const char pskId, const SecPsk terminalPsks, uint32_t terminalNum,
		51	+ const SecPsk *accessPsks, uint32_t accessNum)
		52	+{
		53	+ for (uint32_t i = 0; i < terminalNum; ++i) {
		54	+ if (strcmp(terminalPsks[i].pskId, pskId) == 0) {
		55	+ return true;
		56	+ }
		57	+ }
		58	+ for (uint32_t i = 0; i < accessNum; ++i) {
		59	+ if (strcmp(accessPsks[i].pskId, pskId) == 0) {
		60	+ return true;
		61	+ }
		62	+ }
		63	+ return false;
		64	+}
		65	+
		66	+static int32_t ProvisionAdminPskAcl(const char *pskId)
		67	+{
		68	+ SecPskAcl acls[SEC_ACL_MAX_NUM] = {0};
		69	+ uint16_t aclNum = 0;
		70	+ uint32_t aclNumLen = sizeof(aclNum);
		71	+ int32_t ret = SecConfInfoGet(SEC_CONF_INFO_KEY_PSK_ACL_NUM, (uint8_t *)&aclNum, &aclNumLen);
		72	+ CHECK_RETURN(ret == IOTC_OK, ret);
		73	+ CHECK_RETURN(aclNum <= SEC_ACL_MAX_NUM, IOTC_ERR_INVALID_PARAM);
		74	+
		75	+ uint32_t aclsLen = sizeof(acls);
		76	+ ret = SecConfInfoGet(SEC_CONF_INFO_KEY_PSK_ACLS, (uint8_t *)acls, &aclsLen);
		77	+ CHECK_RETURN(ret == IOTC_OK, ret);
		78	+
		79	+ SecPsk terminalPsks = (SecPsk )IotcCalloc(SEC_TERMINAL_PSK_MAX_NUM, sizeof(SecPsk));
		80	+ SecPsk accessPsks = (SecPsk )IotcCalloc(SEC_ACCESS_PSK_MAX_NUM, sizeof(SecPsk));
		81	+ if (terminalPsks == NULL \|\| accessPsks == NULL) {
		82	+ UTILS_FREE_2_NULL(terminalPsks);
		83	+ UTILS_FREE_2_NULL(accessPsks);
		84	+ return IOTC_ADAPTER_MEM_ERR_CALLOC;
		85	+ }
		86	+ uint32_t terminalNum = 0;
		87	+ uint32_t accessNum = 0;
		88	+ ret = SecUtilsConfQueryPsk(terminalPsks, &terminalNum, false);
		89	+ if (ret == IOTC_OK) {
		90	+ ret = SecUtilsConfQueryPsk(accessPsks, &accessNum, true);
		91	+ }
		92	+ if (ret != IOTC_OK) {
		93	+ goto EXIT;
		94	+ }
		95	+
		96	+ uint16_t write = 0;
		97	+ for (uint16_t read = 0; read < aclNum; ++read) {
		98	+ if (IsPskConfigured(acls[read].pskId, terminalPsks, terminalNum, accessPsks, accessNum)) {
		99	+ acls[write++] = acls[read];
		100	+ }
		101	+ }
		102	+ aclNum = write;
		103	+ if (aclNum < SEC_ACL_MAX_NUM) {
		104	+ (void)memset_s(&acls[aclNum], (SEC_ACL_MAX_NUM - aclNum) * sizeof(SecPskAcl), 0,
		105	+ (SEC_ACL_MAX_NUM - aclNum) * sizeof(SecPskAcl));
		106	+ }
		107	+
		108	+ uint16_t idx = 0;
		109	+ while (idx < aclNum) {
		110	+ if (strcmp(acls[idx].pskId, pskId) == 0 && acls[idx].interface[0] == '\0') {
		111	+ break;
		112	+ }
		113	+ ++idx;
		114	+ }
		115	+ if (idx >= SEC_ACL_MAX_NUM) {
		116	+ ret = IOTC_CORE_SECURITY_ERR_PSK_CACHE_NOT_ENOUGH;
		117	+ goto EXIT;
		118	+ }
		119	+ if (idx == aclNum) {
		120	+ ++aclNum;
		121	+ }
		122	+ (void)memset_s(&acls[idx], sizeof(acls[idx]), 0, sizeof(acls[idx]));
		123	+ ret = strcpy_s(acls[idx].pskId, sizeof(acls[idx].pskId), pskId);
		124	+ if (ret != EOK) {
		125	+ ret = IOTC_ERR_SECUREC_STRCPY;
		126	+ goto EXIT;
		127	+ }
		128	+ acls[idx].privilege = SEC_ACL_PRIVILEGE_ADMIN;
		129	+
		130	+ ret = SecConfInfoSet(SEC_CONF_INFO_KEY_PSK_ACLS, (const uint8_t *)acls, sizeof(acls));
		131	+ if (ret == IOTC_OK) {
		132	+ ret = SecConfInfoSet(SEC_CONF_INFO_KEY_PSK_ACL_NUM, (const uint8_t *)&aclNum, sizeof(aclNum));
		133	+ }
		134	+
		135	+EXIT:
		136	+ (void)memset_s(terminalPsks, SEC_TERMINAL_PSK_MAX_NUM * sizeof(SecPsk), 0,
		137	+ SEC_TERMINAL_PSK_MAX_NUM * sizeof(SecPsk));
		138	+ (void)memset_s(accessPsks, SEC_ACCESS_PSK_MAX_NUM * sizeof(SecPsk), 0,
		139	+ SEC_ACCESS_PSK_MAX_NUM * sizeof(SecPsk));
		140	+ IotcFree(terminalPsks);
		141	+ IotcFree(accessPsks);
		142	+ return ret;
		143	+}
		144	+
50	int32_t SecUtilsConfProvisionCert(const char *domainId, uint32_t domainIdLen,	145	int32_t SecUtilsConfProvisionCert(const char *domainId, uint32_t domainIdLen,
51	const char *adminSerialNumber, uint32_t adminSerialNumberLen)	146	const char *adminSerialNumber, uint32_t adminSerialNumberLen)
52	{	147	{
	@@ -69,14 +164,17 @@ int32_t SecUtilsConfProvisionCert(const char *domainId, uint32_t domainIdLen,
69	int32_t SecUtilsConfProvisionPsk(const char *domainId, uint32_t domainIdLen,	164	int32_t SecUtilsConfProvisionPsk(const char *domainId, uint32_t domainIdLen,
70	const SecPsk *secPsk)	165	const SecPsk *secPsk)
71	{	166	{
72	- CHECK_RETURN_LOGW(domainId != NULL && domainIdLen > 0 && secPsk != NULL,	167	+ CHECK_RETURN_LOGW(domainId != NULL && domainIdLen > 0 && secPsk != NULL &&
		168	+ secPsk->pskType == SEC_PSK_TYPE_ADMIN && strlen(secPsk->pskId) == SEC_PSK_ID_LEN,
73	IOTC_ERR_INVALID_PARAM, "param invalid");	169	IOTC_ERR_INVALID_PARAM, "param invalid");
74	int32_t ret = SecConfInfoSet(SEC_CONF_INFO_KEY_DOMAIN_ID, (const uint8_t *)domainId, domainIdLen);	170	int32_t ret = SecConfInfoSet(SEC_CONF_INFO_KEY_DOMAIN_ID, (const uint8_t *)domainId, domainIdLen);
75	if (ret != IOTC_OK) {	171	if (ret != IOTC_OK) {
76	IOTC_LOGW("set domainId error %d", ret);	172	IOTC_LOGW("set domainId error %d", ret);
77	return ret;	173	return ret;
78	}	174	}
79	- return SecUtilsConfSetPsk(secPsk, false);	175	+ ret = SecUtilsConfSetPsk(secPsk, false);
		176	+ CHECK_RETURN(ret == IOTC_OK, ret);
		177	+ return ProvisionAdminPskAcl(secPsk->pskId);
80	}	178	}
81		179
82	typedef struct {	180	typedef struct {
	@@ -159,7 +257,7 @@ static int32_t RemovePsk(const SecPsk secPsk, const char pskId, SecPsk *psks,
159	idx++;	257	idx++;
160	}	258	}
161	if (idx == currPskNum) {	259	if (idx == currPskNum) {
162	- IOTC_LOGF("remove psk error %s", pskId);	260	+ IOTC_LOGF("remove psk error: identity not found");
163	return IOTC_CORE_SECURITY_ERR_PSK_ID_NOT_EXIST;	261	return IOTC_CORE_SECURITY_ERR_PSK_ID_NOT_EXIST;
164	}	262	}
165	uint32_t dstSize = (pskMaxNum - idx) * sizeof(SecPsk);	263	uint32_t dstSize = (pskMaxNum - idx) * sizeof(SecPsk);
	@@ -230,6 +328,7 @@ int32_t SecUtilsConfSetPsk(const SecPsk *secPsk, bool isAccess)
230	ChangePskConfig(&terminalHandler, SEC_CONF_INFO_KEY_TERMINAL_PSK_NUM, SEC_CONF_INFO_KEY_TERMINAL_PSKS,	328	ChangePskConfig(&terminalHandler, SEC_CONF_INFO_KEY_TERMINAL_PSK_NUM, SEC_CONF_INFO_KEY_TERMINAL_PSKS,
231	SEC_TERMINAL_PSK_MAX_NUM);	329	SEC_TERMINAL_PSK_MAX_NUM);
232	}	330	}
		331	+
233	static int32_t SecUtilsConfQueryPskInner(SecPsk psks, uint32_t outPskNum, SecConfInfoKey numKey,	332	static int32_t SecUtilsConfQueryPskInner(SecPsk psks, uint32_t outPskNum, SecConfInfoKey numKey,
234	SecConfInfoKey psksKey, uint32_t pskMaxNum)	333	SecConfInfoKey psksKey, uint32_t pskMaxNum)
235	{	334	{

Mcore/wifi/application/softap/svc_softap_coap_provision.c+80-0

	@@ -24,6 +24,86 @@
24	#include "utils_json.h"	24	#include "utils_json.h"
25	#include "iotc_errcode.h"	25	#include "iotc_errcode.h"
26	#include "iotc_svc_sec.h"	26	#include "iotc_svc_sec.h"
		27	+#include "iotc_svc_dev.h"
		28	+#include "dev_info.h"
		29	+#include "dev_info_mdl.h"
		30	+#include "securec.h"
		31	+#include "wifi_net_info.h"
		32	+
		33	+#define SOFTAP_DEVICE_INFO_HIV "2.0"
		34	+
		35	+static IotcJson *SoftapBuildDeviceInfoResp(void)
		36	+{
		37	+ IotcJson *respJson = UtilsJsonCreateErrcode(IOTC_OK);
		38	+ if (respJson == NULL) {
		39	+ return NULL;
		40	+ }
		41	+
		42	+ DevAuthInfo authInfo = {0};
		43	+ bool isAuthInfoExist = false;
		44	+ int32_t ret = DevSvcProxyGetAuthInfo(&isAuthInfoExist, &authInfo);
		45	+ if (ret != IOTC_OK \|\|
		46	+ IotcJsonAddStr2Obj(respJson, STR_JSON_DEV_ID, isAuthInfoExist ? authInfo.devId : "") != IOTC_OK) {
		47	+ (void)memset_s(&authInfo, sizeof(authInfo), 0, sizeof(authInfo));
		48	+ IotcJsonDelete(respJson);
		49	+ return NULL;
		50	+ }
		51	+ (void)memset_s(&authInfo, sizeof(authInfo), 0, sizeof(authInfo));
		52	+
		53	+ IotcJson *devInfoJson = MdlBuildDevInfoJson(ModelGetDevInfo());
		54	+ if (devInfoJson == NULL) {
		55	+ IotcJsonDelete(respJson);
		56	+ return NULL;
		57	+ }
		58	+ if (IotcJsonReplaceStr2Obj(devInfoJson, STR_JSON_HIV, SOFTAP_DEVICE_INFO_HIV) != IOTC_OK) {
		59	+ IotcJsonDelete(devInfoJson);
		60	+ IotcJsonDelete(respJson);
		61	+ return NULL;
		62	+ }
		63	+ char mac[MAC_STR_MAX_LEN] = {0};
		64	+ ret = GetWifiMacAddrStr(mac, sizeof(mac));
		65	+ if (ret != IOTC_OK \|\| IotcJsonAddStr2Obj(devInfoJson, STR_JSON_MAC, mac) != IOTC_OK) {
		66	+ IotcJsonDelete(devInfoJson);
		67	+ IotcJsonDelete(respJson);
		68	+ return NULL;
		69	+ }
		70	+ ret = IotcJsonAddItem2Obj(respJson, STR_JSON_DEV_INFO, devInfoJson);
		71	+ if (ret != IOTC_OK) {
		72	+ IotcJsonDelete(devInfoJson);
		73	+ IotcJsonDelete(respJson);
		74	+ return NULL;
		75	+ }
		76	+ return respJson;
		77	+}
		78	+
		79	+void SoftapCoapDeviceInfoReqHandler(CoapEndpoint endpoint, const CoapPacket req,
		80	+ const SocketAddr addr, void userData)
		81	+{
		82	+ NOT_USED(userData);
		83	+ CHECK_V_RETURN_LOGW(endpoint != NULL && req != NULL && addr != NULL, "invalid param");
		84	+ if (req->payload.len != 0) {
		85	+ IOTC_LOGW("DeviceInfo request payload must be empty, len=%u", req->payload.len);
		86	+ return;
		87	+ }
		88	+ IOTC_LOGI("DeviceInfo request payload len=0, hiv=%s", SOFTAP_DEVICE_INFO_HIV);
		89	+
		90	+ IotcJson *respJson = SoftapBuildDeviceInfoResp();
		91	+ if (respJson == NULL) {
		92	+ IOTC_LOGW("build DeviceInfo response error");
		93	+ return;
		94	+ }
		95	+
		96	+ CoapServerRespParam respParam;
		97	+ int32_t ret = CoapServerBuildDefaultRespParam(&respParam, req, respJson);
		98	+ if (ret == IOTC_OK) {
		99	+ CoapPacket packet;
		100	+ ret = CoapServerSendResp(endpoint, &respParam, addr, &packet);
		101	+ }
		102	+ IotcJsonDelete(respJson);
		103	+ if (ret != IOTC_OK) {
		104	+ IOTC_LOGW("send DeviceInfo response error %d", ret);
		105	+ }
		106	+}
27		107
28	void SoftapCoapGetOemProvisionRequestReqHandler(CoapEndpoint endpoint, const CoapPacket req,	108	void SoftapCoapGetOemProvisionRequestReqHandler(CoapEndpoint endpoint, const CoapPacket req,
29	const SocketAddr addr, void userData)	109	const SocketAddr addr, void userData)

Mcore/wifi/application/softap/svc_softap_coap_provision.h+4-1

	@@ -37,8 +37,11 @@ void SoftapCoapProvisionCertReqHandler(CoapEndpoint *endpoint, const CoapPacket
37	void SoftapCoapProvisionPskReqHandler(CoapEndpoint endpoint, const CoapPacket req,	37	void SoftapCoapProvisionPskReqHandler(CoapEndpoint endpoint, const CoapPacket req,
38	const SocketAddr addr, void userData);	38	const SocketAddr addr, void userData);
39		39
		40	+void SoftapCoapDeviceInfoReqHandler(CoapEndpoint endpoint, const CoapPacket req,
		41	+ const SocketAddr addr, void userData);
		42	+
40	#ifdef __cplusplus	43	#ifdef __cplusplus
41	}	44	}
42	#endif	45	#endif
43		46
44	-#endif /* SVC_SOFTAP_COAP_PROVISION_H */	47	+#endif /* SVC_SOFTAP_COAP_PROVISION_H */

Minterfaces/kits/common/iotc_conf.h+16-0

	@@ -47,6 +47,22 @@
47	#define IOTC_CONF_ADAPTER_SOCKET_LWIP_SUPPORT 0	47	#define IOTC_CONF_ADAPTER_SOCKET_LWIP_SUPPORT 0
48	#endif	48	#endif
49		49
		50	+#ifndef IOTC_CONF_ADAPTER_SOCKET_LWIP_FDS
		51	+ #define IOTC_CONF_ADAPTER_SOCKET_LWIP_FDS 0
		52	+#endif
		53	+
		54	+#ifndef IOTC_CONF_UTILS_MUTEX_LOCKLESS
		55	+ #define IOTC_CONF_UTILS_MUTEX_LOCKLESS 0
		56	+#endif
		57	+
		58	+#ifndef IOTC_CONF_ADAPTER_WIFI_MANAGE_SOFTAP_IP
		59	+ #define IOTC_CONF_ADAPTER_WIFI_MANAGE_SOFTAP_IP 0
		60	+#endif
		61	+
		62	+#ifndef IOTC_CONF_WIFI_ONLY_SUPPORT
		63	+ #define IOTC_CONF_WIFI_ONLY_SUPPORT 0
		64	+#endif
		65	+
50	/* mbedtls是否启动debug，0-否，其他-是 */	66	/* mbedtls是否启动debug，0-否，其他-是 */
51	#ifndef IOTC_CONF_ADAPTER_MBEDTLS_TLS_DEBUG	67	#ifndef IOTC_CONF_ADAPTER_MBEDTLS_TLS_DEBUG
52	#define IOTC_CONF_ADAPTER_MBEDTLS_TLS_DEBUG 0	68	#define IOTC_CONF_ADAPTER_MBEDTLS_TLS_DEBUG 0

Minterfaces/kits/common/iotc_errcode.h+5-1

	@@ -46,6 +46,11 @@ enum IotcErrcode {
46	IOTC_SDK_MNGR_ERR_MULTI_INVOKE,	46	IOTC_SDK_MNGR_ERR_MULTI_INVOKE,
47		47
48	IOTC_CORE_DEVICE_ERR_GET_CHAR_STATE = ERR_CODE_BASE(IOTC_SUB_MODULE_CORE_DEVICE),	48	IOTC_CORE_DEVICE_ERR_GET_CHAR_STATE = ERR_CODE_BASE(IOTC_SUB_MODULE_CORE_DEVICE),
		49	+ IOTC_CORE_DEVICE_ERR_STORE_NOT_FOUND,
		50	+ IOTC_CORE_DEVICE_ERR_STORE_SCHEMA,
		51	+ IOTC_CORE_DEVICE_ERR_STORE_CORRUPT,
		52	+ IOTC_CORE_DEVICE_ERR_STORE_STATE,
		53	+ IOTC_CORE_DEVICE_ERR_STORE_KV,
49		54
50	IOTC_CORE_SECURITY_ERR_CONFIG_PROVISION = ERR_CODE_BASE(IOTC_SUB_MODULE_CORE_SECURITY),	55	IOTC_CORE_SECURITY_ERR_CONFIG_PROVISION = ERR_CODE_BASE(IOTC_SUB_MODULE_CORE_SECURITY),
51	IOTC_CORE_SECURITY_ERR_CHECK_PROVISION_DATA,	56	IOTC_CORE_SECURITY_ERR_CHECK_PROVISION_DATA,
	@@ -380,7 +385,6 @@ enum IotcErrcode {
380	IOTC_CORE_COMM_SEC_ERR_SPEKE_VERIFY_HMAC,	385	IOTC_CORE_COMM_SEC_ERR_SPEKE_VERIFY_HMAC,
381	IOTC_CORE_COMM_SEC_ERR_SPEKE_CREATE,	386	IOTC_CORE_COMM_SEC_ERR_SPEKE_CREATE,
382	IOTC_CORE_COMM_SEC_ERR_SESS_KEY_NOT_READY,	387	IOTC_CORE_COMM_SEC_ERR_SESS_KEY_NOT_READY,
383	-
384	IOTC_CORE_COMM_FWK_ERR_SOURCE_TIMER_MAX,	388	IOTC_CORE_COMM_FWK_ERR_SOURCE_TIMER_MAX,
385	IOTC_CORE_COMM_FWK_ERR_SOURCE_TIMER_CREATE,	389	IOTC_CORE_COMM_FWK_ERR_SOURCE_TIMER_CREATE,
386	IOTC_CORE_COMM_FWK_ERR_SOURCE_FD_WATCH,	390	IOTC_CORE_COMM_FWK_ERR_SOURCE_FD_WATCH,