Skip to content

L
lnv-rtk8710
Commit 32fe0911 by zhanggf4
Options

ssl_api OTA and Smartconfig.

parent 6a38409e
Showing with 1374 additions and 668 deletions
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/arch/device.c
...@@ -136,7 +136,6 @@ int IOTDev_GetAttribute(UINT32 attribute_id, OCTData *attr) ...@@ -136,7 +136,6 @@ int IOTDev_GetAttribute(UINT32 attribute_id, OCTData *attr)
return E_SUCCESS; return E_SUCCESS;
} }
int iOta = 0;
int IOTDev_ExecuteAction(UINT32 action_id, OCTData *param) int IOTDev_ExecuteAction(UINT32 action_id, OCTData *param)
{ {
UINT32 attribute_id[1]; UINT32 attribute_id[1];
...@@ -153,9 +152,6 @@ int IOTDev_ExecuteAction(UINT32 action_id, OCTData *param) ...@@ -153,9 +152,6 @@ int IOTDev_ExecuteAction(UINT32 action_id, OCTData *param)
log_debug0("zcf execute action(%08x) onoff=%d\n", (unsigned int)action_id, (int)(param->value.Integer.Integer)); log_debug0("zcf execute action(%08x) onoff=%d\n", (unsigned int)action_id, (int)(param->value.Integer.Integer));
printf("##########execute action %d\n", param->value.Integer.Integer); printf("##########execute action %d\n", param->value.Integer.Integer);
attribute_id[0] = GARDGET_PLUG_ATTRIBUTE_ONOFF; attribute_id[0] = GARDGET_PLUG_ATTRIBUTE_ONOFF;
if ((iOta ++) > 6) {
IOTOTA_Start("1");
}
break; break;
case GARDGET_PLUG_ACTION_OTA_CHECK: case GARDGET_PLUG_ACTION_OTA_CHECK:
log_debug0("execute action(%08x) ota check\n", action_id); log_debug0("execute action(%08x) ota check\n", action_id);
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/arch/rtos.c
...@@ -402,6 +402,23 @@ int IOTSysP_ParamSave(void *param,int size) ...@@ -402,6 +402,23 @@ int IOTSysP_ParamSave(void *param,int size)
return E_SUCCESS; return E_SUCCESS;
} }
int IOTSysP_GetMemParam(void *mem, int size)
{
return E_FAILED;
}
int IOTSysP_SetMemParam(void *mem, int size)
{
#if 0
if(system_rtc_mem_write(64,mem,size) != 0)
{
return E_SUCCESS;
}
#endif
return E_FAILED;
}
static int IOTSys_Check_Flash_Size(void) static int IOTSys_Check_Flash_Size(void)
{ {
return E_SUCCESS; return E_SUCCESS;
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/arch/ssl_server_crt.h 0 → 100644
#ifndef __OPENSSL_CERT_H__
#define __OPENSSL_CERT_H__
#if 0
const unsigned char ca_crt[] = {
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x44, 0x58, 0x6a, 0x43, 0x43,
0x41, 0x6b, 0x59, 0x43, 0x43, 0x51, 0x43, 0x42, 0x38, 0x6c, 0x72, 0x2b,
0x43, 0x54, 0x51, 0x34, 0x75, 0x44, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71,
0x68, 0x6b, 0x69, 0x47, 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x55, 0x46,
0x41, 0x44, 0x42, 0x78, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44,
0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x44, 0x0a, 0x4d, 0x54, 0x45,
0x4d, 0x4d, 0x41, 0x6f, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77,
0x44, 0x53, 0x6c, 0x4d, 0x78, 0x4d, 0x51, 0x77, 0x77, 0x43, 0x67, 0x59,
0x44, 0x56, 0x51, 0x51, 0x48, 0x44, 0x41, 0x4e, 0x58, 0x57, 0x44, 0x45,
0x78, 0x44, 0x54, 0x41, 0x4c, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f,
0x4d, 0x42, 0x45, 0x56, 0x54, 0x55, 0x44, 0x45, 0x78, 0x44, 0x54, 0x41,
0x4c, 0x0a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x4d, 0x42, 0x45,
0x56, 0x54, 0x55, 0x44, 0x45, 0x78, 0x45, 0x7a, 0x41, 0x52, 0x42, 0x67,
0x4e, 0x56, 0x42, 0x41, 0x4d, 0x4d, 0x43, 0x6c, 0x4e, 0x6c, 0x63, 0x6e,
0x5a, 0x6c, 0x63, 0x6a, 0x45, 0x67, 0x51, 0x30, 0x45, 0x78, 0x45, 0x7a,
0x41, 0x52, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47, 0x39, 0x77,
0x30, 0x42, 0x43, 0x51, 0x45, 0x57, 0x0a, 0x42, 0x45, 0x56, 0x54, 0x55,
0x44, 0x45, 0x77, 0x48, 0x68, 0x63, 0x4e, 0x4d, 0x54, 0x67, 0x77, 0x4d,
0x54, 0x41, 0x30, 0x4d, 0x44, 0x55, 0x30, 0x4d, 0x7a, 0x49, 0x31, 0x57,
0x68, 0x63, 0x4e, 0x4d, 0x7a, 0x45, 0x77, 0x4f, 0x54, 0x45, 0x7a, 0x4d,
0x44, 0x55, 0x30, 0x4d, 0x7a, 0x49, 0x31, 0x57, 0x6a, 0x42, 0x78, 0x4d,
0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x0a,
0x45, 0x77, 0x4a, 0x44, 0x4d, 0x54, 0x45, 0x4d, 0x4d, 0x41, 0x6f, 0x47,
0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77, 0x44, 0x53, 0x6c, 0x4d, 0x78,
0x4d, 0x51, 0x77, 0x77, 0x43, 0x67, 0x59, 0x44, 0x56, 0x51, 0x51, 0x48,
0x44, 0x41, 0x4e, 0x58, 0x57, 0x44, 0x45, 0x78, 0x44, 0x54, 0x41, 0x4c,
0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f, 0x4d, 0x42, 0x45, 0x56, 0x54,
0x55, 0x44, 0x45, 0x78, 0x0a, 0x44, 0x54, 0x41, 0x4c, 0x42, 0x67, 0x4e,
0x56, 0x42, 0x41, 0x73, 0x4d, 0x42, 0x45, 0x56, 0x54, 0x55, 0x44, 0x45,
0x78, 0x45, 0x7a, 0x41, 0x52, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x4d,
0x4d, 0x43, 0x6c, 0x4e, 0x6c, 0x63, 0x6e, 0x5a, 0x6c, 0x63, 0x6a, 0x45,
0x67, 0x51, 0x30, 0x45, 0x78, 0x45, 0x7a, 0x41, 0x52, 0x42, 0x67, 0x6b,
0x71, 0x68, 0x6b, 0x69, 0x47, 0x39, 0x77, 0x30, 0x42, 0x0a, 0x43, 0x51,
0x45, 0x57, 0x42, 0x45, 0x56, 0x54, 0x55, 0x44, 0x45, 0x77, 0x67, 0x67,
0x45, 0x69, 0x4d, 0x41, 0x30, 0x47, 0x43, 0x53, 0x71, 0x47, 0x53, 0x49,
0x62, 0x33, 0x44, 0x51, 0x45, 0x42, 0x41, 0x51, 0x55, 0x41, 0x41, 0x34,
0x49, 0x42, 0x44, 0x77, 0x41, 0x77, 0x67, 0x67, 0x45, 0x4b, 0x41, 0x6f,
0x49, 0x42, 0x41, 0x51, 0x44, 0x51, 0x6f, 0x5a, 0x59, 0x42, 0x2b, 0x65,
0x42, 0x45, 0x0a, 0x63, 0x78, 0x66, 0x79, 0x5a, 0x4c, 0x7a, 0x56, 0x6c,
0x4c, 0x4e, 0x37, 0x39, 0x4c, 0x4e, 0x75, 0x62, 0x58, 0x4c, 0x4d, 0x4c,
0x75, 0x4c, 0x32, 0x4c, 0x46, 0x75, 0x58, 0x4f, 0x71, 0x6e, 0x6e, 0x6b,
0x67, 0x41, 0x52, 0x4f, 0x6c, 0x34, 0x33, 0x49, 0x57, 0x4b, 0x6b, 0x63,
0x4a, 0x77, 0x59, 0x4c, 0x2f, 0x4b, 0x45, 0x51, 0x67, 0x6c, 0x68, 0x77,
0x4e, 0x58, 0x5a, 0x48, 0x48, 0x36, 0x4c, 0x0a, 0x64, 0x64, 0x6a, 0x45,
0x44, 0x7a, 0x79, 0x4c, 0x6d, 0x6d, 0x71, 0x74, 0x57, 0x4b, 0x6f, 0x6f,
0x50, 0x47, 0x57, 0x69, 0x50, 0x48, 0x51, 0x6c, 0x72, 0x46, 0x39, 0x77,
0x62, 0x63, 0x69, 0x42, 0x33, 0x6a, 0x47, 0x2b, 0x39, 0x77, 0x65, 0x79,
0x68, 0x39, 0x36, 0x6a, 0x63, 0x34, 0x39, 0x34, 0x4d, 0x6e, 0x67, 0x73,
0x41, 0x42, 0x4b, 0x56, 0x6e, 0x50, 0x4c, 0x67, 0x65, 0x71, 0x49, 0x50,
0x0a, 0x4c, 0x46, 0x63, 0x73, 0x31, 0x46, 0x6c, 0x6f, 0x4a, 0x57, 0x4e,
0x46, 0x38, 0x4e, 0x70, 0x30, 0x4a, 0x36, 0x34, 0x61, 0x33, 0x36, 0x6f,
0x50, 0x79, 0x5a, 0x46, 0x47, 0x66, 0x78, 0x47, 0x33, 0x35, 0x31, 0x6a,
0x7a, 0x58, 0x52, 0x48, 0x5a, 0x78, 0x62, 0x59, 0x33, 0x55, 0x49, 0x55,
0x6e, 0x52, 0x75, 0x42, 0x46, 0x68, 0x54, 0x73, 0x54, 0x73, 0x42, 0x49,
0x44, 0x37, 0x65, 0x53, 0x73, 0x0a, 0x73, 0x6e, 0x37, 0x76, 0x54, 0x35,
0x38, 0x62, 0x54, 0x67, 0x41, 0x30, 0x30, 0x56, 0x42, 0x4a, 0x46, 0x68,
0x4c, 0x75, 0x46, 0x48, 0x67, 0x7a, 0x5a, 0x75, 0x6b, 0x43, 0x2f, 0x37,
0x73, 0x42, 0x6a, 0x78, 0x52, 0x45, 0x57, 0x72, 0x4e, 0x66, 0x2f, 0x2b,
0x66, 0x54, 0x69, 0x34, 0x35, 0x6a, 0x62, 0x79, 0x37, 0x35, 0x77, 0x64,
0x31, 0x35, 0x75, 0x49, 0x55, 0x47, 0x6f, 0x31, 0x66, 0x6c, 0x0a, 0x57,
0x75, 0x56, 0x4e, 0x69, 0x66, 0x72, 0x2b, 0x2b, 0x75, 0x53, 0x79, 0x79,
0x58, 0x76, 0x4d, 0x54, 0x4b, 0x78, 0x64, 0x78, 0x69, 0x37, 0x52, 0x50,
0x47, 0x61, 0x63, 0x57, 0x64, 0x55, 0x6a, 0x30, 0x53, 0x66, 0x6c, 0x43,
0x67, 0x2b, 0x64, 0x72, 0x37, 0x32, 0x4a, 0x43, 0x4b, 0x6b, 0x4a, 0x6e,
0x45, 0x49, 0x69, 0x4e, 0x59, 0x69, 0x6e, 0x39, 0x69, 0x51, 0x38, 0x77,
0x6d, 0x70, 0x50, 0x0a, 0x42, 0x39, 0x2b, 0x4c, 0x43, 0x45, 0x6c, 0x59,
0x39, 0x6d, 0x51, 0x31, 0x41, 0x67, 0x4d, 0x42, 0x41, 0x41, 0x45, 0x77,
0x44, 0x51, 0x59, 0x4a, 0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e,
0x41, 0x51, 0x45, 0x46, 0x42, 0x51, 0x41, 0x44, 0x67, 0x67, 0x45, 0x42,
0x41, 0x47, 0x4a, 0x2f, 0x39, 0x76, 0x51, 0x58, 0x7a, 0x63, 0x6f, 0x6b,
0x34, 0x47, 0x61, 0x47, 0x33, 0x6f, 0x76, 0x7a, 0x0a, 0x47, 0x36, 0x58,
0x47, 0x49, 0x4d, 0x53, 0x33, 0x62, 0x67, 0x42, 0x36, 0x70, 0x38, 0x77,
0x6d, 0x55, 0x70, 0x32, 0x43, 0x2f, 0x69, 0x59, 0x31, 0x5a, 0x37, 0x30,
0x49, 0x65, 0x74, 0x55, 0x41, 0x35, 0x6e, 0x61, 0x42, 0x67, 0x4c, 0x4c,
0x4c, 0x7a, 0x6f, 0x6e, 0x71, 0x73, 0x58, 0x71, 0x4c, 0x51, 0x64, 0x78,
0x78, 0x48, 0x53, 0x34, 0x47, 0x76, 0x46, 0x63, 0x59, 0x6d, 0x66, 0x30,
0x71, 0x0a, 0x34, 0x61, 0x43, 0x38, 0x4e, 0x77, 0x69, 0x4f, 0x54, 0x4d,
0x63, 0x31, 0x4e, 0x47, 0x56, 0x6e, 0x5a, 0x35, 0x34, 0x70, 0x7a, 0x44,
0x59, 0x6a, 0x49, 0x70, 0x70, 0x45, 0x58, 0x6c, 0x30, 0x47, 0x72, 0x73,
0x6d, 0x71, 0x36, 0x67, 0x4a, 0x2b, 0x61, 0x51, 0x43, 0x52, 0x73, 0x6b,
0x76, 0x68, 0x32, 0x65, 0x41, 0x38, 0x6b, 0x47, 0x47, 0x4d, 0x54, 0x74,
0x58, 0x63, 0x52, 0x69, 0x55, 0x36, 0x0a, 0x41, 0x6a, 0x4d, 0x64, 0x61,
0x75, 0x35, 0x52, 0x2b, 0x35, 0x78, 0x73, 0x33, 0x6f, 0x74, 0x62, 0x76,
0x37, 0x6f, 0x63, 0x65, 0x58, 0x6d, 0x37, 0x31, 0x30, 0x71, 0x79, 0x5a,
0x43, 0x78, 0x44, 0x64, 0x31, 0x63, 0x73, 0x74, 0x62, 0x72, 0x69, 0x7a,
0x77, 0x54, 0x4a, 0x5a, 0x37, 0x65, 0x78, 0x35, 0x64, 0x59, 0x7a, 0x65,
0x65, 0x4a, 0x52, 0x32, 0x50, 0x61, 0x6b, 0x2f, 0x6f, 0x6c, 0x53, 0x0a,
0x38, 0x75, 0x56, 0x4e, 0x31, 0x34, 0x7a, 0x55, 0x77, 0x67, 0x47, 0x56,
0x4c, 0x4b, 0x79, 0x62, 0x37, 0x43, 0x58, 0x47, 0x48, 0x49, 0x31, 0x37,
0x7a, 0x2b, 0x78, 0x59, 0x4c, 0x74, 0x75, 0x61, 0x73, 0x39, 0x6a, 0x4d,
0x42, 0x62, 0x4e, 0x5a, 0x77, 0x53, 0x33, 0x4f, 0x30, 0x52, 0x31, 0x36,
0x7a, 0x63, 0x46, 0x62, 0x43, 0x59, 0x6f, 0x64, 0x57, 0x55, 0x43, 0x68,
0x58, 0x71, 0x52, 0x4d, 0x0a, 0x6a, 0x4e, 0x51, 0x79, 0x70, 0x57, 0x4d,
0x4c, 0x37, 0x30, 0x78, 0x4e, 0x4b, 0x67, 0x48, 0x45, 0x67, 0x6b, 0x6a,
0x47, 0x36, 0x74, 0x55, 0x5a, 0x54, 0x4a, 0x31, 0x68, 0x2b, 0x54, 0x37,
0x61, 0x31, 0x37, 0x4b, 0x70, 0x49, 0x4f, 0x6a, 0x35, 0x59, 0x53, 0x50,
0x46, 0x4e, 0x50, 0x58, 0x72, 0x45, 0x66, 0x69, 0x43, 0x33, 0x4e, 0x50,
0x53, 0x72, 0x55, 0x2f, 0x4b, 0x6a, 0x6f, 0x41, 0x51, 0x0a, 0x7a, 0x45,
0x59, 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20,
0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x0a
};
unsigned int ca_crt_len = 1229;
#endif
const unsigned char server_crt[] = {
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43,
0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x44, 0x5a, 0x44, 0x43, 0x43,
0x41, 0x6b, 0x77, 0x43, 0x43, 0x51, 0x44, 0x55, 0x38, 0x4a, 0x7a, 0x35,
0x32, 0x47, 0x55, 0x76, 0x69, 0x6a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71,
0x68, 0x6b, 0x69, 0x47, 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x55, 0x46,
0x41, 0x44, 0x42, 0x78, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44,
0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x44, 0x0a, 0x4d, 0x54, 0x45,
0x4d, 0x4d, 0x41, 0x6f, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77,
0x44, 0x53, 0x6c, 0x4d, 0x78, 0x4d, 0x51, 0x77, 0x77, 0x43, 0x67, 0x59,
0x44, 0x56, 0x51, 0x51, 0x48, 0x44, 0x41, 0x4e, 0x58, 0x57, 0x44, 0x45,
0x78, 0x44, 0x54, 0x41, 0x4c, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x6f,
0x4d, 0x42, 0x45, 0x56, 0x54, 0x55, 0x44, 0x45, 0x78, 0x44, 0x54, 0x41,
0x4c, 0x0a, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x4d, 0x42, 0x45,
0x56, 0x54, 0x55, 0x44, 0x45, 0x78, 0x45, 0x7a, 0x41, 0x52, 0x42, 0x67,
0x4e, 0x56, 0x42, 0x41, 0x4d, 0x4d, 0x43, 0x6c, 0x4e, 0x6c, 0x63, 0x6e,
0x5a, 0x6c, 0x63, 0x6a, 0x45, 0x67, 0x51, 0x30, 0x45, 0x78, 0x45, 0x7a,
0x41, 0x52, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47, 0x39, 0x77,
0x30, 0x42, 0x43, 0x51, 0x45, 0x57, 0x0a, 0x42, 0x45, 0x56, 0x54, 0x55,
0x44, 0x45, 0x77, 0x48, 0x68, 0x63, 0x4e, 0x4d, 0x54, 0x67, 0x77, 0x4d,
0x54, 0x41, 0x30, 0x4d, 0x44, 0x55, 0x30, 0x4d, 0x7a, 0x49, 0x31, 0x57,
0x68, 0x63, 0x4e, 0x4d, 0x7a, 0x45, 0x77, 0x4f, 0x54, 0x45, 0x7a, 0x4d,
0x44, 0x55, 0x30, 0x4d, 0x7a, 0x49, 0x31, 0x57, 0x6a, 0x42, 0x33, 0x4d,
0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x0a,
0x45, 0x77, 0x4a, 0x44, 0x4d, 0x6a, 0x45, 0x4e, 0x4d, 0x41, 0x73, 0x47,
0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77, 0x45, 0x53, 0x6c, 0x4d, 0x79,
0x4d, 0x6a, 0x45, 0x4e, 0x4d, 0x41, 0x73, 0x47, 0x41, 0x31, 0x55, 0x45,
0x42, 0x77, 0x77, 0x45, 0x56, 0x31, 0x67, 0x79, 0x4d, 0x6a, 0x45, 0x4f,
0x4d, 0x41, 0x77, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x67, 0x77, 0x46,
0x52, 0x56, 0x4e, 0x51, 0x0a, 0x4d, 0x6a, 0x49, 0x78, 0x44, 0x6a, 0x41,
0x4d, 0x42, 0x67, 0x4e, 0x56, 0x42, 0x41, 0x73, 0x4d, 0x42, 0x55, 0x56,
0x54, 0x55, 0x44, 0x49, 0x79, 0x4d, 0x52, 0x51, 0x77, 0x45, 0x67, 0x59,
0x44, 0x56, 0x51, 0x51, 0x44, 0x44, 0x41, 0x74, 0x54, 0x5a, 0x58, 0x4a,
0x32, 0x5a, 0x58, 0x49, 0x79, 0x4d, 0x69, 0x42, 0x44, 0x51, 0x54, 0x45,
0x55, 0x4d, 0x42, 0x49, 0x47, 0x43, 0x53, 0x71, 0x47, 0x0a, 0x53, 0x49,
0x62, 0x33, 0x44, 0x51, 0x45, 0x4a, 0x41, 0x52, 0x59, 0x46, 0x52, 0x56,
0x4e, 0x51, 0x4d, 0x6a, 0x49, 0x77, 0x67, 0x67, 0x45, 0x69, 0x4d, 0x41,
0x30, 0x47, 0x43, 0x53, 0x71, 0x47, 0x53, 0x49, 0x62, 0x33, 0x44, 0x51,
0x45, 0x42, 0x41, 0x51, 0x55, 0x41, 0x41, 0x34, 0x49, 0x42, 0x44, 0x77,
0x41, 0x77, 0x67, 0x67, 0x45, 0x4b, 0x41, 0x6f, 0x49, 0x42, 0x41, 0x51,
0x44, 0x6a, 0x0a, 0x71, 0x78, 0x65, 0x54, 0x51, 0x6a, 0x51, 0x79, 0x64,
0x33, 0x37, 0x76, 0x2f, 0x62, 0x67, 0x33, 0x46, 0x64, 0x70, 0x2f, 0x70,
0x77, 0x39, 0x64, 0x6a, 0x43, 0x64, 0x49, 0x69, 0x52, 0x43, 0x35, 0x70,
0x55, 0x65, 0x68, 0x6f, 0x48, 0x4e, 0x75, 0x6e, 0x31, 0x5a, 0x48, 0x59,
0x73, 0x62, 0x45, 0x6a, 0x66, 0x56, 0x49, 0x75, 0x6e, 0x2b, 0x31, 0x55,
0x74, 0x32, 0x59, 0x6d, 0x50, 0x58, 0x74, 0x0a, 0x68, 0x64, 0x4f, 0x36,
0x56, 0x53, 0x65, 0x2f, 0x5a, 0x32, 0x4f, 0x4d, 0x51, 0x65, 0x4e, 0x4b,
0x76, 0x47, 0x7a, 0x5a, 0x64, 0x57, 0x55, 0x4f, 0x72, 0x42, 0x55, 0x58,
0x4e, 0x48, 0x47, 0x77, 0x70, 0x37, 0x4f, 0x44, 0x35, 0x35, 0x34, 0x5a,
0x32, 0x48, 0x34, 0x45, 0x78, 0x47, 0x48, 0x2b, 0x46, 0x5a, 0x38, 0x73,
0x59, 0x47, 0x67, 0x39, 0x37, 0x72, 0x43, 0x70, 0x39, 0x59, 0x33, 0x52,
0x0a, 0x56, 0x52, 0x4a, 0x74, 0x72, 0x33, 0x30, 0x31, 0x55, 0x68, 0x72,
0x34, 0x62, 0x30, 0x6f, 0x59, 0x64, 0x39, 0x67, 0x37, 0x48, 0x33, 0x47,
0x79, 0x6d, 0x51, 0x76, 0x55, 0x79, 0x73, 0x7a, 0x65, 0x62, 0x61, 0x76,
0x36, 0x48, 0x4b, 0x45, 0x6b, 0x74, 0x65, 0x56, 0x35, 0x45, 0x67, 0x64,
0x59, 0x31, 0x65, 0x6f, 0x51, 0x78, 0x65, 0x46, 0x59, 0x36, 0x36, 0x51,
0x7a, 0x43, 0x2b, 0x30, 0x4b, 0x0a, 0x6f, 0x53, 0x32, 0x73, 0x75, 0x4a,
0x31, 0x34, 0x70, 0x30, 0x4b, 0x6f, 0x4f, 0x4f, 0x6f, 0x74, 0x47, 0x4e,
0x6c, 0x41, 0x59, 0x49, 0x31, 0x75, 0x50, 0x57, 0x37, 0x7a, 0x4c, 0x54,
0x31, 0x70, 0x73, 0x6d, 0x4a, 0x76, 0x6c, 0x55, 0x51, 0x57, 0x4e, 0x66,
0x38, 0x70, 0x6e, 0x56, 0x47, 0x36, 0x53, 0x47, 0x30, 0x72, 0x37, 0x73,
0x78, 0x76, 0x59, 0x50, 0x64, 0x52, 0x57, 0x76, 0x53, 0x45, 0x0a, 0x53,
0x58, 0x31, 0x6f, 0x67, 0x52, 0x56, 0x31, 0x69, 0x4f, 0x65, 0x61, 0x47,
0x50, 0x33, 0x43, 0x56, 0x64, 0x53, 0x58, 0x47, 0x70, 0x50, 0x31, 0x31,
0x46, 0x50, 0x33, 0x56, 0x58, 0x46, 0x64, 0x33, 0x56, 0x34, 0x4d, 0x6e,
0x57, 0x55, 0x6c, 0x62, 0x36, 0x56, 0x69, 0x45, 0x59, 0x79, 0x5a, 0x75,
0x34, 0x58, 0x2f, 0x32, 0x33, 0x59, 0x49, 0x45, 0x36, 0x44, 0x46, 0x46,
0x53, 0x67, 0x41, 0x0a, 0x59, 0x33, 0x33, 0x63, 0x59, 0x45, 0x4a, 0x4b,
0x4b, 0x68, 0x62, 0x69, 0x4c, 0x43, 0x38, 0x44, 0x4a, 0x66, 0x35, 0x68,
0x41, 0x67, 0x4d, 0x42, 0x41, 0x41, 0x45, 0x77, 0x44, 0x51, 0x59, 0x4a,
0x4b, 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x46,
0x42, 0x51, 0x41, 0x44, 0x67, 0x67, 0x45, 0x42, 0x41, 0x45, 0x46, 0x79,
0x71, 0x5a, 0x48, 0x54, 0x65, 0x70, 0x51, 0x63, 0x0a, 0x49, 0x65, 0x32,
0x43, 0x45, 0x6b, 0x55, 0x50, 0x76, 0x35, 0x41, 0x58, 0x30, 0x6d, 0x35,
0x59, 0x43, 0x38, 0x6b, 0x2f, 0x38, 0x56, 0x6d, 0x64, 0x54, 0x2b, 0x30,
0x49, 0x78, 0x6f, 0x39, 0x47, 0x74, 0x2b, 0x79, 0x6c, 0x62, 0x62, 0x50,
0x64, 0x36, 0x6d, 0x68, 0x67, 0x6f, 0x5a, 0x49, 0x51, 0x49, 0x6c, 0x61,
0x46, 0x79, 0x4a, 0x45, 0x37, 0x54, 0x38, 0x56, 0x2b, 0x6d, 0x38, 0x76,
0x65, 0x0a, 0x77, 0x6f, 0x65, 0x47, 0x59, 0x2b, 0x68, 0x37, 0x62, 0x72,
0x76, 0x50, 0x63, 0x62, 0x51, 0x78, 0x6c, 0x34, 0x6c, 0x30, 0x52, 0x59,
0x44, 0x76, 0x30, 0x76, 0x2b, 0x2f, 0x45, 0x6e, 0x55, 0x53, 0x6e, 0x61,
0x54, 0x32, 0x69, 0x42, 0x37, 0x57, 0x34, 0x54, 0x4d, 0x33, 0x54, 0x67,
0x6a, 0x46, 0x55, 0x55, 0x50, 0x30, 0x4e, 0x42, 0x34, 0x71, 0x72, 0x74,
0x74, 0x74, 0x32, 0x37, 0x42, 0x35, 0x0a, 0x36, 0x56, 0x6d, 0x74, 0x4c,
0x36, 0x71, 0x52, 0x44, 0x30, 0x79, 0x78, 0x6b, 0x48, 0x74, 0x41, 0x33,
0x4e, 0x68, 0x42, 0x70, 0x33, 0x6f, 0x42, 0x4c, 0x4a, 0x4a, 0x47, 0x6d,
0x54, 0x46, 0x2b, 0x63, 0x30, 0x48, 0x6e, 0x63, 0x36, 0x53, 0x41, 0x38,
0x56, 0x43, 0x79, 0x67, 0x79, 0x47, 0x57, 0x4a, 0x75, 0x58, 0x68, 0x2b,
0x51, 0x46, 0x59, 0x4e, 0x30, 0x46, 0x53, 0x35, 0x41, 0x6b, 0x44, 0x0a,
0x4b, 0x46, 0x55, 0x72, 0x6e, 0x30, 0x68, 0x39, 0x7a, 0x57, 0x45, 0x57,
0x4d, 0x6c, 0x68, 0x51, 0x75, 0x63, 0x4b, 0x37, 0x76, 0x36, 0x71, 0x6f,
0x46, 0x6d, 0x53, 0x76, 0x46, 0x6c, 0x78, 0x77, 0x70, 0x70, 0x4e, 0x50,
0x63, 0x48, 0x39, 0x35, 0x31, 0x77, 0x32, 0x2f, 0x6c, 0x66, 0x4a, 0x72,
0x67, 0x61, 0x7a, 0x43, 0x55, 0x4b, 0x64, 0x5a, 0x64, 0x41, 0x30, 0x59,
0x78, 0x43, 0x7a, 0x66, 0x0a, 0x2b, 0x6b, 0x6e, 0x34, 0x75, 0x79, 0x55,
0x50, 0x6f, 0x75, 0x50, 0x38, 0x69, 0x62, 0x62, 0x57, 0x68, 0x65, 0x6c,
0x6b, 0x50, 0x7a, 0x4f, 0x76, 0x72, 0x35, 0x38, 0x66, 0x39, 0x6c, 0x63,
0x69, 0x42, 0x74, 0x42, 0x70, 0x54, 0x44, 0x38, 0x50, 0x68, 0x4e, 0x75,
0x2b, 0x64, 0x55, 0x48, 0x31, 0x30, 0x78, 0x76, 0x47, 0x6c, 0x31, 0x62,
0x47, 0x44, 0x6f, 0x6c, 0x59, 0x52, 0x64, 0x64, 0x43, 0x0a, 0x34, 0x68,
0x2f, 0x77, 0x55, 0x47, 0x58, 0x4c, 0x2f, 0x47, 0x41, 0x3d, 0x0a, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54,
0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x0a
};
unsigned int server_crt_len = 1237;
const unsigned char server_key[] = {
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x52,
0x53, 0x41, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41, 0x54, 0x45, 0x20, 0x4b,
0x45, 0x59, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x45,
0x70, 0x41, 0x49, 0x42, 0x41, 0x41, 0x4b, 0x43, 0x41, 0x51, 0x45, 0x41,
0x34, 0x36, 0x73, 0x58, 0x6b, 0x30, 0x49, 0x30, 0x4d, 0x6e, 0x64, 0x2b,
0x37, 0x2f, 0x32, 0x34, 0x4e, 0x78, 0x58, 0x61, 0x66, 0x36, 0x63, 0x50,
0x58, 0x59, 0x77, 0x6e, 0x53, 0x49, 0x6b, 0x51, 0x75, 0x61, 0x56, 0x48,
0x6f, 0x61, 0x42, 0x7a, 0x62, 0x70, 0x39, 0x57, 0x52, 0x32, 0x4c, 0x47,
0x0a, 0x78, 0x49, 0x33, 0x31, 0x53, 0x4c, 0x70, 0x2f, 0x74, 0x56, 0x4c,
0x64, 0x6d, 0x4a, 0x6a, 0x31, 0x37, 0x59, 0x58, 0x54, 0x75, 0x6c, 0x55,
0x6e, 0x76, 0x32, 0x64, 0x6a, 0x6a, 0x45, 0x48, 0x6a, 0x53, 0x72, 0x78,
0x73, 0x32, 0x58, 0x56, 0x6c, 0x44, 0x71, 0x77, 0x56, 0x46, 0x7a, 0x52,
0x78, 0x73, 0x4b, 0x65, 0x7a, 0x67, 0x2b, 0x65, 0x65, 0x47, 0x64, 0x68,
0x2b, 0x42, 0x4d, 0x52, 0x68, 0x0a, 0x2f, 0x68, 0x57, 0x66, 0x4c, 0x47,
0x42, 0x6f, 0x50, 0x65, 0x36, 0x77, 0x71, 0x66, 0x57, 0x4e, 0x30, 0x56,
0x55, 0x53, 0x62, 0x61, 0x39, 0x39, 0x4e, 0x56, 0x49, 0x61, 0x2b, 0x47,
0x39, 0x4b, 0x47, 0x48, 0x66, 0x59, 0x4f, 0x78, 0x39, 0x78, 0x73, 0x70,
0x6b, 0x4c, 0x31, 0x4d, 0x72, 0x4d, 0x33, 0x6d, 0x32, 0x72, 0x2b, 0x68,
0x79, 0x68, 0x4a, 0x4c, 0x58, 0x6c, 0x65, 0x52, 0x49, 0x48, 0x0a, 0x57,
0x4e, 0x58, 0x71, 0x45, 0x4d, 0x58, 0x68, 0x57, 0x4f, 0x75, 0x6b, 0x4d,
0x77, 0x76, 0x74, 0x43, 0x71, 0x45, 0x74, 0x72, 0x4c, 0x69, 0x64, 0x65,
0x4b, 0x64, 0x43, 0x71, 0x44, 0x6a, 0x71, 0x4c, 0x52, 0x6a, 0x5a, 0x51,
0x47, 0x43, 0x4e, 0x62, 0x6a, 0x31, 0x75, 0x38, 0x79, 0x30, 0x39, 0x61,
0x62, 0x4a, 0x69, 0x62, 0x35, 0x56, 0x45, 0x46, 0x6a, 0x58, 0x2f, 0x4b,
0x5a, 0x31, 0x52, 0x0a, 0x75, 0x6b, 0x68, 0x74, 0x4b, 0x2b, 0x37, 0x4d,
0x62, 0x32, 0x44, 0x33, 0x55, 0x56, 0x72, 0x30, 0x68, 0x45, 0x6c, 0x39,
0x61, 0x49, 0x45, 0x56, 0x64, 0x59, 0x6a, 0x6e, 0x6d, 0x68, 0x6a, 0x39,
0x77, 0x6c, 0x58, 0x55, 0x6c, 0x78, 0x71, 0x54, 0x39, 0x64, 0x52, 0x54,
0x39, 0x31, 0x56, 0x78, 0x58, 0x64, 0x31, 0x65, 0x44, 0x4a, 0x31, 0x6c,
0x4a, 0x57, 0x2b, 0x6c, 0x59, 0x68, 0x47, 0x4d, 0x0a, 0x6d, 0x62, 0x75,
0x46, 0x2f, 0x39, 0x74, 0x32, 0x43, 0x42, 0x4f, 0x67, 0x78, 0x52, 0x55,
0x6f, 0x41, 0x47, 0x4e, 0x39, 0x33, 0x47, 0x42, 0x43, 0x53, 0x69, 0x6f,
0x57, 0x34, 0x69, 0x77, 0x76, 0x41, 0x79, 0x58, 0x2b, 0x59, 0x51, 0x49,
0x44, 0x41, 0x51, 0x41, 0x42, 0x41, 0x6f, 0x49, 0x42, 0x41, 0x51, 0x43,
0x63, 0x50, 0x36, 0x58, 0x55, 0x61, 0x4e, 0x46, 0x4e, 0x2b, 0x58, 0x6a,
0x69, 0x0a, 0x32, 0x47, 0x78, 0x2f, 0x55, 0x62, 0x34, 0x39, 0x63, 0x62,
0x67, 0x33, 0x36, 0x61, 0x4a, 0x6b, 0x51, 0x37, 0x31, 0x34, 0x79, 0x35,
0x67, 0x58, 0x73, 0x76, 0x6a, 0x46, 0x36, 0x52, 0x44, 0x62, 0x75, 0x55,
0x7a, 0x56, 0x52, 0x4f, 0x41, 0x63, 0x59, 0x2f, 0x4b, 0x56, 0x7a, 0x53,
0x4e, 0x4d, 0x51, 0x56, 0x34, 0x32, 0x2f, 0x32, 0x76, 0x4b, 0x4b, 0x2f,
0x73, 0x31, 0x66, 0x34, 0x31, 0x77, 0x0a, 0x69, 0x78, 0x2b, 0x6c, 0x41,
0x53, 0x42, 0x72, 0x4e, 0x67, 0x68, 0x2f, 0x51, 0x31, 0x62, 0x4f, 0x4d,
0x43, 0x33, 0x2b, 0x6f, 0x58, 0x6d, 0x77, 0x67, 0x31, 0x75, 0x63, 0x50,
0x56, 0x70, 0x76, 0x68, 0x79, 0x41, 0x42, 0x73, 0x33, 0x45, 0x6b, 0x6b,
0x5a, 0x32, 0x35, 0x4d, 0x34, 0x47, 0x48, 0x67, 0x34, 0x45, 0x72, 0x4d,
0x34, 0x6d, 0x4d, 0x51, 0x61, 0x35, 0x61, 0x30, 0x39, 0x69, 0x79, 0x0a,
0x76, 0x42, 0x35, 0x4d, 0x49, 0x4b, 0x51, 0x45, 0x48, 0x35, 0x5a, 0x32,
0x6a, 0x6c, 0x62, 0x79, 0x57, 0x61, 0x53, 0x30, 0x32, 0x75, 0x76, 0x32,
0x6f, 0x59, 0x4e, 0x75, 0x6e, 0x79, 0x52, 0x47, 0x67, 0x30, 0x72, 0x6a,
0x6d, 0x44, 0x4e, 0x41, 0x36, 0x54, 0x69, 0x68, 0x62, 0x48, 0x50, 0x74,
0x37, 0x6f, 0x43, 0x67, 0x49, 0x48, 0x49, 0x72, 0x35, 0x6a, 0x49, 0x6e,
0x77, 0x74, 0x52, 0x48, 0x0a, 0x6f, 0x42, 0x68, 0x64, 0x74, 0x51, 0x35,
0x78, 0x71, 0x58, 0x4c, 0x44, 0x6b, 0x72, 0x36, 0x39, 0x33, 0x36, 0x6c,
0x6e, 0x4e, 0x52, 0x41, 0x46, 0x44, 0x53, 0x39, 0x7a, 0x52, 0x32, 0x61,
0x73, 0x6b, 0x48, 0x4b, 0x73, 0x49, 0x76, 0x46, 0x47, 0x66, 0x78, 0x37,
0x44, 0x63, 0x54, 0x7a, 0x57, 0x79, 0x53, 0x74, 0x78, 0x55, 0x4f, 0x74,
0x46, 0x75, 0x64, 0x2f, 0x6a, 0x67, 0x42, 0x68, 0x33, 0x0a, 0x68, 0x79,
0x43, 0x33, 0x46, 0x53, 0x75, 0x55, 0x47, 0x67, 0x42, 0x55, 0x71, 0x69,
0x39, 0x61, 0x4c, 0x37, 0x59, 0x66, 0x37, 0x45, 0x69, 0x6a, 0x52, 0x57,
0x6b, 0x39, 0x72, 0x70, 0x57, 0x45, 0x34, 0x4b, 0x4e, 0x35, 0x43, 0x4f,
0x36, 0x72, 0x4b, 0x75, 0x49, 0x5a, 0x33, 0x37, 0x62, 0x51, 0x50, 0x56,
0x47, 0x6a, 0x51, 0x5a, 0x4e, 0x4f, 0x4d, 0x36, 0x79, 0x66, 0x78, 0x66,
0x42, 0x69, 0x0a, 0x79, 0x4a, 0x79, 0x66, 0x35, 0x73, 0x62, 0x70, 0x41,
0x6f, 0x47, 0x42, 0x41, 0x50, 0x5a, 0x59, 0x30, 0x34, 0x68, 0x54, 0x42,
0x31, 0x78, 0x62, 0x46, 0x73, 0x62, 0x5a, 0x49, 0x30, 0x73, 0x2f, 0x49,
0x45, 0x43, 0x75, 0x6b, 0x64, 0x38, 0x45, 0x6d, 0x46, 0x50, 0x6e, 0x51,
0x38, 0x31, 0x4a, 0x48, 0x42, 0x76, 0x4a, 0x33, 0x6a, 0x46, 0x6e, 0x72,
0x44, 0x4f, 0x72, 0x43, 0x44, 0x70, 0x52, 0x0a, 0x57, 0x39, 0x75, 0x31,
0x46, 0x50, 0x52, 0x32, 0x48, 0x76, 0x67, 0x49, 0x4c, 0x4c, 0x46, 0x37,
0x36, 0x44, 0x39, 0x4c, 0x6e, 0x78, 0x6e, 0x4a, 0x78, 0x4e, 0x2f, 0x32,
0x73, 0x30, 0x34, 0x47, 0x49, 0x47, 0x43, 0x37, 0x6a, 0x70, 0x45, 0x39,
0x7a, 0x49, 0x67, 0x57, 0x67, 0x32, 0x72, 0x75, 0x55, 0x4b, 0x64, 0x64,
0x6b, 0x48, 0x64, 0x4e, 0x47, 0x78, 0x56, 0x39, 0x52, 0x59, 0x44, 0x30,
0x0a, 0x4a, 0x45, 0x42, 0x78, 0x30, 0x5a, 0x50, 0x61, 0x58, 0x54, 0x73,
0x39, 0x43, 0x57, 0x58, 0x4c, 0x41, 0x75, 0x65, 0x66, 0x65, 0x54, 0x2b,
0x45, 0x6c, 0x31, 0x66, 0x4d, 0x41, 0x75, 0x6d, 0x43, 0x62, 0x6f, 0x31,
0x44, 0x78, 0x45, 0x42, 0x5a, 0x75, 0x4b, 0x62, 0x72, 0x74, 0x77, 0x4e,
0x39, 0x37, 0x67, 0x68, 0x74, 0x69, 0x61, 0x50, 0x72, 0x41, 0x6f, 0x47,
0x42, 0x41, 0x4f, 0x79, 0x57, 0x0a, 0x35, 0x53, 0x6e, 0x42, 0x6f, 0x78,
0x38, 0x4c, 0x77, 0x44, 0x46, 0x49, 0x38, 0x57, 0x42, 0x77, 0x33, 0x4a,
0x6b, 0x37, 0x5a, 0x52, 0x63, 0x6d, 0x54, 0x41, 0x69, 0x44, 0x4b, 0x6b,
0x53, 0x78, 0x6d, 0x77, 0x43, 0x43, 0x64, 0x50, 0x69, 0x2b, 0x61, 0x38,
0x53, 0x63, 0x74, 0x6c, 0x42, 0x4e, 0x4c, 0x6a, 0x47, 0x31, 0x57, 0x69,
0x74, 0x34, 0x36, 0x68, 0x36, 0x6e, 0x79, 0x55, 0x75, 0x50, 0x0a, 0x75,
0x6f, 0x53, 0x41, 0x58, 0x56, 0x34, 0x32, 0x55, 0x77, 0x4b, 0x71, 0x62,
0x47, 0x37, 0x69, 0x77, 0x34, 0x70, 0x56, 0x53, 0x69, 0x54, 0x33, 0x54,
0x59, 0x37, 0x55, 0x38, 0x51, 0x72, 0x75, 0x53, 0x55, 0x38, 0x79, 0x75,
0x76, 0x32, 0x4d, 0x51, 0x30, 0x70, 0x76, 0x45, 0x70, 0x6b, 0x47, 0x43,
0x78, 0x62, 0x62, 0x4e, 0x54, 0x41, 0x58, 0x56, 0x43, 0x6c, 0x4d, 0x57,
0x34, 0x65, 0x6a, 0x0a, 0x61, 0x45, 0x43, 0x4c, 0x55, 0x49, 0x52, 0x2f,
0x56, 0x52, 0x34, 0x61, 0x36, 0x42, 0x75, 0x4a, 0x56, 0x7a, 0x48, 0x6e,
0x67, 0x65, 0x2b, 0x30, 0x33, 0x47, 0x36, 0x72, 0x63, 0x58, 0x68, 0x45,
0x51, 0x75, 0x4f, 0x36, 0x4a, 0x4b, 0x2f, 0x6a, 0x41, 0x6f, 0x47, 0x41,
0x57, 0x75, 0x54, 0x5a, 0x58, 0x2b, 0x4a, 0x71, 0x77, 0x39, 0x76, 0x6b,
0x49, 0x6f, 0x68, 0x35, 0x71, 0x6b, 0x6a, 0x6e, 0x0a, 0x61, 0x4a, 0x5a,
0x41, 0x77, 0x6b, 0x33, 0x61, 0x75, 0x70, 0x4b, 0x4a, 0x42, 0x4e, 0x53,
0x6c, 0x35, 0x32, 0x62, 0x72, 0x63, 0x63, 0x55, 0x7a, 0x31, 0x33, 0x69,
0x53, 0x74, 0x35, 0x6e, 0x50, 0x54, 0x39, 0x69, 0x58, 0x6d, 0x37, 0x39,
0x39, 0x6d, 0x37, 0x7a, 0x41, 0x61, 0x4e, 0x67, 0x30, 0x45, 0x43, 0x36,
0x68, 0x7a, 0x49, 0x30, 0x53, 0x39, 0x43, 0x50, 0x39, 0x63, 0x70, 0x74,
0x32, 0x0a, 0x46, 0x4e, 0x72, 0x2f, 0x4e, 0x6e, 0x33, 0x62, 0x32, 0x70,
0x61, 0x62, 0x39, 0x4c, 0x64, 0x72, 0x30, 0x4f, 0x55, 0x48, 0x36, 0x63,
0x7a, 0x73, 0x59, 0x6c, 0x68, 0x76, 0x62, 0x61, 0x34, 0x6e, 0x4e, 0x68,
0x51, 0x49, 0x35, 0x51, 0x6e, 0x62, 0x2f, 0x6f, 0x42, 0x39, 0x32, 0x43,
0x34, 0x34, 0x71, 0x79, 0x65, 0x2f, 0x50, 0x2f, 0x31, 0x33, 0x4c, 0x66,
0x44, 0x62, 0x58, 0x6a, 0x63, 0x2b, 0x0a, 0x2f, 0x53, 0x5a, 0x30, 0x34,
0x64, 0x31, 0x34, 0x38, 0x54, 0x58, 0x6c, 0x75, 0x41, 0x63, 0x64, 0x37,
0x63, 0x51, 0x6b, 0x31, 0x66, 0x4d, 0x43, 0x67, 0x59, 0x41, 0x31, 0x4f,
0x41, 0x51, 0x34, 0x6a, 0x6c, 0x77, 0x35, 0x49, 0x5a, 0x57, 0x4d, 0x41,
0x4a, 0x4a, 0x37, 0x56, 0x53, 0x66, 0x71, 0x4f, 0x42, 0x67, 0x58, 0x53,
0x77, 0x41, 0x54, 0x63, 0x68, 0x33, 0x52, 0x38, 0x66, 0x6d, 0x68, 0x0a,
0x39, 0x62, 0x61, 0x47, 0x4e, 0x5a, 0x39, 0x63, 0x54, 0x4c, 0x77, 0x64,
0x2b, 0x42, 0x36, 0x4b, 0x41, 0x2f, 0x64, 0x53, 0x6a, 0x42, 0x4a, 0x74,
0x37, 0x75, 0x51, 0x79, 0x34, 0x52, 0x50, 0x64, 0x74, 0x6c, 0x70, 0x4b,
0x56, 0x51, 0x48, 0x37, 0x4f, 0x59, 0x62, 0x47, 0x73, 0x71, 0x2b, 0x31,
0x73, 0x46, 0x58, 0x4c, 0x56, 0x75, 0x33, 0x56, 0x55, 0x55, 0x55, 0x66,
0x5a, 0x6c, 0x61, 0x4c, 0x0a, 0x51, 0x43, 0x67, 0x62, 0x33, 0x4b, 0x39,
0x4f, 0x55, 0x51, 0x6e, 0x6e, 0x37, 0x68, 0x6f, 0x55, 0x66, 0x42, 0x37,
0x4d, 0x77, 0x4a, 0x4b, 0x6e, 0x37, 0x34, 0x73, 0x76, 0x53, 0x61, 0x79,
0x72, 0x79, 0x43, 0x72, 0x47, 0x67, 0x7a, 0x59, 0x4d, 0x58, 0x5a, 0x55,
0x55, 0x6a, 0x4b, 0x4a, 0x57, 0x6b, 0x58, 0x4d, 0x44, 0x44, 0x72, 0x58,
0x2f, 0x46, 0x77, 0x57, 0x68, 0x50, 0x67, 0x6d, 0x6c, 0x0a, 0x33, 0x44,
0x74, 0x67, 0x62, 0x51, 0x4b, 0x42, 0x67, 0x51, 0x43, 0x59, 0x71, 0x66,
0x51, 0x4f, 0x4f, 0x50, 0x61, 0x71, 0x68, 0x2f, 0x54, 0x73, 0x4f, 0x49,
0x67, 0x73, 0x5a, 0x2f, 0x38, 0x42, 0x34, 0x68, 0x68, 0x31, 0x51, 0x33,
0x50, 0x44, 0x43, 0x33, 0x62, 0x32, 0x6d, 0x44, 0x62, 0x52, 0x5a, 0x58,
0x44, 0x36, 0x57, 0x41, 0x45, 0x56, 0x57, 0x4f, 0x41, 0x37, 0x65, 0x4b,
0x47, 0x49, 0x0a, 0x6a, 0x77, 0x55, 0x62, 0x43, 0x44, 0x4f, 0x71, 0x33,
0x41, 0x6d, 0x61, 0x7a, 0x71, 0x77, 0x45, 0x51, 0x35, 0x41, 0x68, 0x48,
0x4b, 0x50, 0x4c, 0x34, 0x4a, 0x72, 0x46, 0x35, 0x45, 0x53, 0x48, 0x6e,
0x53, 0x57, 0x43, 0x74, 0x6d, 0x62, 0x52, 0x49, 0x67, 0x55, 0x36, 0x7a,
0x53, 0x32, 0x62, 0x4d, 0x67, 0x6e, 0x42, 0x69, 0x4e, 0x62, 0x35, 0x49,
0x58, 0x55, 0x52, 0x7a, 0x2b, 0x33, 0x7a, 0x0a, 0x35, 0x73, 0x42, 0x59,
0x55, 0x76, 0x57, 0x72, 0x52, 0x38, 0x4c, 0x4a, 0x36, 0x44, 0x67, 0x51,
0x50, 0x4c, 0x70, 0x78, 0x63, 0x61, 0x7a, 0x34, 0x38, 0x6d, 0x35, 0x48,
0x47, 0x54, 0x53, 0x50, 0x70, 0x77, 0x5a, 0x35, 0x59, 0x6c, 0x56, 0x4b,
0x4d, 0x63, 0x30, 0x45, 0x77, 0x30, 0x78, 0x73, 0x32, 0x4f, 0x38, 0x77,
0x69, 0x67, 0x3d, 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e,
0x44, 0x20, 0x52, 0x53, 0x41, 0x20, 0x50, 0x52, 0x49, 0x56, 0x41, 0x54,
0x45, 0x20, 0x4b, 0x45, 0x59, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a
};
unsigned int server_key_len = 1679;
#define SERVER_CERT server_crt
#define SERVER_CERT_LENGTH server_crt_len
#define SERVER_KEY server_key
#define SERVER_KEY_LENGTH server_key_len
#endif //__REDEFINE_H__
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/common/commcloud.c
...@@ -629,6 +629,7 @@ int IOTCloudI_Firmware(void) ...@@ -629,6 +629,7 @@ int IOTCloudI_Firmware(void)
UINT32 retval = E_FAILED; UINT32 retval = E_FAILED;
cJSON *request = NULL; cJSON *request = NULL;
SendMsgUnit *sendmsg = NULL; SendMsgUnit *sendmsg = NULL;
char version[16];
//check cloud connected status //check cloud connected status
CheckCloudIfConnected(); CheckCloudIfConnected();
...@@ -649,7 +650,8 @@ int IOTCloudI_Firmware(void) ...@@ -649,7 +650,8 @@ int IOTCloudI_Firmware(void)
} }
//{"version":1000} //{"version":1000}
cJSON_AddNumberToObject(request, "version", atoi(IOTDev_AdapterVersion())); memset(version, 0, sizeof(version));
cJSON_AddNumberToObject(request, "version", atoi(IOTDev_AdapterVersion(version)));
cJSON_AddStringToObject(request, "os_version", IOTDEVICE_OSVERSION); cJSON_AddStringToObject(request, "os_version", IOTDEVICE_OSVERSION);
cJSON_AddStringToObject(request, "country_code", IOTDEVICE_COUNTRYCODE); cJSON_AddStringToObject(request, "country_code", IOTDEVICE_COUNTRYCODE);
cJSON_AddItemToObject(sendmsg->root, "request", request); cJSON_AddItemToObject(sendmsg->root, "request", request);
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/common/configdata.c
...@@ -136,30 +136,26 @@ int IOTConfRI_CertSize(void) ...@@ -136,30 +136,26 @@ int IOTConfRI_CertSize(void)
UINT32 IOTConfRI_HubType(void) UINT32 IOTConfRI_HubType(void)
{ {
return 1000102;//firmInfo.hub_type;hub type (1000101/1000102) return firmInfo.hub_type;
} }
const char *IOTConfRI_HubVendor(void) const char *IOTConfRI_HubVendor(void)
{ {
//return "lenovo rtos wifi";//firmInfo.hub_vendor;
return firmInfo.hub_vendor; return firmInfo.hub_vendor;
} }
UINT32 IOTConfRI_GadgetTypeID(void) UINT32 IOTConfRI_GadgetTypeID(void)
{ {
//return 203;//firmInfo.gadget_type_id;
return firmInfo.gadget_type_id; return firmInfo.gadget_type_id;
} }
const char *IOTConfRI_GadgetVendor(void) const char *IOTConfRI_GadgetVendor(void)
{ {
//return "lenovo plug";//firmInfo.gadget_vendor;
return firmInfo.gadget_vendor; return firmInfo.gadget_vendor;
} }
eRelLevel IOTConfRI_Cloud(void) eRelLevel IOTConfRI_Cloud(void)
{ {
//return RELEASE_LEVEL_PVT;//firmInfo.cloud;
return firmInfo.cloud; return firmInfo.cloud;
} }
...@@ -173,7 +169,6 @@ const char *IOTConfRI_CloudStr(void) ...@@ -173,7 +169,6 @@ const char *IOTConfRI_CloudStr(void)
const char *IOTConfRI_PD(char p[68]) const char *IOTConfRI_PD(char p[68])
{ {
char temp = 0; char temp = 0;
return "lenovo_rtos_wifi";
memset(p, 0, sizeof(p)); memset(p, 0, sizeof(p));
memcpy(&p[0], firmInfo.pd0, 8); memcpy(&p[8], firmInfo.pd1, 8); memcpy(&p[0], firmInfo.pd0, 8); memcpy(&p[8], firmInfo.pd1, 8);
memcpy(&p[16], firmInfo.pd2, 8); memcpy(&p[24], firmInfo.pd3, 8); memcpy(&p[16], firmInfo.pd2, 8); memcpy(&p[24], firmInfo.pd3, 8);
...@@ -191,7 +186,6 @@ const char *IOTConfRI_PD(char p[68]) ...@@ -191,7 +186,6 @@ const char *IOTConfRI_PD(char p[68])
const char *IOTConfRI_PK(char p[68]) const char *IOTConfRI_PK(char p[68])
{ {
char temp = 0; char temp = 0;
//return "5680d0b9613502e2ff8851b7ce914514";
memset(p, 0, sizeof(p)); memset(p, 0, sizeof(p));
memcpy(&p[0], firmInfo.pk0, 8); memcpy(&p[8], firmInfo.pk1, 8); memcpy(&p[0], firmInfo.pk0, 8); memcpy(&p[8], firmInfo.pk1, 8);
memcpy(&p[16], firmInfo.pk2, 8); memcpy(&p[24], firmInfo.pk3, 8); memcpy(&p[16], firmInfo.pk2, 8); memcpy(&p[24], firmInfo.pk3, 8);
...@@ -601,6 +595,72 @@ int IOTConfI_GetRefreshToken(char **token, char **spdid) ...@@ -601,6 +595,72 @@ int IOTConfI_GetRefreshToken(char **token, char **spdid)
return E_SUCCESS; return E_SUCCESS;
} }
/* ------------------------------------------------- *
* 保存内存的数据，用于热重启
* ------------------------------------------------- */
#define MEMPARAM_DATA_SIZE (512-128)
#define MEMPARAM_MAGICNUM (0xCB267FAA)
typedef struct {
UINT32 magicNumber;
int type;
char data[MEMPARAM_DATA_SIZE];
}MemParam;
int IOTConfMI_Get(int type, void *mem, int size)
{
MemParam memparam;
memset(&memparam, 0, sizeof(MemParam));
if(IOTSysP_GetMemParam((void*)&memparam, size) != E_SUCCESS) {
return E_FAILED;
}
if(memparam.magicNumber != MEMPARAM_MAGICNUM || memparam.type != type){
log_debug0("invalid data\n");
return E_INVALID;
}
if(mem != NULL && size > 0) {
memcpy(mem, memparam.data, size);
}
return E_SUCCESS;
}
int IOTConfMI_Set(int type, void *mem, int size)
{
MemParam memparam;
if(size > MEMPARAM_DATA_SIZE) {
return E_PARAM_ERROR;
}
memset(&memparam, 0, sizeof(MemParam));
memparam.magicNumber = MEMPARAM_MAGICNUM;
memparam.type = type;
if(mem != NULL && size > 0) {
memcpy(memparam.data, mem, size);
}
return IOTSysP_SetMemParam((void*)&memparam, size);
}
int IOTConfMI_Clear(void)
{
MemParam memparam;
memset(&memparam, 0, sizeof(MemParam));
return IOTSysP_SetMemParam((void*)&memparam,sizeof(MemParam));
}
int IOTConf_QuickRestart(void)
{
UINT32 magicNumber = 0x00;
if(IOTSysP_GetMemParam((void *)&magicNumber,sizeof(magicNumber)) != E_SUCCESS)
{
return 0;
}
if(magicNumber == MEMPARAM_MAGICNUM)
{
return 1;
}
return 0;
}
void IOTConfI_Exit(void) void IOTConfI_Exit(void)
{ {
if(g_access_token != NULL) { if(g_access_token != NULL) {
...@@ -637,8 +697,7 @@ int IOTConfI_Init(void) ...@@ -637,8 +697,7 @@ int IOTConfI_Init(void)
return E_FAILED; return E_FAILED;
} }
} }
printf ("sdkParam.wifiFlag %d\n", sdkParam.wifiFlag);
g_usrDataSize = sdkParam.usrDataSize <= 0 ? 0 : sdkParam.usrDataSize; g_usrDataSize = sdkParam.usrDataSize <= 0 ? 0 : sdkParam.usrDataSize;
g_wifiFlag = sdkParam.wifiFlag <= 0 ? 0 : sdkParam.wifiFlag; g_wifiFlag = sdkParam.wifiFlag <= 0 ? 0 : sdkParam.wifiFlag;
g_otaFlag = sdkParam.otaFlag <= 0 ? 0 : sdkParam.otaFlag; g_otaFlag = sdkParam.otaFlag <= 0 ? 0 : sdkParam.otaFlag;
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/common/configdata.h
...@@ -34,5 +34,14 @@ int IOTConfI_SetOtaFlag(int otaResult); ...@@ -34,5 +34,14 @@ int IOTConfI_SetOtaFlag(int otaResult);
int IOTConfI_SetRefreshToken(char *token, char *spdid); int IOTConfI_SetRefreshToken(char *token, char *spdid);
int IOTConfI_GetRefreshToken(char **token, char **spdid); int IOTConfI_GetRefreshToken(char **token, char **spdid);
/* ====================
* 内存参数读写区(热重启)
*/
#define MEMPARAM_TYPE_NONE (0)
#define MEMPARAM_TYPE_AUTH_FAILED (1)
int IOTConfMI_Get(int type, void *mem, int size);
int IOTConfMI_Set(int type, void *mem, int size);
int IOTConfMI_Clear(void);
#endif //!_CONFIGDATA_HEADER_ #endif //!_CONFIGDATA_HEADER_
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/common/devicemanager.h
...@@ -4,7 +4,7 @@ ...@@ -4,7 +4,7 @@
#include "datatype.h" #include "datatype.h"
#include "rtos.h" #include "rtos.h"
#define VERSION "0.2.0.20180606" #define VERSION "0.2.4.20180614"
typedef struct { typedef struct {
char uuid[SHORTSTRING]; char uuid[SHORTSTRING];
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/common/iotsdk.c
...@@ -13,6 +13,11 @@ void IOTConfI_Exit(void); ...@@ -13,6 +13,11 @@ void IOTConfI_Exit(void);
int IOTSDK_Init(void) int IOTSDK_Init(void)
{ {
int retval = E_FAILED; int retval = E_FAILED;
if(IOTConfRI_Cloud()==RELEASE_LEVEL_API) {
IOTDM_LogLevel(-1);
}
retval = IOTConfI_Init(); retval = IOTConfI_Init();
if(retval == E_SUCCESS) { if(retval == E_SUCCESS) {
int v1,v2,v3;char version[32]; int v1,v2,v3;char version[32];
...@@ -25,7 +30,8 @@ int IOTSDK_Init(void) ...@@ -25,7 +30,8 @@ int IOTSDK_Init(void)
os_printf("GadgetTypeID: %d\n", IOTConfRI_GadgetTypeID()); os_printf("GadgetTypeID: %d\n", IOTConfRI_GadgetTypeID());
os_printf("MAC Address : %s\n", IOTSys_Mac()); os_printf("MAC Address : %s\n", IOTSys_Mac());
os_printf("SDK Version : %s\n", version); os_printf("SDK Version : %s\n", version);
os_printf("ADA Version : %s\n", IOTDev_AdapterVersion()); memset(version, 0, sizeof(version));
os_printf("ADA Version : %s\n", IOTDev_AdapterVersion((version)));
os_printf("Server : %s\n", IOTConfRI_CloudStr()); os_printf("Server : %s\n", IOTConfRI_CloudStr());
os_printf("==========================================\n"); os_printf("==========================================\n");
} else { } else {
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/include/iotsdk_wifi.h
...@@ -11,6 +11,7 @@ typedef struct ...@@ -11,6 +11,7 @@ typedef struct
char serverlevel[8]; char serverlevel[8];
char pre_code[128]; char pre_code[128];
char time_zone[32]; char time_zone[32];
char reserved[16];
}ApInfo; }ApInfo;
int IOTWifi_Start(int force, ApInfo *apInfo); int IOTWifi_Start(int force, ApInfo *apInfo);
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/include/rtos.h
...@@ -5,10 +5,6 @@ ...@@ -5,10 +5,6 @@
#include "datatype.h" #include "datatype.h"
#include "device.h" #include "device.h"
/* Usser configure. */
/* Wifi config 512 bit (0x80000 - 0x200 ).*/
const char *IOTSys_Mac(void); const char *IOTSys_Mac(void);
void IOTSys_Reboot(void); void IOTSys_Reboot(void);
UINT32 IOTSysP_Random(int max); UINT32 IOTSysP_Random(int max);
...@@ -32,7 +28,7 @@ void IOTDev_Event(DMEvent *event); ...@@ -32,7 +28,7 @@ void IOTDev_Event(DMEvent *event);
DeviceInformation *IOTDev_DeviceInformation(void); DeviceInformation *IOTDev_DeviceInformation(void);
int IOTDev_GetAttribute(UINT32 attribute_id, OCTData *attr); int IOTDev_GetAttribute(UINT32 attribute_id, OCTData *attr);
int IOTDev_ExecuteAction(UINT32 action_id, OCTData *param); int IOTDev_ExecuteAction(UINT32 action_id, OCTData *param);
const char * IOTDev_AdapterVersion(void); const char * IOTDev_AdapterVersion(char *version);
int IOTWebsocket_Init(void); int IOTWebsocket_Init(void);
void IOTWebsocket_Exit(void); void IOTWebsocket_Exit(void);
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/leiot/datatype.h
...@@ -47,6 +47,7 @@ typedef long long INT64; ...@@ -47,6 +47,7 @@ typedef long long INT64;
#define E_WRITE (-22) #define E_WRITE (-22)
#define E_AUTH_WAIT (-23) #define E_AUTH_WAIT (-23)
#define E_ACCEPT_TEM_UNAVAIL (-24)
// release version // release version
typedef enum { typedef enum {
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/leiot/http_request.c
...@@ -107,54 +107,103 @@ static int content_length(char *buffer, ...@@ -107,54 +107,103 @@ static int content_length(char *buffer,
} }
return -1; return -1;
} }
static char *httpreq_sslreceive( static int httpreq_sslread(
SSL_Handle handle, SSL_Handle handle,
char *recv_buf, UINT32 buff_length) char *recv_buf, UINT32 buff_length,
int *content_len)
{ {
int recv_len = 0; int recv_len = 0;
int content_len = 0;
int retval = E_FAILED; int retval = E_FAILED;
log_assert(handle != NULL); log_assert(handle != NULL);
log_assert(recv_buf != NULL); log_assert(recv_buf != NULL);
log_assert(buff_length > 0); log_assert(buff_length > 0);
log_assert(content_len > 0);
recv_len = IOTSSL_Read(handle, buff_length, recv_buf); recv_len = IOTSSL_Read(handle, buff_length, recv_buf);
if(recv_len < 0) { if(recv_len <= 0) {
log_error("Read response error(%d)\n", recv_len); log_error("Read response error(%d)\n", recv_len);
goto failed; goto failed;
} }
log_debug0("recv_data: (%d)%s\n", recv_len, recv_buf); log_debug0("recv_data: (%d)%s\n", recv_len, recv_buf);
content_len = content_length(recv_buf, "Content-Length", recv_len); *content_len = content_length(recv_buf, "Content-Length", recv_len);
if(content_len < 0) { if(*content_len < 0) {
content_len = content_length(recv_buf, "content-cength", recv_len); *content_len = content_length(recv_buf, "content-cength", recv_len);
if(content_len < 0) { if(*content_len < 0) {
log_error("Get Content_Length failed\n"); log_error("Get Content_Length failed\n");
recv_len = -1;
goto failed; goto failed;
} }
} }
log_debug0("Get Content_Length: %d\n", content_len); log_debug0("Get Content_Length: %d\n", *content_len);
if(content_len > 0) { failed:
char *pbody = recv_buf + recv_len - content_len; return recv_len;
log_debug0("Get response body:%s\n", pbody); }
return pbody; static int httpreq_sslreadn(
SSL_Handle handle,
int content_len,
int read_sizemax,
writedata_cb cb, void *param)
{
int receive_size;
int receive_reseved = read_sizemax;
char *recv_buff = NULL;
log_assert(handle != NULL);
log_assert(content_len > 0);
log_assert(read_sizemax > 0);
log_assert(cb != NULL);
log_debug0("download file size=%d\n", content_len);
recv_buff = IOTM_Malloc(read_sizemax);
if(recv_buff == NULL) {
log_error("insufficient memory\n");
goto failed;
}
receive_size = (content_len >= read_sizemax)?read_sizemax:content_len;
while(1) {
int received;
// read firmware file context...
memset(recv_buff, 0, read_sizemax);
received = IOTSSL_Readn(handle, receive_size, recv_buff);
if(received <= 0) {
log_error("Read response error(%d)\n", received);
goto failed;
}
log_debug2("read (%d)..\n", received);
cb(recv_buff, received, param);
receive_reseved -= received;
log_debug2("received:%d / %d\n", receive_reseved, content_len);
if(receive_reseved == 0) {
break;
}
log_assert(receive_reseved > 0);
if(receive_reseved >= read_sizemax) {
receive_size = read_sizemax;
} else {
receive_size = receive_reseved;
}
msleep(10);
} }
return recv_buf; return E_SUCCESS;
failed: failed:
return NULL; return E_FAILED;
} }
static int iothttp_request( static int iothttp_request(
const char *server_name, int server_port, const char *server_name, int server_port,
const char *cert, const char *req_url, int req, const char *cert, const char *req_url, int req,
char **headers, char *data, int data_len, char **headers, char *data, int data_len,
char *response) char *response, int read_sizemax, writedata_cb cb, void *param)
{ {
#define HTTPS_RECEIVE_BUFFER (1024) #define HTTPS_RECEIVE_BUFFER (1024)
char *recv_buff = NULL; char *recv_buff = NULL;
char *recv_data = NULL; int recv_len = NULL;
int retval = E_FAILED; int retval = E_FAILED;
int content_len = 0;
SSL_Handle handle = NULL; SSL_Handle handle = NULL;
log_assert(req == 0 || req == 1); log_assert(req == 0 || req == 1);
...@@ -165,15 +214,16 @@ static int iothttp_request( ...@@ -165,15 +214,16 @@ static int iothttp_request(
// connect // connect
handle = IOTSSL_New(server_name, server_port, cert); handle = IOTSSL_New(server_name, server_port, cert);
if(handle == NULL) { if(handle == NULL) {
return E_FAILED; log_assert(IOTSSL_GetError() != E_SUCCESS);
return IOTSSL_GetError();
} }
// send // send request
if(httpreq_sslsend(handle, server_name, headers, req_url, req, if(httpreq_sslsend(handle, server_name, headers, req_url, req,
data, (data==NULL?0:iots_strlen(data))) != E_SUCCESS) { data, (data==NULL?0:iots_strlen(data))) != E_SUCCESS) {
log_error("Https send failed\n"); log_error("Https send failed\n");
goto failed; goto failed;
} }
// receive // receive header
recv_buff = IOTM_Malloc(HTTPS_RECEIVE_BUFFER); recv_buff = IOTM_Malloc(HTTPS_RECEIVE_BUFFER);
if(recv_buff == NULL) { if(recv_buff == NULL) {
log_error("insufficient memory\n"); log_error("insufficient memory\n");
...@@ -181,14 +231,30 @@ static int iothttp_request( ...@@ -181,14 +231,30 @@ static int iothttp_request(
} }
memset(recv_buff,0,HTTPS_RECEIVE_BUFFER); memset(recv_buff,0,HTTPS_RECEIVE_BUFFER);
recv_data = httpreq_sslreceive(handle, recv_buff, HTTPS_RECEIVE_BUFFER); recv_len = httpreq_sslread(handle, recv_buff, HTTPS_RECEIVE_BUFFER,
if(recv_data == NULL) { &content_len);
if(recv_len <= 0) {
goto failed; goto failed;
} }
log_assert(content_len >= 0);
if(response != NULL) { if(response != NULL) {
iots_strcpy(response, recv_data); if(content_len > 0) {
char *pbody = recv_buff + recv_len - content_len;
iots_strcpy(response, pbody);
} else {
iots_strcpy(response, recv_buff);
}
}
IOTM_Free(recv_buff);
recv_buff = NULL;
// download files
if(content_len > 0 && read_sizemax > 0) {
if(httpreq_sslreadn(handle, content_len, read_sizemax, cb, param) != E_SUCCESS) {
goto failed;
}
} }
retval = E_SUCCESS; retval = E_SUCCESS;
failed: failed:
if(recv_buff != NULL) { if(recv_buff != NULL) {
...@@ -208,7 +274,7 @@ int IOTHTTP_Get( ...@@ -208,7 +274,7 @@ int IOTHTTP_Get(
char **headers, char *data, int data_len, char **headers, char *data, int data_len,
char *response) char *response)
{ {
return iothttp_request(server_name, server_port, cert, req_url, 0, headers, data, data_len, response); return iothttp_request(server_name, server_port, cert, req_url, 0, headers, data, data_len, response, 0, NULL, NULL);
} }
int IOTHTTP_Post( int IOTHTTP_Post(
const char *server_name, int server_port, const char *server_name, int server_port,
...@@ -216,6 +282,13 @@ int IOTHTTP_Post( ...@@ -216,6 +282,13 @@ int IOTHTTP_Post(
char **headers, char *data, int data_len, char **headers, char *data, int data_len,
char *response) char *response)
{ {
return iothttp_request(server_name, server_port, cert, req_url, 1, headers, data, data_len, response); return iothttp_request(server_name, server_port, cert, req_url, 1, headers, data, data_len, response, 0, NULL, NULL);
} }
int IOTHTTP_Download(
const char *server_name, int server_port, const char *cert,
const char *req_url, int read_sizemax, writedata_cb cb, void *param)
{
return iothttp_request(server_name, server_port, cert, req_url, 0,
NULL, NULL, 0, NULL, read_sizemax, cb, param);
}
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/leiot/iotcommon.h
...@@ -35,6 +35,7 @@ int IOTQueue_UnitsNumber(void *Qhandle); ...@@ -35,6 +35,7 @@ int IOTQueue_UnitsNumber(void *Qhandle);
int IOTEncode_MD5(const char *inStr, unsigned int inlen, unsigned char *outStr); int IOTEncode_MD5(const char *inStr, unsigned int inlen, unsigned char *outStr);
int IOTEncode_MD5_Hex(const char *inStr, unsigned int inlen, unsigned char *outStr); int IOTEncode_MD5_Hex(const char *inStr, unsigned int inlen, unsigned char *outStr);
typedef int (*writedata_cb)(void *data, UINT32 size, void *param);
int IOTHTTP_Get(const char *server_name, int server_port, int IOTHTTP_Get(const char *server_name, int server_port,
const char *cert, const char *req_url, const char *cert, const char *req_url,
char **headers, char *data, int data_len, char **headers, char *data, int data_len,
...@@ -43,13 +44,21 @@ int IOTHTTP_Post(const char *server_name, int server_port, ...@@ -43,13 +44,21 @@ int IOTHTTP_Post(const char *server_name, int server_port,
const char *cert, const char *req_url, const char *cert, const char *req_url,
char **headers, char *data, int data_len, char **headers, char *data, int data_len,
char *response); char *response);
int IOTHTTP_Download(
const char *server_name, int server_port, const char *cert,
const char *req_url, int read_sizemax, writedata_cb cb, void *param);
typedef void* SSL_Handle; typedef void* SSL_Handle;
void IOTSSL_Destroy(SSL_Handle handle); void IOTSSL_Destroy(SSL_Handle handle);
SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert); SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert);
int IOTSSL_GetError(void);
int IOTSSL_Read(SSL_Handle handle, UINT32 read_length, void *read_buf); int IOTSSL_Read(SSL_Handle handle, UINT32 read_length, void *read_buf);
int IOTSSL_Readn(SSL_Handle handle, UINT32 read_length, void *read_buf); int IOTSSL_Readn(SSL_Handle handle, UINT32 read_length, void *read_buf);
int IOTSSL_Write(SSL_Handle handle, char *data, int data_len); int IOTSSL_Write(SSL_Handle handle, char *data, int data_len);
SSL_Handle IOTSSL_ServerNew(const char *server_ip, int server_port,
const char *cert, int cert_len, const char *key, int key_len);
int IOTSSL_ServerAccept(SSL_Handle handle);
int IOTSSL_ServerShutdown(SSL_Handle handle);
#endif //!IOT_COMMON_HEADER #endif //!IOT_COMMON_HEADER
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/leiot/ssl_api.c
...@@ -16,6 +16,7 @@ ...@@ -16,6 +16,7 @@
#define POLARSSL #define POLARSSL
#ifdef POLARSSL #ifdef POLARSSL
#include <platform/platform_stdlib.h>
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "task.h" #include "task.h"
#include "datatype.h" #include "datatype.h"
...@@ -37,9 +38,14 @@ ...@@ -37,9 +38,14 @@
#define MODULE_TAG "SSLAPI" #define MODULE_TAG "SSLAPI"
#include "log.h" #include "log.h"
#define SSL_CLIENT (1)
#define SSL_SERVER (2)
struct ssl_handle{ struct ssl_handle{
int socket; int socket;
const char *server; const char *server;
int type;
struct sockaddr_in sock_addr;
int clientfd; // for accept
#ifdef SSL_OPENSSL #ifdef SSL_OPENSSL
SSL *ssl; SSL *ssl;
SSL_CTX *ctx; SSL_CTX *ctx;
...@@ -48,17 +54,89 @@ struct ssl_handle{ ...@@ -48,17 +54,89 @@ struct ssl_handle{
#ifdef POLARSSL #ifdef POLARSSL
ssl_context *ssl; ssl_context *ssl;
char *ctx; char *ctx;
x509_crt server_x509;
pk_context server_pk;
#endif //!SSL_OPENSSL #endif //!SSL_OPENSSL
}; };
#define OPENSSL_FRAGMENT_SIZE 2048
static struct ssl_handle *ssl_servernew(const char *server_ip, int server_port)
{
int retval = E_FAILED;
struct ssl_handle *handle = NULL;
socklen_t addr_len = 0;
log_assert(server_ip != NULL);
log_assert(server_port > 0);
handle = IOTM_Malloc(sizeof(struct ssl_handle));
if(handle == NULL) {
goto failed;
}
memset(handle, 0, sizeof(struct ssl_handle));
handle->server = server_ip;
handle->socket = -1;
handle->clientfd = -1;
handle->type = SSL_SERVER;
// socket
handle->socket = socket(AF_INET, SOCK_STREAM,0);
if (handle->socket < 0 ) {
log_error("Create socket failed\n");
goto failed;
}
//============================================
{int opt = 1, flg = 0;
if(setsockopt(handle->socket, SOL_SOCKET, SO_REUSEADDR, (const void*)&opt, sizeof(opt)) < 0) {
log_error("setsockopt SOL_SOCKET SO_REUSEADDR failed\n");
}
flg = fcntl(handle->socket, F_GETFL, 0);
flg |= O_NONBLOCK;
flg |= O_NDELAY;
if(fcntl(handle->socket, F_SETFL, flg) < 0) {
log_error("fctnl failed\n");
}
}
//============================================
memset(&handle->sock_addr, 0, sizeof(handle->sock_addr));
handle->sock_addr.sin_addr.s_addr = inet_addr(server_ip);
handle->sock_addr.sin_family = AF_INET;
handle->sock_addr.sin_port = htons(server_port);
if(bind(handle->socket, (struct sockaddr*)&handle->sock_addr, sizeof(handle->sock_addr)) < 0) {
log_error("bind failed\n");
goto failed;
}
if(listen(handle->socket, 32) < 0) {
log_error("listen failed\n");
goto failed;
}
return handle;
failed:
if(handle != NULL) {
if(handle->socket > 0) {
close(handle->socket);
handle->socket = -1;
}
IOTM_Free(handle);
handle = NULL;
}
return NULL;
}
static struct ssl_handle *ssl_connect(const char *server_name, int server_port) static struct ssl_handle *ssl_connect(const char *server_name, int server_port)
{ {
int retval = E_FAILED; int retval = E_FAILED;
int certSize = 0; int certSize = 0;
char *cert = NULL; char *cert = NULL;
char server_ip[24]; char server_ip[24];
struct sockaddr_in server_addr;
struct hostent *host = NULL; struct hostent *host = NULL;
struct ssl_handle *handle = NULL; struct ssl_handle *handle = NULL;
...@@ -66,12 +144,15 @@ static struct ssl_handle *ssl_connect(const char *server_name, int server_port) ...@@ -66,12 +144,15 @@ static struct ssl_handle *ssl_connect(const char *server_name, int server_port)
log_assert(server_name != NULL); log_assert(server_name != NULL);
log_assert(server_port > 0); log_assert(server_port > 0);
handle = (struct ssl_handle*)IOTM_Malloc(sizeof(struct ssl_handle)); handle = IOTM_Malloc(sizeof(struct ssl_handle));
if(handle == NULL) { if(handle == NULL) {
goto failed; goto failed;
} }
memset(handle, 0, sizeof(struct ssl_handle)); memset(handle, 0, sizeof(struct ssl_handle));
handle->server = server_name; handle->server = server_name;
handle->socket = -1;
handle->clientfd = -1;
handle->type = SSL_CLIENT;
// get host ip // get host ip
host = gethostbyname(server_name); host = gethostbyname(server_name);
if(host == NULL) { if(host == NULL) {
...@@ -88,11 +169,11 @@ static struct ssl_handle *ssl_connect(const char *server_name, int server_port) ...@@ -88,11 +169,11 @@ static struct ssl_handle *ssl_connect(const char *server_name, int server_port)
goto failed; goto failed;
} }
// connect // connect
memset(&server_addr, 0, sizeof(server_addr)); memset(&handle->sock_addr, 0, sizeof(handle->sock_addr));
server_addr.sin_family = AF_INET; handle->sock_addr.sin_family = AF_INET;
server_addr.sin_port = htons(server_port); handle->sock_addr.sin_port = htons(server_port);
server_addr.sin_addr.s_addr = inet_addr(server_ip); handle->sock_addr.sin_addr.s_addr = inet_addr(server_ip);
if(connect(handle->socket,(struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { if(connect(handle->socket,(struct sockaddr *)&handle->sock_addr, sizeof(handle->sock_addr)) < 0) {
log_error("Connect to socket server failed\n"); log_error("Connect to socket server failed\n");
goto failed; goto failed;
} }
...@@ -110,6 +191,12 @@ failed: ...@@ -110,6 +191,12 @@ failed:
return NULL; return NULL;
} }
static int g_ssl_errno = E_FAILED;
int IOTSSL_GetError(void)
{
return g_ssl_errno;
}
#ifdef SSL_OPENSSL #ifdef SSL_OPENSSL
#define FRAGMENT_SIZE (8192) #define FRAGMENT_SIZE (8192)
...@@ -119,10 +206,17 @@ void IOTSSL_Destroy(SSL_Handle handle) ...@@ -119,10 +206,17 @@ void IOTSSL_Destroy(SSL_Handle handle)
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize()); log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
struct ssl_handle *ssl = handle; struct ssl_handle *ssl = handle;
if(ssl != NULL) { if(ssl != NULL) {
if(ssl->type == SSL_SERVER) {
IOTSSL_ServerShutdown(ssl);
}
if(ssl->ssl != NULL) { if(ssl->ssl != NULL) {
SSL_free(ssl->ssl); SSL_free(ssl->ssl);
ssl->ssl = NULL; ssl->ssl = NULL;
} }
if(ssl->clientfd > 0) {
close(ssl->clientfd);
ssl->clientfd = -1;
}
if(ssl->ctx != NULL) { if(ssl->ctx != NULL) {
SSL_CTX_free(ssl->ctx); SSL_CTX_free(ssl->ctx);
ssl->ctx = NULL; ssl->ctx = NULL;
...@@ -140,7 +234,7 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert ...@@ -140,7 +234,7 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert
{ {
struct ssl_handle *handle = NULL; struct ssl_handle *handle = NULL;
int retval = E_FAILED; int retval = E_FAILED;
int count = 0;
if(server_name == NULL || server_port < 0) { if(server_name == NULL || server_port < 0) {
log_error("Parameter error\n"); log_error("Parameter error\n");
retval = E_PARAM_ERROR; retval = E_PARAM_ERROR;
...@@ -174,11 +268,18 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert ...@@ -174,11 +268,18 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert
SSL_CTX_set_default_read_buffer_len(handle->ctx, FRAGMENT_SIZE); SSL_CTX_set_default_read_buffer_len(handle->ctx, FRAGMENT_SIZE);
// initialize ssl // initialize ssl
handle->ssl = SSL_new(handle->ctx); log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
do{
msleep(20);
log_debug0("create ssl count:%d\n", count);
handle->ssl = SSL_new(handle->ctx);
}while(handle->ssl == NULL && ++count <= 3);
if(handle->ssl == NULL ) { if(handle->ssl == NULL ) {
log_error("Create ssl failed\n"); log_error("Create ssl failed\n");
retval = E_NO_MEMORY;
goto failed; goto failed;
} }
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
SSL_set_fd(handle->ssl, handle->socket); SSL_set_fd(handle->ssl, handle->socket);
if(SSL_connect(handle->ssl) < 0) { if(SSL_connect(handle->ssl) < 0) {
...@@ -186,10 +287,12 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert ...@@ -186,10 +287,12 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert
goto failed; goto failed;
} }
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize()); log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
g_ssl_errno = E_SUCCESS;
return handle; return handle;
failed: failed:
IOTSSL_Destroy(handle); IOTSSL_Destroy(handle);
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize()); log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
g_ssl_errno = retval;
return NULL; return NULL;
} }
...@@ -279,6 +382,143 @@ failed: ...@@ -279,6 +382,143 @@ failed:
return retval; return retval;
} }
SSL_Handle IOTSSL_ServerNew(const char *server_ip, int server_port,
const char *cert, int cert_len, const char *key, int key_len)
{
struct ssl_handle *handle = NULL;
int retval = E_FAILED;
if(server_ip == NULL || server_port < 0) {
log_error("Parameter error\n");
goto failed;
}
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
// ssl handle, socket
handle = ssl_servernew(server_ip, server_port);
if(handle == NULL) {
goto failed;
}
log_assert(handle->socket >= 0);
log_assert(handle->ssl == NULL);
log_assert(handle->ctx == NULL);
// initialize ctx
SSL_library_init();
handle->ctx = SSL_CTX_new(TLSv1_1_server_method());
if(handle->ctx == NULL) {
log_error("SSL_CTX_new failed(%d)\n", errno);
goto failed;
}
if(cert != NULL && !SSL_CTX_use_certificate_ASN1(handle->ctx, cert_len, cert)) {
goto failed;
}
if(key != NULL && !SSL_CTX_use_PrivateKey_ASN1(0, handle->ctx, key, key_len)) {
goto failed;
}
SSL_CTX_set_default_read_buffer_len(handle->ctx, OPENSSL_FRAGMENT_SIZE);
retval = E_SUCCESS;
failed:
if(retval != E_SUCCESS && handle != NULL) {
IOTSSL_Destroy(handle);
handle = NULL;
}
return handle;
}
int IOTSSL_ServerAccept(SSL_Handle handle)
{
struct ssl_handle *_handle = handle;
socklen_t addr_len = 0;
int retval = E_FAILED;
if(handle == NULL) {
return E_PARAM_NULL;
}
if(_handle->socket < 0 ||
_handle->clientfd >= 0 ||
_handle->ctx == NULL) {
return E_PARAM_ERROR;
}
log_assert(_handle->socket >= 0);
log_assert(_handle->clientfd < 0);
log_assert(_handle->ctx != NULL);
// initialize ssl
if(_handle->ssl != NULL) {
SSL_free(_handle->ssl);
_handle->ssl = NULL;
}
_handle->ssl = SSL_new(_handle->ctx);
if(_handle->ssl == NULL) {
log_error("SSL_new failed(%d)\n", errno);
goto failed;
}
memset(&_handle->sock_addr, 0, sizeof(_handle->sock_addr));
_handle->clientfd = accept(_handle->socket, (struct sockaddr*)&_handle->sock_addr, &addr_len);
if (_handle->clientfd < 0) {
if(errno == 11) {
retval = E_ACCEPT_TEM_UNAVAIL;
} else {
log_error("accept failed(%d)\n", errno);
}
goto failed;
}
//============================================
{
int setval=1, keepAlive=1, keepIdle=5, keepInterval=1, keepCount=3;
if(setsockopt(_handle->clientfd, IPPROTO_TCP, TCP_NODELAY ,(const char *)&setval, sizeof(setval)) != 0 ||
setsockopt(_handle->clientfd,SOL_SOCKET , SO_KEEPALIVE ,(const char *)&keepAlive , sizeof(keepAlive)) != 0 ||
setsockopt(_handle->clientfd,IPPROTO_TCP, TCP_KEEPIDLE ,(const char *)&keepIdle , sizeof(keepIdle)) != 0 ||
setsockopt(_handle->clientfd,IPPROTO_TCP, TCP_KEEPINTVL,(const char *)&keepInterval, sizeof(keepInterval)) != 0 ||
setsockopt(_handle->clientfd,IPPROTO_TCP, TCP_KEEPCNT ,(const char *)&keepCount , sizeof(keepCount))) {
log_error("setsockopt failed(%d)\n", errno);
goto failed;
}
}
//============================================
SSL_set_fd(_handle->ssl, _handle->clientfd);
if(SSL_accept(_handle->ssl) == 0) {
log_error("SSL_accept failed(%d)\n", errno);
goto failed;
} else {
struct timeval timeout = {10,0};
setsockopt(_handle->clientfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(struct timeval));
}
return E_SUCCESS;
failed:
if(_handle->ssl != NULL) {
SSL_free(_handle->ssl);
_handle->ssl = NULL;
}
if(_handle->clientfd > 0) {
close(_handle->clientfd);
_handle->clientfd = -1;
}
return retval;
}
int IOTSSL_ServerShutdown(SSL_Handle handle)
{
struct ssl_handle *_handle = handle;
if(_handle->type == SSL_SERVER && _handle->ssl != NULL) {
SSL_shutdown(_handle->ssl);
SSL_free(_handle->ssl);
_handle->ssl = NULL;
}
if(_handle->type == SSL_SERVER && _handle->clientfd > 0) {
close(_handle->clientfd);
_handle->clientfd = -1;
}
return E_SUCCESS;
}
#endif //!SSL_OPENSSL #endif //!SSL_OPENSSL
...@@ -294,6 +534,44 @@ static int _random_func(void *p_rng, unsigned char *output, size_t output_len) ...@@ -294,6 +534,44 @@ static int _random_func(void *p_rng, unsigned char *output, size_t output_len)
ssl_context g_stSSl; ssl_context g_stSSl;
static struct ssl_handle *polarssl_servernew(const char *server_ip, int server_port)
{
int retval = E_FAILED;
struct ssl_handle *handle = NULL;
socklen_t addr_len = 0;
log_assert(server_ip != NULL);
log_assert(server_port > 0);
handle = IOTM_Malloc(sizeof(struct ssl_handle));
if(handle == NULL) {
goto failed;
}
memset(handle, 0, sizeof(struct ssl_handle));
handle->server = server_ip;
handle->socket = -1;
handle->clientfd = -1;
handle->type = SSL_SERVER;
// socket
if((retval = net_bind(&handle->socket, NULL, server_port)) != 0) {
log_error(" failed\n ! net_bind returned %d\n\n", retval);
goto failed;
}
return handle;
failed:
if(handle != NULL) {
if(handle->socket > 0) {
close(handle->socket);
handle->socket = -1;
}
IOTM_Free(handle);
handle = NULL;
}
return NULL;
}
void IOTSSL_Destroy(SSL_Handle handle) void IOTSSL_Destroy(SSL_Handle handle)
...@@ -301,11 +579,16 @@ void IOTSSL_Destroy(SSL_Handle handle) ...@@ -301,11 +579,16 @@ void IOTSSL_Destroy(SSL_Handle handle)
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize()); log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
struct ssl_handle *ssl = handle; struct ssl_handle *ssl = handle;
if(ssl != NULL) { if(ssl != NULL) {
if(ssl->type == SSL_SERVER) {
ssl_close_notify(&g_stSSl); IOTSSL_ServerShutdown(ssl);
ssl_free(&g_stSSl); }
ssl_close_notify(ssl->ssl);
if (NULL != ssl->ssl) { if (NULL != ssl->ssl) {
free(ssl->ssl); ssl_free(ssl->ssl);
}
if (NULL != ssl->ssl) {
IOTM_Free(ssl->ssl);
} }
if(ssl->socket > 0) { if(ssl->socket > 0) {
...@@ -335,25 +618,26 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert ...@@ -335,25 +618,26 @@ SSL_Handle IOTSSL_New(const char *server_name, int server_port, const char *cert
log_assert(handle->socket >= 0); log_assert(handle->socket >= 0);
memory_set_own(pvPortMalloc, vPortFree); memory_set_own(pvPortMalloc, vPortFree);
#if 0 #if 1
handle->ssl = malloc(sizeof(ssl_context)); handle->ssl = IOTM_Malloc(sizeof(ssl_context));
if (NULL == handle->ssl) { if (NULL == handle->ssl) {
log_error("IOTM_Malloc failed\n");
goto failed;
} }
memset(handle->ssl, 0, sizeof(ssl_context)); memset(handle->ssl, 0, sizeof(ssl_context));
#endif #endif
if((retval = ssl_init(&g_stSSl)) != 0){ if((retval = ssl_init(handle->ssl)) != 0){
printf("\n[WSCLIENT] ERROR: ssl_init %d\n", retval); printf("\n[WSCLIENT] ERROR: ssl_init %d\n", retval);
goto failed; goto failed;
} }
ssl_set_endpoint(&g_stSSl, 0); ssl_set_endpoint(handle->ssl, 0);
ssl_set_authmode(&g_stSSl, 0); ssl_set_authmode(handle->ssl, 0);
ssl_set_rng(&g_stSSl, _random_func, NULL); ssl_set_rng(handle->ssl, _random_func, NULL);
ssl_set_bio(&g_stSSl, net_recv, &(handle->socket), net_send, &(handle->socket)); ssl_set_bio(handle->ssl, net_recv, &(handle->socket), net_send, &(handle->socket));
if((retval = ssl_handshake(&g_stSSl)) != 0) { if((retval = ssl_handshake(handle->ssl)) != 0) {
printf(" failed ssl_handshake returned %d\n\n", retval); printf(" failed ssl_handshake returned %d\n\n", retval);
goto failed; goto failed;
} else { } else {
...@@ -412,7 +696,7 @@ int IOTSSL_Read( ...@@ -412,7 +696,7 @@ int IOTSSL_Read(
} }
do { do {
nread = ssl_read(&g_stSSl, read_buf, read_length); nread = ssl_read(sslhandle->ssl, read_buf, read_length);
if(nread >= 0) { if(nread >= 0) {
break; break;
} }
...@@ -437,7 +721,7 @@ int IOTSSL_Write(SSL_Handle handle, char *data, int data_len) ...@@ -437,7 +721,7 @@ int IOTSSL_Write(SSL_Handle handle, char *data, int data_len)
goto failed; goto failed;
} }
//printf("IOTSSL_Write %s(len=%d)\n", data, data_len); //printf("IOTSSL_Write %s(len=%d)\n", data, data_len);
if(ssl_write(&g_stSSl, data, data_len) != data_len) { if(ssl_write(sslhandle->ssl, data, data_len) != data_len) {
log_error("SSL_write failed\n"); log_error("SSL_write failed\n");
goto failed; goto failed;
} }
...@@ -446,5 +730,178 @@ failed: ...@@ -446,5 +730,178 @@ failed:
return retval; return retval;
} }
SSL_Handle IOTSSL_ServerNew(const char *server_ip, int server_port,
const char *cert, int cert_len, const char *key, int key_len)
{
struct ssl_handle *handle = NULL;
int retval = E_FAILED;
x509_crt server_x509;
pk_context server_pk;
if(server_ip == NULL || server_port < 0) {
log_error("Parameter error\n");
goto failed;
}
log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
// ssl handle, socket
handle = polarssl_servernew(server_ip, server_port);
if(handle == NULL) {
goto failed;
}
log_assert(handle->socket >= 0);
log_assert(handle->ssl == NULL);
memory_set_own(pvPortMalloc, vPortFree);
memset(&(handle->server_x509), 0, sizeof(x509_crt));
memset(&(handle->server_pk), 0, sizeof(pk_context));
memset(handle->ssl, 0, sizeof(ssl_context));
/*
* 1. Prepare the certificate and key
*/
printf("\n\r . Preparing the certificate and key...");
x509_crt_init(&(handle->server_x509));
pk_init(&(handle->server_pk));
if((retval = x509_crt_parse(&(handle->server_x509), (const unsigned char *)test_srv_crt, strlen(test_srv_crt))) != 0) {
log_error(" failed\n ! x509_crt_parse returned %d\n\n", retval);
goto failed;
}
if((retval = x509_crt_parse(&(handle->server_x509), (const unsigned char *)test_ca_list, strlen(test_ca_list))) != 0) {
log_error(" failed\n ! x509_crt_parse returned %d\n\n", retval);
goto failed;
}
if((retval = pk_parse_key(&(handle->server_pk), test_srv_key, strlen(test_srv_key), NULL, 0)) != 0) {
log_error(" failed\n ! pk_parse_key returned %d\n\n", retval);
goto failed;
}
retval = E_SUCCESS;
failed:
if(retval != E_SUCCESS && handle != NULL) {
IOTSSL_Destroy(handle);
handle = NULL;
}
return handle;
}
int IOTSSL_ServerAccept(SSL_Handle handle)
{
struct ssl_handle *_handle = handle;
socklen_t addr_len = 0;
int retval = E_FAILED;
log_error("enter IOTSSL_ServerAccept\n");
if(handle == NULL) {
log_error("enter IOTSSL_ServerAccept 1\n");
return E_PARAM_NULL;
}
if(_handle->socket < 0 ||
_handle->clientfd >= 0) {
log_error("enter IOTSSL_ServerAccept 2\n");
return E_PARAM_ERROR;
}
log_assert(_handle->socket >= 0);
log_assert(_handle->clientfd < 0);
// initialize ssl
if(_handle->ssl != NULL) {
ssl_free(_handle->ssl);
_handle->ssl = NULL;
}
_handle->ssl = IOTM_Malloc(sizeof(ssl_context));
if (NULL == _handle->ssl) {
log_error("IOTM_Malloc failed\n");
goto failed;
}
if((retval = ssl_init(_handle->ssl)) != 0) {
printf(" failed\n ! ssl_init returned %d\n\n", retval);
goto failed;
}
ssl_set_endpoint(_handle->ssl, SSL_IS_SERVER);
ssl_set_ca_chain(_handle->ssl, _handle->server_x509.next, NULL, NULL);
ssl_set_authmode(_handle->ssl, SSL_VERIFY_NONE);
ssl_set_rng(_handle->ssl, _random_func, NULL);
if (retval = net_accept(_handle->socket, &_handle->clientfd, NULL) == 0) {
log_debug0("\n\r . A client is connecting\n\r");
} else {
log_error("enter IOTSSL_ServerAccept 3\n");
}
if (_handle->clientfd < 0) {
if(errno == 11) {
retval = E_ACCEPT_TEM_UNAVAIL;
} else {
log_error("accept failed(%d)\n", errno);
}
goto failed;
}
//============================================
{
int setval=1, keepAlive=1, keepIdle=5, keepInterval=1, keepCount=3;
if(setsockopt(_handle->clientfd, IPPROTO_TCP, TCP_NODELAY ,(const char *)&setval, sizeof(setval)) != 0 ||
setsockopt(_handle->clientfd,SOL_SOCKET , SO_KEEPALIVE ,(const char *)&keepAlive , sizeof(keepAlive)) != 0 ||
setsockopt(_handle->clientfd,IPPROTO_TCP, TCP_KEEPIDLE ,(const char *)&keepIdle , sizeof(keepIdle)) != 0 ||
setsockopt(_handle->clientfd,IPPROTO_TCP, TCP_KEEPINTVL,(const char *)&keepInterval, sizeof(keepInterval)) != 0 ||
setsockopt(_handle->clientfd,IPPROTO_TCP, TCP_KEEPCNT ,(const char *)&keepCount , sizeof(keepCount))) {
log_error("setsockopt failed(%d)\n", errno);
goto failed;
}
}
//============================================
ssl_set_bio(_handle->ssl, net_recv, &(_handle->clientfd), net_send, &(_handle->clientfd));
if((retval = ssl_set_own_cert(_handle->ssl, &(_handle->server_x509), &(_handle->server_pk))) != 0) {
printf(" failed\n ! ssl_set_own_cert returned %d\n\n", retval);
goto failed;
}
if((retval = ssl_handshake(_handle->ssl)) != 0) {
printf(" failed\n ! ssl_handshake returned %d\n\n", retval);
goto failed;
} else {
struct timeval timeout = {10,0};
setsockopt(_handle->clientfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(struct timeval));
}
log_debug0("Ssl connect OK\n");
return E_SUCCESS;
failed:
if(_handle->ssl != NULL) {
ssl_free(_handle->ssl);
_handle->ssl = NULL;
}
if(_handle->clientfd > 0) {
close(_handle->clientfd);
_handle->clientfd = -1;
}
return retval;
}
int IOTSSL_ServerShutdown(SSL_Handle handle)
{
struct ssl_handle *_handle = handle;
if(_handle->type == SSL_SERVER && _handle->ssl != NULL) {
ssl_close_notify(_handle->ssl);
ssl_free(_handle->ssl);
IOTM_Free(_handle->ssl);
_handle->ssl = NULL;
}
if(_handle->type == SSL_SERVER && _handle->clientfd > 0) {
close(_handle->clientfd);
_handle->clientfd = -1;
}
return E_SUCCESS;
}
#endif //!SSL_OPENSSL #endif //!SSL_OPENSSL
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/ota/ota.c
...@@ -26,6 +26,7 @@ ...@@ -26,6 +26,7 @@
#include "log.h" #include "log.h"
#include "md5c.h" #include "md5c.h"
#include "commcloud.h" #include "commcloud.h"
#include "iotcommon.h"
#include "security_func.h" #include "security_func.h"
...@@ -45,42 +46,16 @@ ...@@ -45,42 +46,16 @@
#define OTA_FW_RECV_BUFLEN (512) #define OTA_FW_RECV_BUFLEN (512)
#define HTTPS_CONTEXT_MAXLEN (512) #define HTTPS_CONTEXT_MAXLEN (512)
#define FRAGMENT_SIZE (8192)
#define HTTPS 1 #define OTA_SERVER_PORT (443)
int IOTConfRI_GetCert(void *buf,int bufSize);
int IOTConfRI_CertSize(void);
static int g_firmFlag = E_SUCCESS; static int g_firmFlag = E_SUCCESS;
static const char *g_check_version_url = "/v2.0/ota/check_update_version"; static const char *g_check_version_url = "/v2.0/ota/check_update_version";
//static const char *g_doneload_result_url = "/v2.0/third_download_result"; //static const char *g_doneload_result_url = "/v2.0/third_download_result";
//static const char *g_upgrade_rusult_url = "/v2.0/third_update_result"; //static const char *g_upgrade_rusult_url = "/v2.0/third_update_result";
static const int g_server_port = 443;
static int g_socket = -1;
ssl_context stSSL;
char *strip_blank(char *buf, int len)
{
char *buf1 = NULL;
int i, j;
len += 1; // '\0'
buf1 = malloc(len);
if (!buf1)
return NULL;
// Strip the blanks.
memset(buf1, 0, len);
for (i = 0, j = 0; i < len; i++) {
if (buf[i] != 0x20)
buf1[j++] = buf[i];
}
memcpy(buf, buf1, j+1);
free(buf1);
return buf;
}
//static SSL_CTX *g_ctx = NULL;
typedef enum{e_get,e_post} g_req; typedef enum{e_get,e_post} g_req;
...@@ -92,11 +67,8 @@ void TimerCallBack(void *arg) ...@@ -92,11 +67,8 @@ void TimerCallBack(void *arg)
IOTSys_Reboot(); IOTSys_Reboot();
} }
static void iotota_Disconnect(void);
static int Get_Server_IP(const char *server_name/*in*/,char * server_ip/*out*/) static int Get_Server_IP(const char *server_name/*in*/,char * server_ip/*out*/)
{ {
#if 1
struct hostent *host = NULL; struct hostent *host = NULL;
host = gethostbyname(server_name); host = gethostbyname(server_name);
if(host != NULL ) if(host != NULL )
...@@ -106,118 +78,74 @@ static int Get_Server_IP(const char *server_name/*in*/,char * server_ip/*out*/) ...@@ -106,118 +78,74 @@ static int Get_Server_IP(const char *server_name/*in*/,char * server_ip/*out*/)
return E_SUCCESS; return E_SUCCESS;
} }
log_error("Get the ip of\" %s\" failed\n",server_name); log_error("Get the ip of\" %s\" failed\n",server_name);
#endif
return E_FAILED; return E_FAILED;
} }
static int _random_func(void *p_rng, unsigned char *output, size_t output_len)
{
rtw_get_random_bytes(output, output_len);
return 0;
}
static int iotota_Connect(const char *server_name, int server_port) static SSL_Handle iotota_Connect(const char *server_name, int server_port)
{ {
int retval = E_FAILED; int retval = E_FAILED;
int cert_len = 0; int certSize = 0;
char server_ip[24]; char *cert = NULL;
struct sockaddr_in server_addr; SSL_Handle handle = NULL;
#if HTTPS
int iRet = -1;
memory_set_own(pvPortMalloc, vPortFree);
#endif
if(server_name == NULL || server_port < 0) if(server_name == NULL || server_port < 0)
{ {
log_error("Parameter error\n"); log_error("Parameter error\n");
goto failed; goto failed;
} }
memset(server_ip,0,sizeof(server_ip)); certSize = IOTConfRI_CertSize();
memset(&server_addr, 0, sizeof(server_addr)); if(certSize <= 0 || certSize >= 4096)
if(Get_Server_IP(server_name,server_ip) < 0)
{ {
log_error("Get ota server ip failed\n"); log_error("Get CertSize error(%d)\n",certSize);
goto failed; goto failed;
} }
cert = IOTM_Malloc(certSize + 1);
g_socket = socket(AF_INET, SOCK_STREAM,0); if(cert == NULL)
if (g_socket < 0 )
{ {
log_error("Create socket failed\n"); log_error("insufficient memory\n");
goto failed; goto failed;
} }
memset(cert,0,certSize + 1);
server_addr.sin_family = AF_INET; if(IOTConfRI_GetCert(cert,certSize + 1) != E_SUCCESS)
server_addr.sin_port = htons(server_port);
server_addr.sin_addr.s_addr = inet_addr(server_ip);
if(connect(g_socket,(struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
{ {
log_error("Connect to socket server failed\n"); log_error("Get root cert failed\n");
goto failed; goto failed;
} }
#if HTTPS
printf("Available heap [0x%x]\n", xPortGetFreeHeapSize());
if((iRet = ssl_init(&stSSL)) != 0){
printf("\n[WSCLIENT] ERROR: ssl_init %d\n", iRet);
goto failed;
}
ssl_set_endpoint(&stSSL, 0);
ssl_set_authmode(&stSSL, 0);
ssl_set_rng(&stSSL, _random_func, NULL);
ssl_set_bio(&stSSL, net_recv, &g_socket, net_send, &g_socket);
if((iRet = ssl_handshake(&stSSL)) != 0) {
printf(" failed ssl_handshake returned %d\n\n", iRet);
goto failed;
} else {
printf(" SSL handshake OK\n\n");
}
#endif
retval = E_SUCCESS;
return retval;
failed:
iotota_Disconnect();
return retval; handle = IOTSSL_New(server_name, server_port, cert);
} if(handle == NULL) {
log_error("IOTSSL_New failed\n");
goto failed;
}
static void iotota_Disconnect(void) log_debug0("[%s][%d][size=%u]\n",__FUNCTION__,__LINE__,IOTSysP_GetFreeHeapSize());
{ log_debug0("SSL connect to server ok\n");
retval = E_SUCCESS;
if(&stSSL != NULL) { failed:
ssl_close_notify(&stSSL); if(cert != NULL) {
ssl_free(&stSSL); IOTM_Free(cert);
cert = NULL;
} }
if(retval != E_SUCCESS && handle != NULL) {
if(g_socket >= 0) { IOTSSL_Destroy(handle);
close(g_socket); handle = NULL;
g_socket = -1;
} }
return handle;
} }
static int Https_Send(ssl_context *ssl,const char *server_name,const char *url, char *data,int data_len,g_req req ) static int Https_Send(SSL_Handle handle,const char *server_name,const char *url, char *data,int data_len,g_req req )
{ {
char *context = NULL; char *context = NULL;
char *tempbuf = NULL; char *tempbuf = NULL;
int tempsize = 256; int tempsize = 256;
int retval = E_FAILED; int retval = E_FAILED;
if(NULL == url || NULL == server_name ) log_assert(handle != NULL);
{ log_assert(url != NULL);
log_error("Parameter error\n"); log_assert(server_name != NULL);
goto failed;
}
context = (char *)IOTM_Malloc(HTTPS_CONTEXT_MAXLEN); context = (char *)IOTM_Malloc(HTTPS_CONTEXT_MAXLEN);
if(NULL == context) { if(NULL == context) {
...@@ -264,7 +192,7 @@ static int Https_Send(ssl_context *ssl,const char *server_name,const char *url, ...@@ -264,7 +192,7 @@ static int Https_Send(ssl_context *ssl,const char *server_name,const char *url,
} }
log_debug0("\nHttps Request:\n%s\r\n",context); log_debug0("\nHttps Request:\n%s\r\n",context);
if(ssl_write(ssl, context, iots_strlen(context)) != iots_strlen(context)) if(IOTSSL_Write(handle,context, iots_strlen(context)) != E_SUCCESS)
{ {
log_error("Https client send failed\n"); log_error("Https client send failed\n");
goto failed; goto failed;
...@@ -284,7 +212,7 @@ failed: ...@@ -284,7 +212,7 @@ failed:
return retval; return retval;
} }
static int SSL_Readn(ssl_context *ssl, void *pbuf,unsigned int leng_byte,unsigned int maxlen) static int SSL_Readn(SSL_Handle handle, void *pbuf,unsigned int leng_byte,unsigned int maxlen)
{ {
int nleft = 0; //usigned int 剩余未读取的字节数 int nleft = 0; //usigned int 剩余未读取的字节数
int nread = 0; //int 实际读到的字节数 int nread = 0; //int 实际读到的字节数
...@@ -295,25 +223,21 @@ static int SSL_Readn(ssl_context *ssl, void *pbuf,unsigned int leng_byte,unsigne ...@@ -295,25 +223,21 @@ static int SSL_Readn(ssl_context *ssl, void *pbuf,unsigned int leng_byte,unsigne
while (nleft > 0) while (nleft > 0)
{ {
nread = ssl_read(ssl, ptr, nleft); nread = IOTSSL_Read(handle,nleft,ptr);
if(nread < 0) if(nread < 0)
{ {
log_debugx("get error code(%d)\n",nread); HasRead = 0;
if (errno == EINTR) { return -1;
nread = 0; }
} else if(nread == 0)
else { {
HasRead = 0;
return -1;
}
} else if(nread == 0) {
break; break;
} }
nleft -= nread; nleft -= nread;
ptr += nread; ptr += nread;
HasRead += nread; HasRead += nread;
if(HasRead == maxlen) { if(HasRead == maxlen)
{
HasRead = 0; HasRead = 0;
break; break;
} }
...@@ -332,7 +256,6 @@ static int Get_Content_Length(char *buffer,const char *substr,int length) ...@@ -332,7 +256,6 @@ static int Get_Content_Length(char *buffer,const char *substr,int length)
char *pbuf = buffer; char *pbuf = buffer;
int len = length; int len = length;
int Content_Length = 0; int Content_Length = 0;
//strip_blank(buffer, length);
while(1) while(1)
{ {
ptr = memchr(pbuf,substr[0],len); ptr = memchr(pbuf,substr[0],len);
...@@ -353,7 +276,7 @@ static int Get_Content_Length(char *buffer,const char *substr,int length) ...@@ -353,7 +276,7 @@ static int Get_Content_Length(char *buffer,const char *substr,int length)
} }
} }
static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const char *url,const char *md5) static int iotota_UpgradeStart(SSL_Handle handle,const char *server_name,const char *url,const char *md5)
{ {
int retval = E_FAILED; int retval = E_FAILED;
int read_len = 0; int read_len = 0;
...@@ -362,23 +285,21 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch ...@@ -362,23 +285,21 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch
int Content_Length = 0; int Content_Length = 0;
char *data_buf = NULL; char *data_buf = NULL;
char *tempbuf = NULL; char *tempbuf = NULL;
MD5_CTX ctx;
//timer_t timer; //timer_t timer;
if(url == NULL || ssl == NULL || server_name == NULL || md5 == NULL )
{
log_error("parameter error\n");
goto failed;
}
if(Https_Send(ssl,server_name,url, NULL,0,e_get) != E_SUCCESS) log_assert(handle != NULL);
log_assert(url != NULL);
log_assert(server_name != NULL);
log_assert(md5 != NULL);
if(Https_Send(handle,server_name,url, NULL,0,e_get) != E_SUCCESS)
{ {
log_error(" send OTA request failed\n"); log_error(" send OTA request failed\n");
goto failed; goto failed;
} }
log_debug0("Request success\n"); log_debug0("Request success\n");
//memset(&timer,0,sizeof(timer)); //memset(&timer,0,sizeof(timer));
data_buf = (char *)IOTM_Malloc(OTA_FW_RECV_BUFLEN); data_buf = IOTM_Malloc(OTA_FW_RECV_BUFLEN);
if(data_buf == NULL) if(data_buf == NULL)
{ {
log_error("insufficient memory\n"); log_error("insufficient memory\n");
...@@ -389,7 +310,7 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch ...@@ -389,7 +310,7 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch
IOTOtaP_ReceiveDataPrepare(); IOTOtaP_ReceiveDataPrepare();
//recv https head //recv https head
head_len = ssl_read(ssl,data_buf,OTA_FW_RECV_BUFLEN - 1); head_len = IOTSSL_Read(handle,OTA_FW_RECV_BUFLEN-1,data_buf);
if (head_len>0) if (head_len>0)
{ {
log_debug2("=== head len:%d ===\n",head_len); log_debug2("=== head len:%d ===\n",head_len);
...@@ -412,7 +333,10 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch ...@@ -412,7 +333,10 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch
goto failed; goto failed;
} }
unsigned char sout[MD5_HASHBYTES]; MD5_CTX ctx;
unsigned char sout[MD5_HASHBYTES];
memset(&ctx,0,sizeof(ctx));
memset(&sout,0,MD5_HASHBYTES); memset(&sout,0,MD5_HASHBYTES);
MD5Init(&ctx); MD5Init(&ctx);
...@@ -420,9 +344,9 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch ...@@ -420,9 +344,9 @@ static int iotota_UpgradeStart(ssl_context *ssl,const char *server_name,const ch
{ {
// read firmware file context... // read firmware file context...
memset(data_buf,0,OTA_FW_RECV_BUFLEN); memset(data_buf,0,OTA_FW_RECV_BUFLEN);
//IOTDM_TimerStart(&timer,5000,TimerCallBack,NULL,0); //IOTSysP_TimerStart(&timer,5000,TimerCallBack,NULL,0);
read_len = SSL_Readn(ssl, data_buf,OTA_FW_RECV_BUFLEN - 1,Content_Length); read_len = SSL_Readn(handle, data_buf,OTA_FW_RECV_BUFLEN - 1,Content_Length);
//IOTDM_TimerStop(&timer); //IOTSysP_TimerStop(&timer);
log_debug2("read (%d)..\n", read_len); log_debug2("read (%d)..\n", read_len);
if( read_len > 0 ) if( read_len > 0 )
{ {
...@@ -480,9 +404,7 @@ failed: ...@@ -480,9 +404,7 @@ failed:
return retval; return retval;
} }
//static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,const char *url,char **pbuf/*out*/,char *md5/*out*/) static int iotota_CheckUpdateVersion(SSL_Handle handle,const char *server_name,const char *url,UINT32 version,char **pbuf/*out*/,char *md5/*out*/)
static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,const char *url,UINT32 version,char **pbuf/*out*/,char *md5/*out*/)
{ {
int Content_Length = 0; int Content_Length = 0;
int new_version = 0; int new_version = 0;
...@@ -497,11 +419,11 @@ static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,co ...@@ -497,11 +419,11 @@ static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,co
char *temp = NULL; char *temp = NULL;
int retval = E_FAILED; int retval = E_FAILED;
if (ssl == NULL || server_name == NULL || url == NULL || pbuf == NULL || md5 == NULL) log_assert(handle != NULL);
{ log_assert(server_name != NULL);
log_error("Parameter error\n"); log_assert(url != NULL);
goto failed; log_assert(pbuf != NULL);
} log_assert(md5 != NULL);
root = cJSON_CreateObject(); root = cJSON_CreateObject();
if(root == NULL) if(root == NULL)
...@@ -535,7 +457,7 @@ static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,co ...@@ -535,7 +457,7 @@ static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,co
cJSON_Delete(root);root = NULL; cJSON_Delete(root);root = NULL;
int data_len = iots_strlen(data); int data_len = iots_strlen(data);
log_debug0("Json data len:%d\n",data_len); log_debug0("Json data len:%d\n",data_len);
if(Https_Send(ssl,server_name,url,data,iots_strlen(data),e_post) != E_SUCCESS) if(Https_Send(handle,server_name,url,data,iots_strlen(data),e_post) != E_SUCCESS)
{ {
log_error("Https send failed\n"); log_error("Https send failed\n");
goto failed; goto failed;
...@@ -549,7 +471,7 @@ static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,co ...@@ -549,7 +471,7 @@ static int iotota_CheckUpdateVersion(ssl_context *ssl,const char *server_name,co
goto failed; goto failed;
} }
memset(recv_buf,0,1024 * 1); memset(recv_buf,0,1024 * 1);
int recv_len = ssl_read(ssl,recv_buf,1024 * 1); int recv_len = IOTSSL_Read(handle,1024 * 1,recv_buf);
if (recv_len < 0) if (recv_len < 0)
{ {
log_error("Read response error\n"); log_error("Read response error\n");
...@@ -737,7 +659,7 @@ static int iotota_ReportDoneloadResult(SSL *ssl,const char *server_name,const ch ...@@ -737,7 +659,7 @@ static int iotota_ReportDoneloadResult(SSL *ssl,const char *server_name,const ch
goto failed; goto failed;
} }
memset(recv_buf,0,1024 * 1); memset(recv_buf,0,1024 * 1);
int recv_len = ssl_read(ssl,recv_buf,1024 * 1); int recv_len = SSL_read(ssl,recv_buf,1024 * 1);
if (recv_len < 0) if (recv_len < 0)
{ {
log_error("Read response failed\n"); log_error("Read response failed\n");
...@@ -951,13 +873,15 @@ int IOTOTAI_StatusCheck(void) ...@@ -951,13 +873,15 @@ int IOTOTAI_StatusCheck(void)
{ {
UINT32 fwVersion = 0; UINT32 fwVersion = 0;
int otaflag = 0; int otaflag = 0;
char version[16];
otaflag = IOTConfI_GetOtaFlag(); otaflag = IOTConfI_GetOtaFlag();
log_debug0("ota flag:%d\n",otaflag); log_debug0("ota flag:%d\n",otaflag);
if(otaflag > 0 && otaflag <= 3) if(otaflag > 0 && otaflag <= 3)
{ {
log_debug0("Go on to ota %dtimes\n", otaflag); log_debug0("Go on to ota %dtimes\n", otaflag);
if(sscanf(IOTDev_AdapterVersion(),"%u",&fwVersion) == -1) memset(version, 0, sizeof(version));
if(sscanf(IOTDev_AdapterVersion(version),"%u",&fwVersion) == -1)
{ {
log_error("Change version to UINT32 failed\n"); log_error("Change version to UINT32 failed\n");
fwVersion = 0; fwVersion = 0;
...@@ -978,6 +902,7 @@ int IOTOTAI_Start(UINT32 version) ...@@ -978,6 +902,7 @@ int IOTOTAI_Start(UINT32 version)
char *fw_server_url = NULL; // "webpage/rtk/ota_all.bin"; char *fw_server_url = NULL; // "webpage/rtk/ota_all.bin";
char *md5 = NULL; char *md5 = NULL;
const char *server_name = NULL; const char *server_name = NULL;
SSL_Handle handle = NULL;
DMEvent event; DMEvent event;
memset(&event,0,sizeof(event)); memset(&event,0,sizeof(event));
...@@ -992,18 +917,19 @@ int IOTOTAI_Start(UINT32 version) ...@@ -992,18 +917,19 @@ int IOTOTAI_Start(UINT32 version)
} }
IOTOtaP_Prepare(); IOTOtaP_Prepare();
//ready source //ready source
md5 = (char *)IOTM_Malloc(OTA_FW_MD5_BUFLEN); md5 = IOTM_Malloc(OTA_FW_MD5_BUFLEN);
if(md5 == NULL ) if(md5 == NULL )
{ {
log_error("insufficient memory\n"); log_error("insufficient memory\n");
goto failed; goto failed;
} }
memset(md5,0,OTA_FW_MD5_BUFLEN); memset(md5,0,OTA_FW_MD5_BUFLEN);
server_name = IOTCloudI_GetOtaUrl();
log_assert(server_name != NULL);
server_name = IOTCloudI_GetOtaUrl();
log_assert(server_name != NULL);
//https connect 1st //https connect 1st
if(iotota_Connect(server_name,g_server_port) != E_SUCCESS) handle = iotota_Connect(server_name,OTA_SERVER_PORT);
if(handle == NULL)
{ {
log_error(" OTA connect failed\n"); log_error(" OTA connect failed\n");
goto failed; goto failed;
...@@ -1011,7 +937,7 @@ int IOTOTAI_Start(UINT32 version) ...@@ -1011,7 +937,7 @@ int IOTOTAI_Start(UINT32 version)
log_debug0("OTA connect success\n"); log_debug0("OTA connect success\n");
//POST request,fetch host url and md5,save host+url to pbuf //POST request,fetch host url and md5,save host+url to pbuf
if(iotota_CheckUpdateVersion(&stSSL,server_name,g_check_version_url,version,&pbuf,md5) != E_SUCCESS) if(iotota_CheckUpdateVersion(handle,server_name,g_check_version_url,version,&pbuf,md5) != E_SUCCESS)
{ {
log_error("Check OTA fireware version failedd\n"); log_error("Check OTA fireware version failedd\n");
goto failed; goto failed;
...@@ -1024,24 +950,23 @@ int IOTOTAI_Start(UINT32 version) ...@@ -1024,24 +950,23 @@ int IOTOTAI_Start(UINT32 version)
log_error("Parse url failed\n"); log_error("Parse url failed\n");
goto failed; goto failed;
} }
//fw_server_name="deviot.lenovo.com.cn";
log_debug0("firmware host_name:%s\n",fw_server_name); //fw_server_url="webpage/rtk/ota_all.bin";
log_debug0("firmware url:%s\n",fw_server_url); log_debug0("firmware host_name:%s,url:%s\n",fw_server_name,fw_server_url);
IOTSSL_Destroy(handle);
log_debug0("SSL disconnect......\n"); handle = NULL;
iotota_Disconnect();
//https connect 2st //https connect 2st
if(iotota_Connect(fw_server_name,g_server_port) != E_SUCCESS) handle = iotota_Connect(fw_server_name,OTA_SERVER_PORT);
if(handle == NULL)
{ {
log_error(" OTA connect failed\n"); log_error(" OTA connect failed\n");
goto failed; goto failed;
} }
log_debug0("OTA connect success\n"); log_debug0("OTA connect2 success\n");
//GET request,fetch firmware //GET request,fetch firmware
//if(iotota_UpgradeStart(&stSSL, "deviot.lenovo.com.cn", "webpage/rtk/ota_all.bin", md5) != E_SUCCESS) if(iotota_UpgradeStart(handle,fw_server_name,fw_server_url,md5) != E_SUCCESS)
if(iotota_UpgradeStart(&stSSL, fw_server_name,fw_server_url,md5) != E_SUCCESS)
{ {
log_error(" Https OTA upgrade fail!!\n"); log_error(" Https OTA upgrade fail!!\n");
goto failed; goto failed;
...@@ -1049,7 +974,10 @@ int IOTOTAI_Start(UINT32 version) ...@@ -1049,7 +974,10 @@ int IOTOTAI_Start(UINT32 version)
retval = E_SUCCESS; retval = E_SUCCESS;
failed: failed:
iotota_Disconnect(); if(handle != NULL) {
IOTSSL_Destroy(handle);
handle = NULL;
}
if(pbuf != NULL) if(pbuf != NULL)
{ {
IOTM_Free(pbuf); IOTM_Free(pbuf);
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/wificonfig/https.c
//#include "redefine.h"
//#include "ssl_server_crt.h"
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "task.h" #include "task.h"
#include "diag.h"
#include "redefine.h"
#include "ssl_server_crt.h"
#include "datatype.h" #include "datatype.h"
#define MODULE_TAG "HTTPS" #define MODULE_TAG "HTTPS"
#include "log.h" #include "log.h"
...@@ -12,6 +10,7 @@ ...@@ -12,6 +10,7 @@
#include "https.h" #include "https.h"
#include "leiot/cJSON.h" #include "leiot/cJSON.h"
#include "iotsdk_wifi.h" #include "iotsdk_wifi.h"
#include "iotcommon.h"
#include "security_func.h" #include "security_func.h"
#include "redefine.h" #include "redefine.h"
...@@ -26,12 +25,6 @@ ...@@ -26,12 +25,6 @@
#include "polarssl/certs.h" #include "polarssl/certs.h"
#include "polarssl/error.h" #include "polarssl/error.h"
#define LOG_NHTTP(...) log_debug0(__VA_ARGS__)
#define SERVER_PORT 8443
#define STACKSIZE 1150
extern struct netif xnetif[NET_IF_NUM]; extern struct netif xnetif[NET_IF_NUM];
extern struct netif xnetif[NET_IF_NUM]; extern struct netif xnetif[NET_IF_NUM];
extern const char *test_ca_crt; extern const char *test_ca_crt;
...@@ -61,24 +54,8 @@ static int g_recvedSetwifi = 0; ...@@ -61,24 +54,8 @@ static int g_recvedSetwifi = 0;
static ApInfo *g_apInfo = NULL; static ApInfo *g_apInfo = NULL;
static const char *g_response_data = NULL; static const char *g_response_data = NULL;
#ifdef PLATFORM_LINUX
static const char *g_cert_file = NULL;
static const char *g_cert_key = NULL;
void Wificonfig_SetCert(const char *cert, const char *key)
{
g_cert_file = cert;
g_cert_key = key;
}
#endif //!PLATFORM_LINUX
static int random(void *p_rng, unsigned char *output, size_t output_len)
{
rtw_get_random_bytes(output, output_len);
return 0;
}
Request_Type parse_request_type(char* data) static Request_Type parse_request_type(char* data)
{ {
if (data == NULL) return RQ_ERR; if (data == NULL) return RQ_ERR;
...@@ -88,7 +65,7 @@ Request_Type parse_request_type(char* data) ...@@ -88,7 +65,7 @@ Request_Type parse_request_type(char* data)
return RQ_ERR; return RQ_ERR;
} }
URI_Entry* get_uri_entry(unsigned int hash) static URI_Entry* get_uri_entry(unsigned int hash)
{ {
unsigned int i = 0; unsigned int i = 0;
for (i = 0; i < _nhttp->uri_count; ++i) for (i = 0; i < _nhttp->uri_count; ++i)
...@@ -97,7 +74,7 @@ URI_Entry* get_uri_entry(unsigned int hash) ...@@ -97,7 +74,7 @@ URI_Entry* get_uri_entry(unsigned int hash)
return NULL; return NULL;
} }
unsigned int fnv_hash(const char* str, unsigned int length) static unsigned int fnv_hash(const char* str, unsigned int length)
{ {
unsigned int h = 2166136261UL; unsigned int h = 2166136261UL;
unsigned int i = 0; unsigned int i = 0;
...@@ -107,7 +84,7 @@ unsigned int fnv_hash(const char* str, unsigned int length) ...@@ -107,7 +84,7 @@ unsigned int fnv_hash(const char* str, unsigned int length)
} }
// Get URI // Get URI
int parse_uri(HTTP_Request* rq, char* data) static int parse_uri(HTTP_Request* rq, char* data)
{ {
// Search / in request // Search / in request
// HTTP/1.1 /testest \r\n // HTTP/1.1 /testest \r\n
...@@ -132,7 +109,7 @@ int parse_uri(HTTP_Request* rq, char* data) ...@@ -132,7 +109,7 @@ int parse_uri(HTTP_Request* rq, char* data)
return 1; return 1;
} }
int parse_request(HTTP_Request* request, char* data) static int parse_request(HTTP_Request* request, char* data)
{ {
//char *token; //char *token;
char *rest = data; char *rest = data;
...@@ -142,28 +119,28 @@ int parse_request(HTTP_Request* request, char* data) ...@@ -142,28 +119,28 @@ int parse_request(HTTP_Request* request, char* data)
request->type = parse_request_type(data); request->type = parse_request_type(data);
if (request->type == RQ_ERR) { if (request->type == RQ_ERR) {
LOG_NHTTP("Unknown request type\r\n"); log_debug0("Unknown request type\r\n");
return 0; return 0;
} }
// parse uri // parse uri
if (!parse_uri(request, data)) { if (!parse_uri(request, data)) {
LOG_NHTTP("Failed to parse URI\r\n"); log_debug0("Failed to parse URI\r\n");
return 0; return 0;
} }
return 1; return 1;
} }
void dump_request(HTTP_Request* rq) static void dump_request(HTTP_Request* rq)
{ {
LOG_NHTTP("Type:%d\r\n", rq->type); log_debug0("Type:%d\r\n", rq->type);
LOG_NHTTP("URI:%s\r\n", rq->uri); log_debug0("URI:%s\r\n", rq->uri);
LOG_NHTTP("URI Len:%d\r\n", rq->uri_length); log_debug0("URI Len:%d\r\n", rq->uri_length);
LOG_NHTTP("hash:%x\r\n", rq->uri_hash); log_debug0("hash:%x\r\n", rq->uri_hash);
} }
int parse_json_data(char *buffer,char *msgType) static int parse_json_data(char *buffer,char *msgType)
{ {
cJSON *root = NULL; cJSON *root = NULL;
cJSON *ssid = NULL; cJSON *ssid = NULL;
...@@ -200,7 +177,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -200,7 +177,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->ssid,ssid->valuestring,iots_strlen(ssid->valuestring)); iots_memcpy(g_apInfo->ssid,ssid->valuestring,iots_strlen(ssid->valuestring));
LOG_NHTTP("ssid : %s\n",g_apInfo->ssid); log_debug0("ssid : %s\n",g_apInfo->ssid);
pwd = cJSON_GetObjectItem(root,"pwd"); pwd = cJSON_GetObjectItem(root,"pwd");
if(pwd == NULL || pwd->valuestring == NULL) if(pwd == NULL || pwd->valuestring == NULL)
...@@ -214,7 +191,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -214,7 +191,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->pwd,pwd->valuestring,iots_strlen(pwd->valuestring)); iots_memcpy(g_apInfo->pwd,pwd->valuestring,iots_strlen(pwd->valuestring));
LOG_NHTTP("pwd : %s\n",g_apInfo->pwd); log_debug0("pwd : %s\n",g_apInfo->pwd);
utc = cJSON_GetObjectItem(root,"utc"); utc = cJSON_GetObjectItem(root,"utc");
if(utc != NULL && utc->valuestring != NULL) if(utc != NULL && utc->valuestring != NULL)
{ {
...@@ -224,7 +201,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -224,7 +201,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->utc,utc->valuestring,iots_strlen(utc->valuestring)); iots_memcpy(g_apInfo->utc,utc->valuestring,iots_strlen(utc->valuestring));
LOG_NHTTP("utc : %s\n",g_apInfo->utc); log_debug0("utc : %s\n",g_apInfo->utc);
} }
localserver = cJSON_GetObjectItem(root,"localserver"); localserver = cJSON_GetObjectItem(root,"localserver");
...@@ -236,7 +213,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -236,7 +213,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->localserver,localserver->valuestring,iots_strlen(localserver->valuestring)); iots_memcpy(g_apInfo->localserver,localserver->valuestring,iots_strlen(localserver->valuestring));
LOG_NHTTP("localserver : %s\n",g_apInfo->localserver); log_debug0("localserver : %s\n",g_apInfo->localserver);
} }
serverlevel = cJSON_GetObjectItem(root,"serverlevel"); serverlevel = cJSON_GetObjectItem(root,"serverlevel");
...@@ -248,7 +225,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -248,7 +225,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->serverlevel,serverlevel->valuestring,iots_strlen(serverlevel->valuestring)); iots_memcpy(g_apInfo->serverlevel,serverlevel->valuestring,iots_strlen(serverlevel->valuestring));
LOG_NHTTP("serverlevel : %s\n",g_apInfo->serverlevel); log_debug0("serverlevel : %s\n",g_apInfo->serverlevel);
} }
pre_code = cJSON_GetObjectItem(root,"pre_code"); pre_code = cJSON_GetObjectItem(root,"pre_code");
...@@ -260,7 +237,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -260,7 +237,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->pre_code,pre_code->valuestring,iots_strlen(pre_code->valuestring)); iots_memcpy(g_apInfo->pre_code,pre_code->valuestring,iots_strlen(pre_code->valuestring));
LOG_NHTTP("pre_code : %s\n",g_apInfo->pre_code); log_debug0("pre_code : %s\n",g_apInfo->pre_code);
} }
time_zone = cJSON_GetObjectItem(root,"time_zone"); time_zone = cJSON_GetObjectItem(root,"time_zone");
...@@ -272,7 +249,7 @@ int parse_json_data(char *buffer,char *msgType) ...@@ -272,7 +249,7 @@ int parse_json_data(char *buffer,char *msgType)
goto failed; goto failed;
} }
iots_memcpy(g_apInfo->time_zone,time_zone->valuestring,iots_strlen(time_zone->valuestring)); iots_memcpy(g_apInfo->time_zone,time_zone->valuestring,iots_strlen(time_zone->valuestring));
LOG_NHTTP("time_zone :%s \n",g_apInfo->time_zone); log_debug0("time_zone :%s \n",g_apInfo->time_zone);
} }
} }
else if(strcmp(msgType,"changeNetwork") == 0) else if(strcmp(msgType,"changeNetwork") == 0)
...@@ -317,24 +294,24 @@ struct record ...@@ -317,24 +294,24 @@ struct record
const char *address, *city, *state, *zip, *country; const char *address, *city, *state, *zip, *country;
}; };
int SendHttpsResp(ssl_context* ssl, Nano_Http* _nhttp, const char* data) int SendHttpsResp(SSL_Handle handle, Nano_Http* _nhttp, const char* data)
{ {
HTTP_Response* resp = &_nhttp->response; HTTP_Response* resp = &_nhttp->response;
resp->rtype = OK_; resp->rtype = OK_;
resp->ctype = text_html; resp->ctype = text_html;
resp->chunks_sent = 0; resp->chunks_sent = 0;
resp->send_zero = 0; resp->send_zero = 0;
LOG_NHTTP("send response data: %s\n", g_response_data); log_debug0("send response data: %s\n", g_response_data);
int cnt = iots_sprintf((char *)_nhttp->data, "HTTP/1.1 %s\r\n", responses_str[resp->rtype]); int cnt = iots_sprintf((char *)_nhttp->data, "HTTP/1.1 %s\r\n", responses_str[resp->rtype]);
cnt += iots_sprintf((char *)_nhttp->data + cnt, "Content-Type: %s\r\n\r\n", ctypes_str[resp->ctype]); cnt += iots_sprintf((char *)_nhttp->data + cnt, "Content-Type: %s\r\n\r\n", ctypes_str[resp->ctype]);
cnt += iots_sprintf((char *)_nhttp->data + cnt, "%s", g_response_data); cnt += iots_sprintf((char *)_nhttp->data + cnt, "%s", g_response_data);
LOG_NHTTP("Chunks: %d\r\nRest: %d\r\n", resp->chunks_left, resp->rest); log_debug0("Chunks: %d\r\nRest: %d\r\n", resp->chunks_left, resp->rest);
_nhttp->processing = 1; _nhttp->processing = 1;
LOG_NHTTP("=== EOF_REQ ===\r\n"); log_debug0("=== EOF_REQ ===\r\n");
LOG_NHTTP("Res data: %d\n", iots_strlen((const char *)_nhttp->data)); log_debug0("Res data: %d\n", iots_strlen((const char *)_nhttp->data));
if(ssl_write(ssl, _nhttp->data, iots_strlen((const char *)_nhttp->data)) > 0) if(IOTSSL_Write(handle, _nhttp->data, iots_strlen((const char *)_nhttp->data)) == E_SUCCESS)
{ {
return E_SUCCESS; return E_SUCCESS;
} }
...@@ -352,7 +329,7 @@ static int GetSetwifiStatus(void) ...@@ -352,7 +329,7 @@ static int GetSetwifiStatus(void)
} }
int process_request(char* data, ssl_context* ssl, int client_socket) static int process_request(char* data, SSL_Handle handle)
{ {
int j = 0; int j = 0;
int ret = 0; int ret = 0;
...@@ -361,19 +338,19 @@ int process_request(char* data, ssl_context* ssl, int client_socket) ...@@ -361,19 +338,19 @@ int process_request(char* data, ssl_context* ssl, int client_socket)
char *json_packet = NULL; char *json_packet = NULL;
HTTP_Request* req = NULL; HTTP_Request* req = NULL;
recv_data = (char *)IOTM_Malloc(2048); recv_data = IOTM_Malloc(2048);
if(recv_data == NULL) { if(recv_data == NULL) {
LOG_NHTTP("malloc failed\n"); log_debug0("malloc failed\n");
goto out; goto out;
} }
iots_strcpy(recv_data, data); iots_strcpy(recv_data, data);
LOG_NHTTP("=== REQUEST ===\r\n"); log_debug0("=== REQUEST ===\r\n");
_nhttp = &nhttp; _nhttp = &nhttp;
req = &_nhttp->request; req = &_nhttp->request;
if (!parse_request(req, data)) if (!parse_request(req, data))
{ {
LOG_NHTTP("parsing failed\r\n"); log_debug0("parsing failed\r\n");
//while (1) {}; //while (1) {};
goto out; goto out;
} }
...@@ -389,7 +366,7 @@ int process_request(char* data, ssl_context* ssl, int client_socket) ...@@ -389,7 +366,7 @@ int process_request(char* data, ssl_context* ssl, int client_socket)
if(g_respResult != 1) //是否需要再次response,若app没收到response会多次发送setwifi if(g_respResult != 1) //是否需要再次response,若app没收到response会多次发送setwifi
{ {
log_debug0("response false,response again......\n"); log_debug0("response false,response again......\n");
if(SendHttpsResp(ssl, _nhttp, g_response_data) == E_SUCCESS) if(SendHttpsResp(handle, _nhttp, g_response_data) == E_SUCCESS)
{ {
g_respResult = 1; g_respResult = 1;
} }
...@@ -398,33 +375,33 @@ int process_request(char* data, ssl_context* ssl, int client_socket) ...@@ -398,33 +375,33 @@ int process_request(char* data, ssl_context* ssl, int client_socket)
goto out; goto out;
} }
LOG_NHTTP("POSCIK: %s\r\n", data); log_debug0("POSCIK: %s\r\n", data);
// LOG_NHTTP ("recv_data : %s\n", recv_data); // log_debug0 ("recv_data : %s\n", recv_data);
for (j = 0; j < iots_strlen(recv_data); j++) for (j = 0; j < iots_strlen(recv_data); j++)
if (recv_data[j] == '\r' && recv_data[j + 1] == '\n' && recv_data[j + 2] == '\r' && recv_data[j + 3] == '\n') if (recv_data[j] == '\r' && recv_data[j + 1] == '\n' && recv_data[j + 2] == '\r' && recv_data[j + 3] == '\n')
{ {
json_packet = &recv_data[j + 4]; json_packet = &recv_data[j + 4];
break; break;
} }
LOG_NHTTP("Received data : %s\n", (char*) json_packet); log_debug0("Received data : %s\n", (char*) json_packet);
if( parse_json_data(json_packet,"setWifi") != E_SUCCESS) if( parse_json_data(json_packet,"setWifi") != E_SUCCESS)
{ {
LOG_NHTTP("parse json data failed \n"); log_debug0("parse json data failed \n");
goto out; goto out;
} }
if(GetSetwifiStatus() == E_SUCCESS) //收到所需信息后才响应 if(GetSetwifiStatus() == E_SUCCESS) //收到所需信息后才响应
{ {
log_debug0("Softap get needed info\n"); log_debug0("Softap get needed info\n");
g_recvedSetwifi = 1; g_recvedSetwifi = 1;
if(SendHttpsResp(ssl, _nhttp, g_response_data) == E_SUCCESS) if(SendHttpsResp(handle, _nhttp, g_response_data) == E_SUCCESS)
{ {
g_respResult = 1; g_respResult = 1;
LOG_NHTTP("Send response success!\n"); log_debug0("Send response success!\n");
} }
else else
{ {
LOG_NHTTP("Send response failed!\n"); log_debug0("Send response failed!\n");
} }
} }
ret = 0; ret = 0;
...@@ -437,7 +414,7 @@ int process_request(char* data, ssl_context* ssl, int client_socket) ...@@ -437,7 +414,7 @@ int process_request(char* data, ssl_context* ssl, int client_socket)
ret = 0; ret = 0;
goto out; goto out;
} }
LOG_NHTTP("POSCIK: %s\r\n", data); log_debug0("POSCIK: %s\r\n", data);
for (j = 0; j < iots_strlen(recv_data); j++) for (j = 0; j < iots_strlen(recv_data); j++)
if (recv_data[j] == '\r' && recv_data[j + 1] == '\n' && recv_data[j + 2] == '\r' && recv_data[j + 3] == '\n') if (recv_data[j] == '\r' && recv_data[j + 1] == '\n' && recv_data[j + 2] == '\r' && recv_data[j + 3] == '\n')
...@@ -446,20 +423,20 @@ int process_request(char* data, ssl_context* ssl, int client_socket) ...@@ -446,20 +423,20 @@ int process_request(char* data, ssl_context* ssl, int client_socket)
break; break;
} }
LOG_NHTTP("Received data : %s\n", (char*) json_packet); log_debug0("Received data : %s\n", (char*) json_packet);
if(parse_json_data(json_packet,"changeNetwork") != E_SUCCESS) if(parse_json_data(json_packet,"changeNetwork") != E_SUCCESS)
{ {
ret = 0; ret = 0;
goto out; goto out;
} }
ret = 1; ret = 1;
LOG_NHTTP("changeNetwork OK\n"); log_debug0("changeNetwork OK\n");
LOG_NHTTP("SendHttpsResp......\n"); log_debug0("SendHttpsResp......\n");
//ret = SendHttpsResp(ssl, _nhttp, g_response_data); //ret = SendHttpsResp(handle, _nhttp, g_response_data);
//if (ret > 0) //if (ret > 0)
// LOG_NHTTP("ok\n"); // log_debug0("ok\n");
//else //else
// LOG_NHTTP("Setwifi error...\n"); // log_debug0("Setwifi error...\n");
//if(1 == ret_parse_json) { //if(1 == ret_parse_json) {
// ret = 1; // ret = 1;
//} //}
...@@ -479,300 +456,161 @@ out: ...@@ -479,300 +456,161 @@ out:
return ret; return ret;
} }
static int https_checkDataIsValid(char *pszBuf)
int SetNonBlock(int iSock)
{ {
int iFlags; int iRet = 0;
int left_flag = 0, right_flag = 0;
iFlags = fcntl(iSock, F_GETFL, 0); char* offset_l = pszBuf;
iFlags |= O_NONBLOCK; char* offset_r = pszBuf;
iFlags |= O_NDELAY;
int ret = fcntl(iSock, F_SETFL, iFlags); while (!(offset_l == NULL && offset_r == NULL)) {
return ret; offset_l = strstr(offset_l+1, "{");
if (offset_l != NULL)
left_flag ++;
offset_r = strstr(offset_r+1, "}");
if (offset_r != NULL)
right_flag ++;
if (left_flag > 0 && left_flag == right_flag)
{
iRet = 1;
break;
}
}
return iRet;
} }
#if 0
static int load_server_cert(SSL_CTX* ctx) //int Wificonfig_StartHttpsServer(const char *response, char *ssid, char *password, char *utc)
int Wificonfig_StartHttpsServer(const char *response,ApInfo *apInfo /*char *ssid, char *password, char *utc*/)
{ {
int retval = E_FAILED; int s_flag = 0;
#ifndef PLATFORM_LINUX int loopNumber = 0;
int retval = E_FAILED;
char *pszRecvBuf = NULL;
int iRecvBufOft = 0;
int cer_len = (SERVER_CERT_LENGTH+3)&~3; int cer_len = (SERVER_CERT_LENGTH+3)&~3;
int key_len = (SERVER_KEY_LENGTH+3)&~3; int key_len = (SERVER_KEY_LENGTH+3)&~3;
int buffer_len = (cer_len>key_len)?cer_len:key_len; char *cer_buf = NULL;
char *buffer = NULL; char *key_buf = NULL;
SSL_Handle handle = NULL;
int iRet = -1;
int iLogIndex = 0;
int recv_flag = 0;
buffer = IOTM_Malloc(buffer_len); log_assert(apInfo != NULL && response != NULL);
if(buffer == NULL) {
log_error("insufficient memory\n");
goto failed;
}
LOG_NHTTP("load server crt ......len=%d/%d\n", cer_len, buffer_len); g_apInfo = apInfo;
memset(buffer, 0, buffer_len); memset(g_apInfo,0,sizeof(ApInfo));
log_assert(cer_len <= buffer_len); g_response_data = response;
iots_memcpy(buffer, SERVER_CERT, cer_len/*fixme.. SERVER_CERT_LENGTH*/);
if(!SSL_CTX_use_certificate_ASN1(ctx, SERVER_CERT_LENGTH, buffer)) {
log_error("use_certificate failed\n");
goto failed;
}
LOG_NHTTP("load server private key ......len=%d/%d\n", key_len, buffer_len); g_respResult = 0;
memset(buffer, 0, buffer_len); g_recvedSetwifi = 0;
log_assert(key_len <= buffer_len); loopNumber = ALL_SLEEP_TIME / SLEEP_TIME;
iots_memcpy(buffer, SERVER_KEY, key_len/*fixme.. SERVER_KEY_LENGTH*/);
if(!SSL_CTX_use_PrivateKey_ASN1(0, ctx, buffer, SERVER_KEY_LENGTH)) {
log_error("use_PrivateKey failed\n");
goto failed;
}
retval = E_SUCCESS;
log_debug0("set SSL context read buffer size ......OK\n"); log_debug0("OpenSSL thread start...\n");
SSL_CTX_set_default_read_buffer_len(ctx, OPENSSL_FRAGMENT_SIZE); log_debug0("create SSL context ......\n");
failed: cer_buf = IOTM_Malloc(cer_len);
if(buffer != NULL) { if(cer_buf == NULL) {
IOTM_Free(buffer); log_error("insufficient memory\n");
buffer = NULL; retval = E_NO_MEMORY;
} goto end;
#else
if(g_cert_file == NULL || g_cert_key == NULL) {
log_error("certificate file unknown\n");
goto failed;
} }
LOG_NHTTP("load server crt ......file=%s\n", g_cert_file); key_buf = IOTM_Malloc(key_len);
if(!SSL_CTX_use_certificate_file(ctx, g_cert_file, SSL_FILETYPE_PEM)) { if(key_buf == NULL) {
log_error("use_certificate_file failed\n"); log_error("insufficient memory\n");
goto failed; IOTM_Free(cer_buf); cer_buf = NULL;
retval = E_NO_MEMORY;
goto end;
} }
LOG_NHTTP("load server private key ......file=%s\n", g_cert_key); memset(cer_buf, 0, cer_len);
if (!SSL_CTX_use_PrivateKey_file(ctx, g_cert_key, SSL_FILETYPE_PEM)) { memset(key_buf, 0, key_len);
log_error("use_PrivateKey_file failed\n"); log_debug0("load server crt ......len=%d/%d\n", cer_len, key_len);
goto failed; iots_memcpy(cer_buf, SERVER_CERT, cer_len);
iots_memcpy(key_buf, SERVER_KEY, key_len);
handle = IOTSSL_ServerNew("192.168.199.1", OPENSSL_LOCAL_TCP_PORT,
cer_buf, cer_len, key_buf, key_len);
IOTM_Free(cer_buf); cer_buf = NULL;
IOTM_Free(key_buf); key_buf = NULL;
if(handle == NULL) {
log_error("handle is null\n");
goto end;
} }
retval = E_SUCCESS;
failed:
#endif //!PLATFORM_LINUX
return retval;
}
#endif
static int Setsockopt(int socket,int keepIdle,int keepInterval,int keepCount)
{
int retval = 0;
int setval = 1;
int keepAlive = 1;
retval |= setsockopt(socket,IPPROTO_TCP, TCP_NODELAY ,(const char *)&setval ,sizeof(setval));
retval |= setsockopt(socket,SOL_SOCKET ,SO_KEEPALIVE ,(const char *)&keepAlive ,sizeof(keepAlive));
retval |= setsockopt(socket,IPPROTO_TCP,TCP_KEEPIDLE ,(const char *)&keepIdle ,sizeof(keepIdle));
retval |= setsockopt(socket,IPPROTO_TCP,TCP_KEEPINTVL,(const char *)&keepInterval,sizeof(keepInterval));
retval |= setsockopt(socket,IPPROTO_TCP,TCP_KEEPCNT ,(const char *)&keepCount ,sizeof(keepCount));
return retval; pszRecvBuf = IOTM_Malloc(OPENSSL_RECV_BUF_ALL_LEN);
} if (NULL == pszRecvBuf) {
log_error("insufficient memory\n");
/*char *ssid, char *password, char *utc*/ retval = E_NO_MEMORY;
int Wificonfig_StartHttpsServer(const char *response, ApInfo *apInfo) goto end;
{ }
int ret, server_fd = -1, client_fd = -1;
x509_crt server_x509;
pk_context server_pk;
ssl_context ssl;
unsigned char szRecvBuf[OPENSSL_RECV_BUF_ONE_LEN + 1];
int iRrecvFlag = 0;
int left_flag = 0, right_flag = 0;
char *offset_l = NULL;
char *offset_r = NULL;
int times = 0;
int loopStop = 0;
int loopNumber = 0;
int s_flag = 0;
int iOffset;
uint8_t *ip;
//char *response = "<HTML><BODY>SSL OK</BODY></HTML>";
if(apInfo == NULL) {
log_error("Parameter error\n");
return E_FAILED;
}
g_apInfo = apInfo;
memset(g_apInfo,0,sizeof(ApInfo));
g_response_data = response;
g_respResult = 0;
g_recvedSetwifi = 0;
loopNumber = ALL_SLEEP_TIME / SLEEP_TIME;
// Delay to wait for IP by DHCP
vTaskDelay(10000);
log_debug0("SSL server Start\n");
memory_set_own(pvPortMalloc, vPortFree);
memset(&server_x509, 0, sizeof(x509_crt));
memset(&server_pk, 0, sizeof(pk_context));
memset(&ssl, 0, sizeof(ssl_context));
x509_crt_init(&server_x509);
pk_init(&server_pk);
if((ret = x509_crt_parse(&server_x509, (const unsigned char *)test_srv_crt, strlen(test_srv_crt))) != 0) {
printf(" failed\n ! x509_crt_parse returned %d\n\n", ret);
goto exit;
}
if((ret = x509_crt_parse(&server_x509, (const unsigned char *)test_ca_list, strlen(test_ca_list))) != 0) {
printf(" failed\n ! x509_crt_parse returned %d\n\n", ret);
goto exit;
}
if((ret = pk_parse_key(&server_pk, test_srv_key, strlen(test_srv_key), NULL, 0)) != 0) {
printf(" failed\n ! pk_parse_key returned %d\n\n", ret);
goto exit;
}
/*
* 2. Start the connection
*/
ip = LwIP_GetIP(&xnetif[0]);
printf("\n\r . Starting tcp server /%d.%d.%d.%d/%d...", ip[0], ip[1], ip[2], ip[3], SERVER_PORT);
if((ret = net_bind(&server_fd, NULL, SERVER_PORT)) != 0) {
log_error(" failed\n ! net_bind returned %d\n\n", ret);
goto exit;
}
printf(" ok\n");
/*
* 3. Waiting for client to connect
*/
reconnect: reconnect:
log_debug0("Waiting for client to connect...\n\r"); retval = IOTSSL_ServerAccept(handle);
if(retval == E_ACCEPT_TEM_UNAVAIL) {
while((ret = net_accept(server_fd, &client_fd, NULL)) == 0) { goto checkloop;
log_debug0("A client is connecting\n\r"); } else if(retval != E_SUCCESS) {
log_debug0("IOTSSL_ServerAccept falied\n");
goto end;
}
retval = E_FAILED;
log_debug0("SSL server socket accept client ......\n");
iRecvBufOft = 0;
recv_flag = 0;
memset(pszRecvBuf, 0, OPENSSL_RECV_BUF_ALL_LEN);
log_debug0("ssl_read...\n");
do {
msleep(10);
iRet = IOTSSL_Read(handle, OPENSSL_RECV_BUF_ALL_LEN, pszRecvBuf + iRecvBufOft);
if (iRet < 0)
continue;
iRecvBufOft += iRet;
if (0 == https_checkDataIsValid(pszRecvBuf)) {
continue;
}
//struct timeval timeout = {10,0}; log_debug0 ("recv over...SSL read len : %d, SSL read: \n%s\n",
//setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(struct timeval)); iots_strlen(pszRecvBuf), pszRecvBuf);
/* if(1 == (iRet = process_request(pszRecvBuf, handle))) {
* 4. Setup stuff log_debug0 ("Get passwd, Ret : %d, re_num : %d, I will leave softap.\n", iRet, loopNumber);
*/ goto end;
printf("\n\r . Setting up the SSL/TLS structure..."); } else {
log_debug0("Get Ssid Passwd %s\n", (g_recvedSetwifi == 1)?"Ok":"False");
if((ret = ssl_init(&ssl)) != 0) { IOTSSL_ServerShutdown(handle);
log_error(" failed\n ! ssl_init returned %d\n\n", ret); goto reconnect;
goto close_ssl;
} }
} while (++recv_flag < 100);
ssl_set_endpoint(&ssl, SSL_IS_SERVER); if(recv_flag >= 100) {
ssl_set_ca_chain(&ssl, server_x509.next, NULL, NULL); log_debug0 ("recv error, recv buf len:%d\n", iots_strlen(pszRecvBuf));
ssl_set_authmode(&ssl, SSL_VERIFY_NONE); }
ssl_set_rng(&ssl, random, NULL);
ssl_set_bio(&ssl, net_recv, &client_fd, net_send, &client_fd);
if((ret = ssl_set_own_cert(&ssl, &server_x509, &server_pk)) != 0) {
printf(" failed\n ! ssl_set_own_cert returned %d\n\n", ret);
goto close_ssl;
}
/*
* 5. Handshake
*/
printf("\n\r . Performing the SSL/TLS handshake...");
if((ret = ssl_handshake(&ssl)) != 0) { checkloop:
log_error(" failed\n ! ssl_handshake returned %d\n\n", ret); if(loopNumber) {
goto close_ssl; if(g_recvedSetwifi == 1) {
} loopNumber --;
}
log_debug0("ok. Use ciphersuite %s\n", ssl_get_ciphersuite(&ssl));
iOffset = 0; log_debug0("%s", ((iLogIndex++%40) == 0)?"wait connect second ...\n":"");
iRrecvFlag = 0; msleep(SLEEP_TIME);
memset(szRecvBuf, 0, (OPENSSL_RECV_BUF_ONE_LEN)); IOTSSL_ServerShutdown(handle);
do { goto reconnect;
msleep(1); }
ret = ssl_read(&ssl, &szRecvBuf[iOffset], OPENSSL_RECV_BUF_ONE_LEN);
iRrecvFlag ++;
if (iRrecvFlag > 5000) {
printf ("recv ret : %d, recv buf len...\n", ret, iots_strlen(szRecvBuf) - iOffset);
break;
}
if ( ret > 0) {
iOffset += ret;
}
if (ret <= -1)
continue;
times = 0;
left_flag = 0;
right_flag = 0;
offset_l = szRecvBuf;
offset_r = szRecvBuf;
while (!(offset_l == NULL && offset_r == NULL)) {
offset_l = strstr(offset_l+1, "{");
if (offset_l != NULL)
left_flag ++;
offset_r = strstr(offset_r+1, "}");
if (offset_r != NULL)
right_flag ++;
if (left_flag > 0 && left_flag == right_flag)
{
times = 1;
break;
}
}
if ( times > 0) {
log_debug0("recv over...SSL read len : %d, SSL read: \n%s\n", iots_strlen(szRecvBuf), szRecvBuf);
loopStop = process_request(szRecvBuf, &ssl, client_fd);
log_debug0("Ret : %d, re_num : %d\n",loopStop,loopNumber);
break;
}
}while(1);
close_ssl:
#ifdef POLARSSL_ERROR_C
if(ret != 0) {
char error_buf[100];
polarssl_strerror(ret, error_buf, 100);
log_debug0("\n\rLast error was: %d - %s\n", ret, error_buf);
}
#endif
ssl_close_notify(&ssl);
close_fd:
net_close(client_fd);
ssl_free(&ssl);
if(loopStop != 1 && loopNumber) {
s_flag ++;
if(g_recvedSetwifi == 1) {
loopNumber --;
}
if (s_flag % (5 * (1000 / SLEEP_TIME)) == 0) {
log_debug0("wait connect second %d...\n", s_flag / (1000 / SLEEP_TIME));
}
msleep(SLEEP_TIME);
goto reconnect;
} else {
break;
}
}
net_close(server_fd); end:
if(handle != NULL) {
IOTSSL_Destroy(handle);
handle = NULL;
}
exit: if (NULL != pszRecvBuf) {
x509_crt_free(&server_x509); IOTM_Free(pszRecvBuf);
pk_free(&server_pk); pszRecvBuf = NULL;
}
//vTaskDelete(NULL); log_debug0("Closet https server sucess\n");
return (g_recvedSetwifi) ? E_SUCCESS : retval;
return (g_recvedSetwifi) ? E_SUCCESS : E_FAILED;
} }
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/wificonfig/https.h
...@@ -8,13 +8,11 @@ ...@@ -8,13 +8,11 @@
#define BUFFER_SIZE 2048 #define BUFFER_SIZE 2048
#define OPENSSL_RECV_BUF_ONE_LEN 1024 #define OPENSSL_RECV_BUF_ALL_LEN 2048
#define OPENSSL_RECV_BUF_ALL_LEN 4096
#define OPENSSL_LOCAL_TCP_PORT 8443 #define OPENSSL_LOCAL_TCP_PORT 8443
#define OPENSSL_THREAD_NAME "openssl" #define OPENSSL_THREAD_NAME "openssl"
#define OPENSSL_THREAD_STACK_WORDS 2048 #define OPENSSL_THREAD_STACK_WORDS 2048
#define OPENSSL_THREAD_PRORIOTY 6 #define OPENSSL_THREAD_PRORIOTY 6
#define OPENSSL_FRAGMENT_SIZE 2048
typedef enum { typedef enum {
GET, GET,
......
rtk8710-sdk/project/realtek_amebaz_va0_example/leiot/wificonfig/wificonfig.c
...@@ -2,16 +2,15 @@ ...@@ -2,16 +2,15 @@
//#include <stdlib.h> //#include <stdlib.h>
//#include <stdio.h> //#include <stdio.h>
#include "cJSON.h" #include "cJSON.h"
#include "main.h" #include "iotcommon.h"
//#include "iotcommon.h"
#include "redefine.h" #include "redefine.h"
#include "datatype.h"
#include "iotsdk.h"
#include "rtos.h" #include "rtos.h"
#include "include/device.h" #include "iotsdk.h"
#include "configdata.h"
#define MODULE_TAG "WifiConfig" #define MODULE_TAG "WifiConfig"
#include "log.h" #include "log.h"
#include "iotsdk_wifi.h" #include "iotsdk_wifi.h"
#include "datatype.h"
#include "security_func.h" #include "security_func.h"
#include "cmsis_os.h" #include "cmsis_os.h"
...@@ -37,11 +36,18 @@ int IOTWifi_Start(int force,ApInfo *apInfo) ...@@ -37,11 +36,18 @@ int IOTWifi_Start(int force,ApInfo *apInfo)
int retval = E_FAILED; int retval = E_FAILED;
char code_challenge[36]; char code_challenge[36];
char code_verifier[16]; char code_verifier[16];
char version[16];
DMEvent event; DMEvent event;
char *country_code = "cn"; //US. char *country_code = "cn"; //US.
log_assert(apInfo != NULL); log_assert(apInfo != NULL);
if(IOTConfMI_Get(MEMPARAM_TYPE_AUTH_FAILED, apInfo, sizeof(ApInfo)) == E_SUCCESS) {
log_assert(sizeof(apInfo->reserved) == sizeof(code_verifier));
memcpy(code_verifier, apInfo->reserved, sizeof(apInfo->reserved));
log_debug0("get mem param: %s->%s->%s->%s\n", apInfo->ssid, apInfo->pwd, apInfo->reserved, apInfo->pre_code);
IOTConfMI_Clear();
goto sta_auth;
}
event.event = IOTDM_EVENT_NETWORK_CONFIG; event.event = IOTDM_EVENT_NETWORK_CONFIG;
if(!force && IOTConf_GetWifiFlag()) { if(!force && IOTConf_GetWifiFlag()) {
log_debug0("wifi is already configed\n"); log_debug0("wifi is already configed\n");
...@@ -66,11 +72,11 @@ int IOTWifi_Start(int force,ApInfo *apInfo) ...@@ -66,11 +72,11 @@ int IOTWifi_Start(int force,ApInfo *apInfo)
memset(code_verifier, 0, sizeof(code_verifier)); memset(code_verifier, 0, sizeof(code_verifier));
iots_sprintfs(code_verifier, sizeof(code_verifier), "%d%d", IOTSysP_Random(10000), IOTSysP_Random(10000)); iots_sprintfs(code_verifier, sizeof(code_verifier), "%d%d", IOTSysP_Random(10000), IOTSysP_Random(10000));
printf("code_verifier %s\n", code_verifier);
memset(code_challenge, 0, sizeof(code_challenge)); memset(code_challenge, 0, sizeof(code_challenge));
IOTEncode_MD5_Hex(code_verifier, iots_strlen(code_verifier), code_challenge); IOTEncode_MD5_Hex(code_verifier, iots_strlen(code_verifier), code_challenge);
memset(buffer, 0, BUFFER_LENGTH); memset(buffer, 0, BUFFER_LENGTH);
memset(version, 0, sizeof(version));
iots_sprintfs(buffer, sizeof(buffer), iots_sprintfs(buffer, sizeof(buffer),
"{\"hubtype\":\"%d\", " "{\"hubtype\":\"%d\", "
"\"macaddr\":\"%s\", " "\"macaddr\":\"%s\", "
...@@ -82,7 +88,7 @@ int IOTWifi_Start(int force,ApInfo *apInfo) ...@@ -82,7 +88,7 @@ int IOTWifi_Start(int force,ApInfo *apInfo)
(const unsigned char *)IOTSys_Mac(), (const unsigned char *)IOTSys_Mac(),
country_code, country_code,
IOTConfRI_CloudStr(), IOTConfRI_CloudStr(),
IOTDev_AdapterVersion(), code_challenge); IOTDev_AdapterVersion(version), code_challenge);
log_debug0("softap started, then start https server, response=%s\n", buffer); log_debug0("softap started, then start https server, response=%s\n", buffer);
if(Wificonfig_StartHttpsServer(buffer,apInfo) != E_SUCCESS) { if(Wificonfig_StartHttpsServer(buffer,apInfo) != E_SUCCESS) {
...@@ -95,6 +101,7 @@ int IOTWifi_Start(int force,ApInfo *apInfo) ...@@ -95,6 +101,7 @@ int IOTWifi_Start(int force,ApInfo *apInfo)
log_error("softap stop failed\n"); log_error("softap stop failed\n");
} }
sta_auth:
log_debug0("softap stoped, then do staticon config\n"); log_debug0("softap stoped, then do staticon config\n");
if(IOTWifiP_StationConfig(apInfo->ssid,apInfo->pwd) != E_SUCCESS) { if(IOTWifiP_StationConfig(apInfo->ssid,apInfo->pwd) != E_SUCCESS) {
log_error("station config failed\n"); log_error("station config failed\n");
...@@ -116,7 +123,7 @@ int IOTWifi_Start(int force,ApInfo *apInfo) ...@@ -116,7 +123,7 @@ int IOTWifi_Start(int force,ApInfo *apInfo)
ssleep(2); ssleep(2);
} }
log_debug0("station connect success, then set wificonfig flag\n"); log_debug0("station connect success, then get access token\n");
{ {
int retry = 10; int retry = 10;
while(retry-- > 0) { while(retry-- > 0) {
...@@ -135,6 +142,14 @@ int IOTWifi_Start(int force,ApInfo *apInfo) ...@@ -135,6 +142,14 @@ int IOTWifi_Start(int force,ApInfo *apInfo)
} }
if(retval == E_SUCCESS) { if(retval == E_SUCCESS) {
retval = IOTConfI_SetWifiFlag(1); retval = IOTConfI_SetWifiFlag(1);
} else if(retval == E_NO_MEMORY) {
log_assert(sizeof(apInfo->reserved) == sizeof(code_verifier));
memcpy(apInfo->reserved, code_verifier, sizeof(apInfo->reserved));
log_debug0("set mem param: %s->%s->%s->%s\n", apInfo->ssid, apInfo->pwd, apInfo->reserved, apInfo->pre_code);
if(IOTConfMI_Set(MEMPARAM_TYPE_AUTH_FAILED, apInfo, sizeof(ApInfo)) == E_SUCCESS) {
log_debug0("check no memeory to restart\n");
IOTSys_Reboot();
}
} }
failed: failed:
if(buffer != NULL) { if(buffer != NULL) {
......
rtk8710-sdk/project/realtek_amebaz_va0_example/src/main.c
...@@ -108,78 +108,10 @@ void user_task(void *arg) ...@@ -108,78 +108,10 @@ void user_task(void *arg)
return; return;
} }
if(xTaskCreate(main_task, ((const char*)"main_task"), 1024*4, NULL, tskIDLE_PRIORITY + 3 + PRIORITIE_OFFSET, NULL) != pdPASS) if(xTaskCreate(main_task, ((const char*)"main_task"), 1024*1 + 512, NULL, tskIDLE_PRIORITY + 3 + PRIORITIE_OFFSET, NULL) != pdPASS)
printf("\n\r%s xTaskCreate(init_thread) failed", __FUNCTION__); printf("\n\r%s xTaskCreate(init_thread) failed", __FUNCTION__);
for(;;) { vTaskDelete(NULL);
rtw_msleep_os(6000);
}
#if 0
IOTDM_LogLevel(2);
rtw_msleep_os(3000);
rtc_write(1528804180);
if(IOTRtos_init()!= 0) {
printf("RTOS init failed\n");
return;
}
if(IOTSDK_Init()!= 0) {
printf("confit init failed\n");
return;
}
rtw_msleep_os(3000);
if(!IOTConf_GetWifiFlag()) {
softap:
printf("Enter softap_task\r\n");
g_pstInfo = malloc(sizeof(ApInfo));
if(g_pstInfo == NULL)
{
printf("Malloc failed\n");
return;
}
memset(g_pstInfo, 0, sizeof(ApInfo));
IOTWifi_Start(0,g_pstInfo);
log_debug0("delete softap task......\n");
if(strlen(g_pstInfo->utc) != 0)
{
memset(g_utc,0,sizeof(g_utc));
memcpy(g_utc,g_pstInfo->utc, strlen(g_pstInfo->utc));
}
if(g_pstInfo != NULL)
{
free(g_pstInfo);
g_pstInfo = NULL;
}
}else {
while (1) {
if (0 != IOTWifi_ConnectWifiByConf()) {
printf("Connect Falied\r\n");
//goto softap;
} else {
break;
}
if (!IOTConf_GetWifiFlag()) {
goto softap;
}
}
rtw_msleep_os(3000);
}
//xSemaphoreGive(mutex);
//vTaskDelete(NULL);
IOTDM_Loop();
for(;;) {
rtw_msleep_os(6000);
printf("user_thread alive \n");
}
#endif
} }
void user_thread(void *param) void user_thread(void *param)
......
rtk8710-sdk/project/realtek_amebaz_va0_example/src/wificonfig_8710.c
...@@ -157,6 +157,7 @@ static void ApUpgradeTask(void *arg) ...@@ -157,6 +157,7 @@ static void ApUpgradeTask(void *arg)
IOTOTA_ApOTAStart(); IOTOTA_ApOTAStart();
log_debug0("delete ap upgrade task\n"); log_debug0("delete ap upgrade task\n");
vTaskDelete(NULL); vTaskDelete(NULL);
IOT_GetHeapSize();
} }
int IOTWifiP_SoftapStart(const char *hotspot) int IOTWifiP_SoftapStart(const char *hotspot)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment