OrgUCloud
/
ucloud-iot-rtthread-package
mirror of https://github.com/ucloud/ucloud-iot-rtthread-package.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #18 from ucloud/support_http_client 

support http client
This commit is contained in:
ethanDu1 2020-02-25 14:16:44 +08:00 committed by GitHub
parent 5d589c3d33 2716bcebb4
commit 102c2e753a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 918 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
README.md
View File

@ -15,6 +15,7 @@ UCloud IOT SDK for rt-thread Package 是基于[UCloud设备端C-SDK](https://git
| samples | 示例目录 |
| ├─mqtt | 静态注册收发消息示例 |
| ├─dynamic_auth | 动态注册示例 |
| ├─http | Http连接云平台示例 |
| ├─dev_model | 物模型示例 |
| ├─ota | ota升级示例 |
| ├─shadow | 设备影子示例 |
@ -43,7 +44,8 @@ RT-Thread online packages --->
IoT Cloud --->
[ ] ucloud-iot-sdk: ucloud iot sdk for uiot-core platform. --->
--- ucloud-iothub: ucloud iot sdk for uiot-core platform
[ ] Enable Mqtt
[ ] Enable Mqtt link uiot-core platform
[ ] Enable Http link uiot-core platform
ucloud Device Config --->
Version (latest) --->
```
@ -52,7 +54,8 @@ RT-Thread online packages --->
根据产品需求选择合适的应用示例修改新增业务逻辑，也可新增例程编写新的业务逻辑。
```
--- ucloud-iot-sdk: ucloud iot sdk for uiot-core platform.
[*] Enable Mqtt
[*] Enable Mqtt link uiot-core platform
[ ] Enable Http link uiot-core platform
Ucloud Device Config --->
[*] Enable Ucloud Mqtt Sample
[ ] Enable Ucloud Mqtt Dynamic Auth Sample
@ -69,7 +72,9 @@ RT-Thread online packages --->
- 选项说明
`Enable Mqtt`：使能MQTT连接云平台功能。
`Enable Mqtt link uiot-core platform`：使能MQTT连接云平台功能。
`Enable Http link uiot-core platform`：使能HTTP连接云平台功能,只支持https,勾选会关联选中mbedTLS软件包。
`Ucloud Device Config `：填写当前设备认证要素，当认证模式为动态认证时，设备密钥可以不填写

29
SConscript
View File

@ -8,6 +8,8 @@ src_base = []
sample_ucloud_mqtt_src = []
sample_ucloud_mqtt_dynamic_auth_src = []
sample_ucloud_http_publish_src = []
sample_ucloud_http_upload_file_src = []
sample_ucloud_shadow_src = []
sample_ucloud_dev_model_src = []
sample_ucloud_ota_src = []
@ -29,6 +31,8 @@ CPPPATH += [cwd + '/uiot/sdk-impl']
CPPPATH += [cwd + '/uiot/shadow/include']
CPPPATH += [cwd + '/uiot/utils']
src_base += Glob('uiot/utils/*.c')
src_base += Glob('ports/rtthread/*.c')
#Debug
if GetDepend(['PKG_USING_UCLOUD_DEBUG']):
CPPDEFINES += ['ENABLE_LOG_DEBUG', 'ENABLE_LOG_INFO', 'ENABLE_LOG_WARN', 'ENABLE_LOG_ERROR']
@ -36,13 +40,10 @@ if GetDepend(['PKG_USING_UCLOUD_DEBUG']):
#Gen MQTT src file
if GetDepend(['PKG_USING_UCLOUD_MQTT']):
src_base += Glob('uiot/mqtt/src/*.c')
src_base += Glob('uiot/utils/utils_timer.c')
src_base += Glob('uiot/utils/utils_net.c')
src_base += Glob('uiot/utils/utils_list.c')
src_base += Glob('uiot/utils/json_parser.c')
src_base += Glob('uiot/utils/json_token.c')
src_base += Glob('uiot/utils/string_utils.c')
src_base += Glob('ports/rtthread/*.c')
#Gen HTTP src file
if GetDepend(['PKG_USING_UCLOUD_HTTP']):
src_base += Glob('uiot/http/*.c')
#Gen shadow src file
if GetDepend(['PKG_USING_UCLOUD_SHADOW']):
@ -56,8 +57,6 @@ if GetDepend(['PKG_USING_UCLOUD_DEV_MODEL']):
if GetDepend(['PKG_USING_UCLOUD_OTA']):
src_base += Glob('uiot/ota/src/*.c')
src_base += Glob('ports/fal/*.c')
src_base += Glob('uiot/utils/utils_md5.c')
src_base += Glob('uiot/utils/utils_httpc.c')
#TLS used
if GetDepend(['PKG_USING_UCLOUD_TLS']):
@ -80,6 +79,18 @@ if GetDepend(['PKG_USING_UCLOUD_MQTT_DYNAMIC_AUTH_SAMPLE']):
group = DefineGroup('sample_ucloud_mqtt_dynamic_auth', sample_ucloud_mqtt_dynamic_auth_src, depend = ['PKG_USING_UCLOUD_MQTT_DYNAMIC_AUTH_SAMPLE'], CPPPATH = CPPPATH, LOCAL_CCFLAGS = LOCAL_CCFLAGS, CPPDEFINES = CPPDEFINES)
#Http Publish Example
if GetDepend(['PKG_USING_UCLOUD_HTTP_PUBLISH_SAMPLE']):
sample_ucloud_http_publish_src += Glob('samples/http/http_client_sample.c')
group = DefineGroup('sample_ucloud_http_publish', sample_ucloud_http_publish_src, depend = ['PKG_USING_UCLOUD_HTTP_PUBLISH_SAMPLE'], CPPPATH = CPPPATH, LOCAL_CCFLAGS = LOCAL_CCFLAGS, CPPDEFINES = CPPDEFINES)
#Http Upload File Example
if GetDepend(['PKG_USING_UCLOUD_HTTP_UPLOAD_FILE_SAMPLE']):
sample_ucloud_http_upload_file_src += Glob('samples/http/upload_file_sample.c')
group = DefineGroup('sample_ucloud_http_upload_file', sample_ucloud_http_upload_file_src, depend = ['PKG_USING_UCLOUD_HTTP_UPLOAD_FILE_SAMPLE'], CPPPATH = CPPPATH, LOCAL_CCFLAGS = LOCAL_CCFLAGS, CPPDEFINES = CPPDEFINES)
#Shadow Example
if GetDepend(['PKG_USING_UCLOUD_SHADOW_SAMPLE']):
sample_ucloud_shadow_src += Glob('samples/shadow/shadow_sample.c')

3
docs/quick_start.md
View File

@ -42,7 +42,8 @@
1. 打开mqtt sample
```
--- ucloud-iot-sdk: ucloud iot sdk for uiot-core platform.
[*] Enable Mqtt
[*] Enable Mqtt link uiot-core platform
[ ] Enable Http link uiot-core platform
Ucloud Device Config --->
[*] Enable Ucloud Mqtt Sample
[ ] Enable Ucloud Mqtt Dynamic Auth Sample

4
samples/dev_model/dev_model_sample.c
View File

@ -125,7 +125,8 @@ static void mqtt_devmodel_thread(void)
IOT_MQTT_Yield(client, 50);
void *h_dm = IOT_DM_Init(PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN, client);
if (NULL == h_dm) {
if (NULL == h_dm) {
IOT_MQTT_Destroy(&client);
LOG_ERROR("initialize device model failed");
return;
}
@ -135,6 +136,7 @@ static void mqtt_devmodel_thread(void)
IOT_DM_RegisterCallback(COMMAND , h_dm, command_cb);
IOT_DM_RegisterCallback(PROPERTY_POST , h_dm, property_post_cb);
IOT_DM_RegisterCallback(PROPERTY_SET , h_dm, property_set_cb);
IOT_DM_Yield(h_dm, 200);
for (int i = 0; i < 10; i++) {
IOT_DM_Property_Report(h_dm, PROPERTY_POST, i * 2, "{\"volume\": {\"Value\":50}}");

121
samples/http/http_client_sample.c Normal file
View File

@ -0,0 +1,121 @@
/*
* Copyright (C) 2012-2019 UCloud. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <signal.h>
#include "uiot_import.h"
#include "ca.h"
#include "utils_httpc.h"
#include "uiot_export_http.h"
#define UIOT_PUBLISH_TOPIC "%s/%s/upload/event"
static int running_state = 0;
static void http_publish_test_thread(void)
{
char *token = (char *)HAL_Malloc(1024);
memset(token, 0, 1024);
int ret = SUCCESS_RET;
char *topic = (char *)HAL_Malloc(256);
memset(topic, 0, 256);
HAL_Snprintf((char *)topic, 256, UIOT_PUBLISH_TOPIC,PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN);
char *data = "{\"test\": \"18\"}";
ret = IOT_HTTP_Get_Token(PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SECRET, token);
if(SUCCESS_RET != ret)
{
HAL_Printf("get Token fail,ret:%d\r\n", ret);
return;
}
HAL_Printf("get token:%s\n", token);
HAL_Printf("topic:%s\n", topic);
ret = IOT_HTTP_Publish(token, topic, data, 5000);
if(SUCCESS_RET != ret)
{
HAL_Printf("Publish fail,ret:%d\r\n", ret);
return;
}
HAL_Printf("Publish success\n");
HAL_Free(token);
HAL_Free(topic);
return;
}
static int http_publish_test_example(int argc, char **argv)
{
rt_thread_t tid;
int stack_size = 8192;
if (2 == argc)
{
if (!strcmp("start", argv[1]))
{
if (1 == running_state)
{
HAL_Printf("http_publish_test_example is already running\n");
return 0;
}
}
else if (!strcmp("stop", argv[1]))
{
if (0 == running_state)
{
HAL_Printf("http_publish_test_example is already stopped\n");
return 0;
}
running_state = 0;
return 0;
}
else
{
HAL_Printf("Usage: http_publish_test_example start/stop");
return 0;
}
}
else
{
HAL_Printf("Para err, usage: http_publish_test_example start/stop");
return 0;
}
tid = rt_thread_create("http_publish_test", (void (*)(void *))http_publish_test_thread,
NULL, stack_size, RT_THREAD_PRIORITY_MAX / 2 - 1, 100);
if (tid != RT_NULL)
{
rt_thread_startup(tid);
}
return 0;
}
#ifdef RT_USING_FINSH
#include <finsh.h>
FINSH_FUNCTION_EXPORT(http_publish_test_example, startup http publish example);
#endif
#ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(http_publish_test_example, startup http publish example);
#endif

130
samples/http/upload_file_sample.c Normal file
View File

@ -0,0 +1,130 @@
/*
* Copyright (C) 2012-2019 UCloud. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <signal.h>
#include "uiot_import.h"
#include "ca.h"
#include "utils_httpc.h"
#include "uiot_export_http.h"
//upload file name saved in ufile
#define FILE_NAME "upload_file.txt"
//data saved in file that you upload
#define UPLOAD_BUFFER "This is a test file for upload test!"
static int running_state = 0;
static void http_upload_file_test_thread(void)
{
char md5[100];
char *authorization = (char *)malloc(1024);
memset(authorization, 0, 1024);
char *put_url = (char *)malloc(1024);
memset(put_url, 0, 1024);
int ret = SUCCESS_RET;
http_client_buffer_md5(UPLOAD_BUFFER, sizeof(UPLOAD_BUFFER), md5);
HAL_Printf("MD5:%s\n", md5);
ret = IOT_GET_URL_AND_AUTH(PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SECRET, \
FILE_NAME, UPLOAD_BUFFER, sizeof(UPLOAD_BUFFER), md5, authorization, put_url);
if(SUCCESS_RET != ret)
{
HAL_Printf("get url and auth fail,ret:%d\r\n", ret);
return;
}
HAL_Printf("get authorization:%s\n", authorization);
HAL_Printf("get put_url:%s\n", put_url);
//上传文件超时时间与文件长度相关
ret = IOT_HTTP_UPLOAD_FILE(FILE_NAME, UPLOAD_BUFFER, sizeof(UPLOAD_BUFFER), md5, authorization, put_url, 10000);
if(SUCCESS_RET != ret)
{
HAL_Printf("upload file fail,ret:%d\r\n", ret);
return;
}
HAL_Printf("upload success\n");
HAL_Free(authorization);
HAL_Free(put_url);
return;
}
static int http_upload_file_test_example(int argc, char **argv)
{
rt_thread_t tid;
int stack_size = 8192;
if (2 == argc)
{
if (!strcmp("start", argv[1]))
{
if (1 == running_state)
{
HAL_Printf("http_publish_test_example is already running\n");
return 0;
}
}
else if (!strcmp("stop", argv[1]))
{
if (0 == running_state)
{
HAL_Printf("http_publish_test_example is already stopped\n");
return 0;
}
running_state = 0;
return 0;
}
else
{
HAL_Printf("Usage: http_publish_test_example start/stop");
return 0;
}
}
else
{
HAL_Printf("Para err, usage: http_publish_test_example start/stop");
return 0;
}
tid = rt_thread_create("http_upload_file_test", (void (*)(void *))http_upload_file_test_thread,
NULL, stack_size, RT_THREAD_PRIORITY_MAX / 2 - 1, 100);
if (tid != RT_NULL)
{
rt_thread_startup(tid);
}
return 0;
}
#ifdef RT_USING_FINSH
#include <finsh.h>
FINSH_FUNCTION_EXPORT(http_upload_file_test_example, startup http upload_file example);
#endif
#ifdef FINSH_USING_MSH
MSH_CMD_EXPORT(http_upload_file_test_example, startup http upload_file example);
#endif

1
samples/ota/ota_sample.c
View File

@ -104,6 +104,7 @@ static void ota_test_thread(void)
void *h_ota = IOT_OTA_Init(PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN, client);
if (NULL == h_ota) {
IOT_MQTT_Destroy(&client);
LOG_ERROR("init OTA failed");
return;
}

130
samples/shadow/shadow_sample.c
View File

@ -24,14 +24,9 @@
#include "uiot_import.h"
#include "shadow_client.h"
#define MAX_SIZE_OF_TOPIC_CONTENT 100
#define SIZE_OF_JSON_BUFFER 256
static int running_state = 0;
static UIoT_Shadow *sg_pshadow;
static MQTTInitParams sg_initParams = DEFAULT_MQTT_INIT_PARAMS;
//当设备直接按照desired字段中的属性值更新时不需要上报
void RegCallback_update(void *pClient, RequestParams *pParams, char *pJsonValueBuffer, uint32_t valueLength, DeviceProperty *pProperty)
{
@ -88,33 +83,37 @@ static int _setup_connect_init_params(MQTTInitParams* initParams)
static void shadow_test_thread(void)
{
int ret = SUCCESS_RET;
ret = _setup_connect_init_params(&sg_initParams);
MQTTInitParams initParams = DEFAULT_MQTT_INIT_PARAMS;
ret = _setup_connect_init_params(&initParams);
if(ret != SUCCESS_RET)
{
HAL_Printf("_setup_connect_init_params fail:%d\n", ret);
return;
}
void *mqtt_client = IOT_MQTT_Construct(&sg_initParams);
void *mqtt_client = IOT_MQTT_Construct(&initParams);
if(mqtt_client == NULL)
{
HAL_Printf("IOT_MQTT_Construct fail\n");
return;
}
void *shadow_client = IOT_Shadow_Construct(PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN, mqtt_client);
UIoT_Shadow *shadow_client = (UIoT_Shadow *)IOT_Shadow_Construct(PKG_USING_UCLOUD_IOT_SDK_PRODUCT_SN, PKG_USING_UCLOUD_IOT_SDK_DEVICE_SN, mqtt_client);
if(shadow_client == NULL)
{
HAL_Printf("IOT_Shadow_Construct fail\n");
return;
}
sg_pshadow = (UIoT_Shadow *)shadow_client;
bool isConnected = IOT_MQTT_IsConnected(sg_pshadow->mqtt);
HAL_Printf("IOT_Shadow_Construct fail\n");
IOT_MQTT_Destroy(&mqtt_client);
}
IOT_Shadow_Yield(shadow_client, 200);
bool isConnected = IOT_MQTT_IsConnected(shadow_client->mqtt);
if(isConnected != true)
{
HAL_Printf("IOT_MQTT_IsConnected fail\n");
return;
IOT_MQTT_Destroy(&mqtt_client);
return;
}
int time_sec = MAX_WAIT_TIME_SEC;
@ -126,10 +125,13 @@ static void shadow_test_thread(void)
Property1->key= str1;
Property1->data = &num1;
Property1->type = JINT32;
ret = IOT_Shadow_Register_Property(sg_pshadow, Property1, RegCallback_hold);
ret = IOT_Shadow_Register_Property(shadow_client, Property1, RegCallback_hold);
if(SUCCESS_RET != ret)
{
HAL_Printf("Register Property1 fail:%d\n", ret);
HAL_Free(Property1);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}
@ -139,10 +141,14 @@ static void shadow_test_thread(void)
Property2->key= str2;
Property2->data = &num2;
Property2->type = JFLOAT;
ret = IOT_Shadow_Register_Property(sg_pshadow, Property2, RegCallback_update);
ret = IOT_Shadow_Register_Property(shadow_client, Property2, RegCallback_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Register Property2 fail:%d\n", ret);
HAL_Free(Property1);
HAL_Free(Property2);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}
@ -152,10 +158,14 @@ static void shadow_test_thread(void)
Property3->key= str3;
Property3->data = &num3;
Property3->type = JDOUBLE;
ret = IOT_Shadow_Register_Property(sg_pshadow, Property3, RegCallback_update);
ret = IOT_Shadow_Register_Property(shadow_client, Property3, RegCallback_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Register Property3 fail:%d\n", ret);
HAL_Free(Property1);
HAL_Free(Property2);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}
@ -165,10 +175,16 @@ static void shadow_test_thread(void)
Property4->key= str4;
Property4->data = num4;
Property4->type = JSTRING;
ret = IOT_Shadow_Register_Property(sg_pshadow, Property4, RegCallback_update);
ret = IOT_Shadow_Register_Property(shadow_client, Property4, RegCallback_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Register Property4 fail:%d\n", ret);
HAL_Free(Property1);
HAL_Free(Property2);
HAL_Free(Property3);
HAL_Free(Property4);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}
@ -178,10 +194,17 @@ static void shadow_test_thread(void)
Property5->key= str5;
Property5->data = &num5;
Property5->type = JBOOL;
ret = IOT_Shadow_Register_Property(sg_pshadow, Property5, RegCallback_update);
ret = IOT_Shadow_Register_Property(shadow_client, Property5, RegCallback_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Register Property5 fail:%d\n", ret);
HAL_Free(Property1);
HAL_Free(Property2);
HAL_Free(Property3);
HAL_Free(Property4);
HAL_Free(Property5);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}
@ -191,43 +214,51 @@ static void shadow_test_thread(void)
Property6->key= str6;
Property6->data = num6;
Property6->type = JOBJECT;
ret = IOT_Shadow_Register_Property(sg_pshadow, Property6, RegCallback_update);
ret = IOT_Shadow_Register_Property(shadow_client, Property6, RegCallback_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Register Property6 fail:%d\n", ret);
HAL_Free(Property1);
HAL_Free(Property2);
HAL_Free(Property3);
HAL_Free(Property4);
HAL_Free(Property5);
HAL_Free(Property6);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}
/* 先同步一下版本号和设备掉电期间更新的属性 */
ret = IOT_Shadow_Get_Sync(sg_pshadow, _update_ack_cb, time_sec, &ack_update);
ret = IOT_Shadow_Get_Sync(shadow_client, _update_ack_cb, time_sec, &ack_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Get Sync fail:%d\n", ret);
return;
goto end;
}
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
/* update */
ack_update = ACK_NONE;
ret = IOT_Shadow_Update(sg_pshadow, _update_ack_cb, time_sec, &ack_update, 6, Property1, Property2, Property3, Property4, Property5, Property6);
ret = IOT_Shadow_Update(shadow_client, _update_ack_cb, time_sec, &ack_update, 6, Property1, Property2, Property3, Property4, Property5, Property6);
if(SUCCESS_RET != ret)
{
HAL_Printf("Update Property1 Property2 Property3 Property4 Property5 Property6 fail:%d\n", ret);
return;
goto end;
}
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
ack_update = ACK_NONE;
ret = IOT_Shadow_Get_Sync(sg_pshadow, _update_ack_cb, time_sec, &ack_update);
ret = IOT_Shadow_Get_Sync(shadow_client, _update_ack_cb, time_sec, &ack_update);
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
/* update */
@ -238,58 +269,58 @@ static void shadow_test_thread(void)
Property4->data = num9;
ack_update = ACK_NONE;
ret = IOT_Shadow_Update(sg_pshadow, _update_ack_cb, time_sec, &ack_update, 2, Property1, Property4);
ret = IOT_Shadow_Update(shadow_client, _update_ack_cb, time_sec, &ack_update, 2, Property1, Property4);
if(SUCCESS_RET != ret)
{
HAL_Printf("Update Property1 Property4 fail:%d\n", ret);
return;
goto end;
}
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
/* delete */
ack_update = ACK_NONE;
ret = IOT_Shadow_Delete(sg_pshadow, _update_ack_cb, time_sec, &ack_update, 2, Property1, Property2);
ret = IOT_Shadow_Delete(shadow_client, _update_ack_cb, time_sec, &ack_update, 2, Property1, Property2);
if(SUCCESS_RET != ret)
{
HAL_Printf("Delete Property1 Property2 fail:%d\n", ret);
return;
goto end;
}
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
ack_update = ACK_NONE;
ret = IOT_Shadow_Get_Sync(sg_pshadow, _update_ack_cb, time_sec, &ack_update);
ret = IOT_Shadow_Get_Sync(shadow_client, _update_ack_cb, time_sec, &ack_update);
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
/* delete all */
ack_update = ACK_NONE;
ret = IOT_Shadow_Delete_All(sg_pshadow, _update_ack_cb, time_sec, &ack_update);
ret = IOT_Shadow_Delete_All(shadow_client, _update_ack_cb, time_sec, &ack_update);
if(SUCCESS_RET != ret)
{
HAL_Printf("Delete All fail:%d\n", ret);
return;
goto end;
}
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
ack_update = ACK_NONE;
ret = IOT_Shadow_Get_Sync(sg_pshadow, _update_ack_cb, time_sec, &ack_update);
ret = IOT_Shadow_Get_Sync(shadow_client, _update_ack_cb, time_sec, &ack_update);
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
Property1->data = &num1;
@ -299,31 +330,32 @@ static void shadow_test_thread(void)
/* update */
ack_update = ACK_NONE;
ret = IOT_Shadow_Update_And_Reset_Version(sg_pshadow, _update_ack_cb, time_sec, &ack_update, 4, Property1, Property4, Property5, Property6);
ret = IOT_Shadow_Update_And_Reset_Version(shadow_client, _update_ack_cb, time_sec, &ack_update, 4, Property1, Property4, Property5, Property6);
if(SUCCESS_RET != ret)
{
HAL_Printf("Update and Reset Ver fail:%d\n", ret);
return;
goto end;
}
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
ack_update = ACK_NONE;
ret = IOT_Shadow_Get_Sync(sg_pshadow, _update_ack_cb, time_sec, &ack_update);
ret = IOT_Shadow_Get_Sync(shadow_client, _update_ack_cb, time_sec, &ack_update);
while (ACK_NONE == ack_update) {
IOT_Shadow_Yield(sg_pshadow, MAX_WAIT_TIME_MS);
IOT_Shadow_Yield(shadow_client, MAX_WAIT_TIME_MS);
}
end:
HAL_Free(Property1);
HAL_Free(Property2);
HAL_Free(Property3);
HAL_Free(Property4);
HAL_Free(Property5);
HAL_Free(Property6);
IOT_Shadow_Destroy(sg_pshadow);
IOT_Shadow_Destroy(shadow_client);
IOT_MQTT_Destroy(&mqtt_client);
return;
}

237
uiot/http/http_client.c Normal file
View File

@ -0,0 +1,237 @@
/*
* Copyright (C) 2012-2019 UCloud. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "utils_httpc.h"
#include "lite-utils.h"
#include "ca.h"
#include "utils_sha2.h"
int IOT_HTTP_Get_Token(const char *product_sn, const char *device_sn, const char *device_sercret, char *token)
{
int ret = SUCCESS_RET;
http_client_t *http_client_post = (http_client_t *)HAL_Malloc(sizeof(http_client_t));
if(NULL == http_client_post)
{
LOG_ERROR("http_client_post malloc fail\n");
return FAILURE_RET;
}
http_client_data_t *http_data_post = (http_client_data_t *)HAL_Malloc(sizeof(http_client_data_t));
if(NULL == http_data_post)
{
HAL_Free(http_client_post);
LOG_ERROR("http_data_post malloc fail\n");
return FAILURE_RET;
}
memset(http_client_post, 0, sizeof(http_client_t));
memset(http_data_post, 0, sizeof(http_client_data_t));
http_data_post->response_buf = (char *)HAL_Malloc(1024);
if(NULL == http_data_post->response_buf)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post);
LOG_ERROR("http_data_post->response_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_post->response_buf, 0, 1024);
http_data_post->response_buf_len = 1024;
http_data_post->post_content_type = (char *)"application/json";
http_data_post->post_buf = (unsigned char *)HAL_Malloc(1024);
if(NULL == http_data_post->post_buf)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post);
LOG_ERROR("http_data_post->post_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_post->post_buf, 0, 1024);
HAL_Snprintf((char *)http_data_post->post_buf, 1024, "{\"ProductSN\":\"%s\",\"DeviceSN\":\"%s\"}",product_sn, device_sn);
http_data_post->post_buf_len = strlen((char *)http_data_post->post_buf);
uint8_t mac_output_hex[32] = {0};
char mac_output_char[65] = {0};
utils_hmac_sha256((const uint8_t *)http_data_post->post_buf, http_data_post->post_buf_len, (const uint8_t *)device_sercret, strlen(device_sercret), mac_output_hex);
LITE_hexbuf_convert((unsigned char *)mac_output_hex, mac_output_char, 32, 0);
LOG_DEBUG("hmac:%s\r\n",mac_output_char);
http_client_post->header = (char *)HAL_Malloc(1024);
if(NULL == http_client_post->header)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post->post_buf);
HAL_Free(http_data_post);
LOG_ERROR("http_client_post->header malloc fail\n");
return FAILURE_RET;
}
memset(http_client_post->header, 0, 1024);
HAL_Snprintf(http_client_post->header, 1024, "Content-Type: application/json\r\nAuthorization: %s\r\nbody: %s\r\n",mac_output_char,http_data_post->post_buf);
const char *ca_crt = iot_https_ca_get();
char *url = (char *)"https://http-cn-sh2.iot.ucloud.cn/auth";
ret = http_client_common(http_client_post, url, 443, ca_crt, HTTP_POST, http_data_post,5000);
if(SUCCESS_RET != ret)
{
LOG_ERROR("HTTP_POST error\n");
goto end;
}
ret = http_client_recv_data(http_client_post, 5000, http_data_post);
if(SUCCESS_RET != ret)
{
LOG_ERROR("http_client_recv_data error\n");
goto end;
}
LOG_DEBUG("response_buf:%s\n",http_data_post->response_buf);
char *temp = LITE_json_value_of((char *)"Token", http_data_post->response_buf);
if(NULL == temp)
{
LOG_ERROR("parse Token error\n");
char *temp_message = LITE_json_value_of((char *)"Message", http_data_post->response_buf);
LOG_ERROR("%s\n", temp_message);
HAL_Free(temp_message);
goto end;
}
strncpy(token,temp,strlen(temp));
token[strlen(temp)+1] = '\0';
LOG_DEBUG("token:%s\n",token);
HAL_Free(temp);
end:
http_client_close(http_client_post);
HAL_Free(http_client_post->header);
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post->post_buf);
HAL_Free(http_data_post);
return ret;
}
int IOT_HTTP_Publish(char *token, char *topic, char *data, uint32_t timeout_ms)
{
int ret = SUCCESS_RET;
http_client_t *http_client_post = (http_client_t *)HAL_Malloc(sizeof(http_client_t));
if(NULL == http_client_post)
{
LOG_ERROR("http_client_post malloc fail\n");
return FAILURE_RET;
}
http_client_data_t *http_data_post = (http_client_data_t *)HAL_Malloc(sizeof(http_client_data_t));
if(NULL == http_data_post)
{
HAL_Free(http_client_post);
LOG_ERROR("http_data_post malloc fail\n");
return FAILURE_RET;
}
memset(http_client_post, 0, sizeof(http_client_t));
memset(http_data_post, 0, sizeof(http_client_data_t));
http_data_post->response_buf = (char *)HAL_Malloc(1024);
if(NULL == http_data_post->response_buf)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post);
LOG_ERROR("http_data_post->response_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_post->response_buf, 0, 1024);
http_data_post->response_buf_len = 1024;
http_data_post->post_content_type = (char *)"application/octet-stream";
http_data_post->post_buf = (unsigned char *)HAL_Malloc(1024);
if(NULL == http_data_post->post_buf)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post);
LOG_ERROR("http_data_post->post_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_post->post_buf, 0, 1024);
HAL_Snprintf((char *)http_data_post->post_buf, 1024, "%s",data);
http_data_post->post_buf_len = strlen((char *)http_data_post->post_buf);
http_client_post->header = (char *)HAL_Malloc(1024);
if(NULL == http_client_post->header)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post->post_buf);
HAL_Free(http_data_post);
LOG_ERROR("http_client_post->header malloc fail\n");
return FAILURE_RET;
}
memset(http_client_post->header, 0, 1024);
HAL_Snprintf(http_client_post->header, 1024, "Password: %s\r\nContent-Type: application/octet-stream\r\nbody: %s\r\n", token, http_data_post->post_buf);
const char *ca_crt = iot_https_ca_get();
char *url = (char *)HAL_Malloc(256);
if(NULL == url)
{
goto end;
LOG_ERROR("http_client_post->header malloc fail\n");
return FAILURE_RET;
}
memset(url, 0, 256);
HAL_Snprintf(url, 256, "https://http-cn-sh2.iot.ucloud.cn/topic/%s",topic);
ret = http_client_common(http_client_post, url, 443, ca_crt, HTTP_POST, http_data_post,5000);
if(SUCCESS_RET != ret)
{
LOG_ERROR("HTTP_POST error\n");
goto end;
}
HAL_Free(url);
ret = http_client_recv_data(http_client_post, 5000, http_data_post);
if(SUCCESS_RET != ret)
{
LOG_ERROR("http_client_recv_data error\n");
goto end;
}
LOG_DEBUG("response_buf:%s\n",http_data_post->response_buf);
char *temp_message = LITE_json_value_of((char *)"Message", http_data_post->response_buf);
if(NULL == temp_message)
{
LOG_ERROR("parse Message error\n");
goto end;
}
LOG_DEBUG("%s\n", temp_message);
HAL_Free(temp_message);
end:
http_client_close(http_client_post);
HAL_Free(http_client_post->header);
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post->post_buf);
HAL_Free(http_data_post);
return ret;
}

231
uiot/http/http_upload_file.c Normal file
View File

@ -0,0 +1,231 @@
/*
* Copyright (C) 2012-2019 UCloud. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "utils_httpc.h"
#include "lite-utils.h"
#include "ca.h"
#include "utils_sha2.h"
int IOT_GET_URL_AND_AUTH(const char *product_sn, const char *device_sn, const char *device_sercret, char *file_name, char *upload_buffer, uint32_t upload_buffer_len, char *md5, char *authorization, char *put_url)
{
int ret = SUCCESS_RET;
http_client_t *http_client_post = (http_client_t *)HAL_Malloc(sizeof(http_client_t));
if(NULL == http_client_post)
{
LOG_ERROR("http_client_post malloc fail\n");
return FAILURE_RET;
}
http_client_data_t *http_data_post = (http_client_data_t *)HAL_Malloc(sizeof(http_client_data_t));
if(NULL == http_data_post)
{
HAL_Free(http_client_post);
LOG_ERROR("http_data_post malloc fail\n");
return FAILURE_RET;
}
memset(http_client_post, 0, sizeof(http_client_t));
memset(http_data_post, 0, sizeof(http_client_data_t));
http_data_post->response_buf = (char *)HAL_Malloc(1024);
if(NULL == http_data_post->response_buf)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post);
LOG_ERROR("http_data_post->response_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_post->response_buf, 0, 1024);
http_data_post->response_buf_len = 1024;
http_data_post->post_content_type = (char *)"application/json";
http_data_post->post_buf = (unsigned char *)HAL_Malloc(1024);
if(NULL == http_data_post->post_buf)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post);
LOG_ERROR("http_data_post->post_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_post->post_buf, 0, 1024);
HAL_Snprintf((char *)http_data_post->post_buf, 1024, "{\"ProductSN\":\"%s\",\"DeviceSN\":\"%s\"," \
"\"FileName\":\"%s\",\"FileSize\":%d,\"MD5\":\"%s\",\"Content-Type\":\"plain/text\"}", \
product_sn, device_sn, file_name, upload_buffer_len, md5);
http_data_post->post_buf_len = strlen((char *)http_data_post->post_buf);
uint8_t mac_output_hex[32] = {0};
char mac_output_char[65] = {0};
utils_hmac_sha256((const uint8_t *)http_data_post->post_buf, http_data_post->post_buf_len, (const uint8_t *)device_sercret, strlen(device_sercret), mac_output_hex);
LITE_hexbuf_convert((unsigned char *)mac_output_hex, mac_output_char, 32, 0);
LOG_DEBUG("hmac:%s\r\n",mac_output_char);
http_client_post->header = (char *)HAL_Malloc(1024);
if(NULL == http_client_post->header)
{
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post->post_buf);
HAL_Free(http_data_post);
LOG_ERROR("http_client_post->header malloc fail\n");
return FAILURE_RET;
}
memset(http_client_post->header, 0, 1024);
HAL_Snprintf(http_client_post->header, 1024, "Content-Type: application/json\r\nAuthorization:%s\r\n",mac_output_char);
const char *ca_crt = iot_https_ca_get();
char *url = (char *)"https://file-cn-sh2.iot.ucloud.cn/api/v1/url";
ret = http_client_common(http_client_post, url, 443, ca_crt, HTTP_POST, http_data_post,5000);
if(SUCCESS_RET != ret)
{
LOG_ERROR("HTTP_POST error\n");
goto end;
}
ret = http_client_recv_data(http_client_post, 5000, http_data_post);
if(SUCCESS_RET != ret)
{
LOG_ERROR("http_client_recv_data error\n");
goto end;
}
LOG_DEBUG("response_buf:%s\n",http_data_post->response_buf);
char *temp_auth = LITE_json_value_of((char *)"Authorization", http_data_post->response_buf);
if(NULL == temp_auth)
{
LOG_ERROR("parse Authorization error\n");
goto end;
}
strncpy(authorization,temp_auth,strlen(temp_auth));
authorization[strlen(temp_auth)+1] = '\0';
LOG_DEBUG("authorization:%s\n",authorization);
HAL_Free(temp_auth);
char *temp_url = LITE_json_value_of((char *)"URL", http_data_post->response_buf);
if(NULL == temp_url)
{
LOG_ERROR("parse URL error\n");
goto end;
}
strncpy(put_url,temp_url,strlen(temp_url));
put_url[strlen(temp_url)+1] = '\0';
LOG_DEBUG("put_url:%s\n",put_url);
HAL_Free(temp_url);
end:
http_client_close(http_client_post);
HAL_Free(http_client_post->header);
HAL_Free(http_client_post);
HAL_Free(http_data_post->response_buf);
HAL_Free(http_data_post->post_buf);
HAL_Free(http_data_post);
return ret;
}
int IOT_HTTP_UPLOAD_FILE(char *file_name, char *upload_buffer, uint32_t upload_buffer_len, char *md5, char *authorization, char *url, uint32_t timeout_ms)
{
int ret = SUCCESS_RET;
http_client_t *http_client_put = (http_client_t *)HAL_Malloc(sizeof(http_client_t));
if(NULL == http_client_put)
{
LOG_ERROR("http_client_put malloc fail\n");
return FAILURE_RET;
}
http_client_data_t *http_data_put = (http_client_data_t *)HAL_Malloc(sizeof(http_client_data_t));
if(NULL == http_data_put)
{
HAL_Free(http_client_put);
LOG_ERROR("http_data_put malloc fail\n");
return FAILURE_RET;
}
memset(http_client_put, 0, sizeof(http_client_t));
memset(http_data_put, 0, sizeof(http_client_data_t));
http_data_put->response_buf = (char *)HAL_Malloc(512);
if(NULL == http_data_put)
{
HAL_Free(http_client_put);
HAL_Free(http_data_put);
LOG_ERROR("http_data_put->response_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_put->response_buf, 0, 512);
http_data_put->response_buf_len = 512;
http_client_put->header = (char *)HAL_Malloc(1024);
if(NULL == http_data_put)
{
HAL_Free(http_client_put);
HAL_Free(http_data_put->response_buf);
HAL_Free(http_data_put);
LOG_ERROR("http_client_put->header malloc fail\n");
return FAILURE_RET;
}
memset(http_client_put->header, 0, 1024);
HAL_Snprintf(http_client_put->header, 1024, "Authorization:%s\r\nContent-Type:plain/text\r\nContent-MD5:%s\r\n",authorization,md5);
LOG_DEBUG("header:%s\n", http_client_put->header);
http_data_put->post_content_type = (char *)"plain/text";
http_data_put->post_buf = (unsigned char *)HAL_Malloc(upload_buffer_len + 1);
if(NULL == http_data_put->post_buf)
{
HAL_Free(http_data_put->response_buf);
HAL_Free(http_data_put);
HAL_Free(http_client_put->header);
HAL_Free(http_client_put);
LOG_ERROR("http_data_put->post_buf malloc fail\n");
return FAILURE_RET;
}
memset(http_data_put->post_buf, 0, upload_buffer_len + 1);
strncpy((char *)http_data_put->post_buf, upload_buffer, upload_buffer_len);
http_data_put->post_buf[upload_buffer_len]= '\0';
http_data_put->post_buf_len = upload_buffer_len;
const char *ca_crt = iot_https_ca_get();
ret = http_client_common(http_client_put, url, 443, ca_crt, HTTP_PUT, http_data_put, timeout_ms);
if(SUCCESS_RET != ret)
{
LOG_ERROR("http_client_common error\n");
goto end;
}
ret = http_client_recv_data(http_client_put, timeout_ms, http_data_put);
if(SUCCESS_RET != ret)
{
LOG_ERROR("http_client_recv_data error\n");
goto end;
}
LOG_DEBUG("content_len:%d response_received_len:%d\n",http_data_put->response_content_len, http_data_put->response_received_len);
LOG_DEBUG("response_buf:%s\n",http_data_put->response_buf);
end:
http_client_close(http_client_put);
HAL_Free(http_data_put->post_buf);
HAL_Free(http_data_put->response_buf);
HAL_Free(http_data_put);
HAL_Free(http_client_put->header);
HAL_Free(http_client_put);
return ret;
}

35
uiot/sdk-impl/uiot_export_http.h Normal file
View File

@ -0,0 +1,35 @@
/*
* Copyright (C) 2012-2019 UCloud. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#ifndef C_SDK_UIOT_EXPORT_HTTP_
#define C_SDK_UIOT_EXPORT_HTTP_
#if defined(__cplusplus)
extern "C" {
#endif
int IOT_HTTP_Get_Token(const char *product_sn, const char *device_sn, const char *device_sercret, char *token);
int IOT_HTTP_Publish(char *token, char *topic, char *data, uint32_t timeout_ms);
int IOT_GET_URL_AND_AUTH(const char *product_sn, const char *device_sn, const char *device_sercret, char *file_name, char *upload_buffer, uint32_t upload_buffer_len, char *md5, char *authorization, char *put_url);
int IOT_HTTP_UPLOAD_FILE(char *file_name, char *upload_buffer, uint32_t upload_buffer_len, char *md5, char *authorization, char *url, uint32_t timeout_ms);
#if defined(__cplusplus)
}
#endif
#endif

2
uiot/shadow/src/shadow_client_manager.c
View File

@ -121,6 +121,8 @@ void uiot_shadow_reset(void *pClient)
uiot_shadow_unsubscribe_topic(shadow_client,SHADOW_SUBSCRIBE_REQUEST_TEMPLATE);
uiot_shadow_unsubscribe_topic(shadow_client,SHADOW_SUBSCRIBE_SYNC_TEMPLATE);
IOT_MQTT_Yield(shadow_client->mqtt,200);
if (shadow_client->inner_data.request_list)
{

44
uiot/utils/utils_httpc.c
View File

@ -122,8 +122,15 @@ static int _http_send_header(http_client_t *client, char *host, const char *path
memset(send_buf, 0, HTTP_CLIENT_SEND_BUF_SIZE);
len = 0; /* Reset send buffer */
HAL_Snprintf(buf, sizeof(buf), "%s %s HTTP/1.1\r\nHost: %s\r\nRange: bytes=%d-%d\r\n", pMethod, path, host, size_fetched, size_fetched + range_len); /* Write request */
if(range_len != 0)
{
HAL_Snprintf(buf, sizeof(buf), "%s %s HTTP/1.1\r\nHost: %s\r\nRange: bytes=%d-%d\r\n", pMethod, path, host, size_fetched, size_fetched + range_len); /* Write request */
}
else
{
HAL_Snprintf(buf, sizeof(buf), "%s %s HTTP/1.1\r\nHost: %s\r\n", pMethod, path, host); /* Write request */
}
ret = _utils_fill_tx_buffer(client, send_buf, &len, buf, strlen(buf));
if (ret < 0) {
/* LOG_ERROR("Could not write request"); */
@ -479,6 +486,27 @@ int http_client_connect(http_client_t *client, const char *url, int port, const
return rc;
}
int http_client_common(http_client_t *client, const char *url, int port, const char *ca_crt,
HTTP_Request_Method method, http_client_data_t *client_data, uint32_t timeout_ms) {
int rc;
if (client->net.handle == 0) {
rc = http_client_connect(client, url, port, ca_crt);
if (rc != SUCCESS_RET) {
return rc;
}
}
rc = _http_send_request(client, url, method, 0, 0, client_data, timeout_ms);
if (rc != SUCCESS_RET) {
LOG_ERROR("http_send_request error, rc = %d", rc);
http_client_close(client);
return rc;
}
return SUCCESS_RET;
}
int http_client_recv_data(http_client_t *client, uint32_t timeout_ms, http_client_data_t *client_data) {
int rc = SUCCESS_RET;
Timer timer;
@ -536,6 +564,18 @@ void http_client_file_md5(char* file_path, char *output)
HAL_Free(buffer);
}
void http_client_buffer_md5(char* buffer, uint32_t buffer_len, char *output)
{
iot_md5_context ctx;
utils_md5_init(&ctx);
utils_md5_starts(&ctx);
utils_md5_update(&ctx, (unsigned char *)buffer, buffer_len);
utils_md5_finish_hb2hex(&ctx, output);
utils_md5_free(&ctx);
return;
}
#ifdef __cplusplus
}
#endif

5
uiot/utils/utils_httpc.h
View File

@ -59,6 +59,9 @@ typedef struct {
int http_client_connect(http_client_t *client, const char *url, int port, const char *ca_crt);
int http_client_common(http_client_t *client, const char *url, int port, const char *ca_crt,
HTTP_Request_Method method, http_client_data_t *client_data, uint32_t timeout_ms);
int http_client_recv_data(http_client_t *client, uint32_t timeout_ms, http_client_data_t *client_data);
void http_client_close(http_client_t *client);
@ -67,6 +70,8 @@ int _http_send_user_data(http_client_t *client, http_client_data_t *client_data,
void http_client_file_md5(char* file_path, char *output);
void http_client_buffer_md5(char* buffer, uint32_t buffer_len, char *output);
int _http_send_request(http_client_t *client, const char *url, HTTP_Request_Method method, uint32_t size_fetched, size_t range_len,
http_client_data_t *client_data, uint32_t timeout_ms);

80
uiot/utils/utils_net.c
View File

@ -80,54 +80,6 @@ static int connect_ssl(utils_network_pt pNetwork)
}
}
/*** TCP connection ***/
static int read_tcp(utils_network_pt pNetwork, unsigned char *buffer, size_t len, uint32_t timeout_ms)
{
if (NULL == pNetwork) {
LOG_ERROR("network is null");
return FAILURE_RET;
}
return HAL_TCP_Read((uintptr_t)pNetwork->handle, buffer, len, timeout_ms);
}
static int write_tcp(utils_network_pt pNetwork, unsigned char *buffer, size_t len, uint32_t timeout_ms)
{
if (NULL == pNetwork) {
LOG_ERROR("network is null");
return FAILURE_RET;
}
return HAL_TCP_Write((uintptr_t)pNetwork->handle, buffer, len, timeout_ms);
}
static int disconnect_tcp(utils_network_pt pNetwork)
{
if (NULL == pNetwork) {
LOG_ERROR("network is null");
return FAILURE_RET;
}
HAL_TCP_Disconnect(pNetwork->handle);
pNetwork->handle = (uintptr_t)(-1);
return SUCCESS_RET;
}
static int connect_tcp(utils_network_pt pNetwork)
{
if (NULL == pNetwork) {
LOG_ERROR("network is null");
return FAILURE_RET;
}
pNetwork->handle = HAL_TCP_Connect(pNetwork->pHostAddress, pNetwork->port);
if (pNetwork->handle == (uintptr_t)(-1)) {
return FAILURE_RET;
}
return SUCCESS_RET;
}
#else
/*** TCP connection ***/
static int read_tcp(utils_network_pt pNetwork, unsigned char *buffer, size_t len, uint32_t timeout_ms)
@ -184,17 +136,9 @@ int utils_net_read(utils_network_pt pNetwork, unsigned char *buffer, size_t len,
{
int ret = 0;
#ifdef PKG_USING_UCLOUD_TLS
if (NULL != pNetwork->ca_crt) {
ret = read_ssl(pNetwork, buffer, len, timeout_ms);
}
else
{
ret = read_tcp(pNetwork, buffer, len, timeout_ms);
}
#else
if (NULL == pNetwork->ca_crt) {
ret = read_tcp(pNetwork, buffer, len, timeout_ms);
}
#endif
return ret;
@ -204,17 +148,9 @@ int utils_net_write(utils_network_pt pNetwork,unsigned char *buffer, size_t len,
{
int ret = 0;
#ifdef PKG_USING_UCLOUD_TLS
if (NULL != pNetwork->ca_crt) {
ret = write_ssl(pNetwork, buffer, len, timeout_ms);
}
else
{
ret = write_tcp(pNetwork, buffer, len, timeout_ms);
}
#else
if (NULL == pNetwork->ca_crt) {
ret = write_tcp(pNetwork, buffer, len, timeout_ms);
}
#endif
return ret;
@ -224,17 +160,9 @@ int utils_net_disconnect(utils_network_pt pNetwork)
{
int ret = 0;
#ifdef PKG_USING_UCLOUD_TLS
if (NULL != pNetwork->ca_crt) {
ret = disconnect_ssl(pNetwork);
}
else
{
ret = disconnect_tcp(pNetwork);
}
#else
if (NULL == pNetwork->ca_crt) {
ret = disconnect_tcp(pNetwork);
}
#endif
return ret;
@ -244,17 +172,9 @@ int utils_net_connect(utils_network_pt pNetwork)
{
int ret = 0;
#ifdef PKG_USING_UCLOUD_TLS
if (NULL != pNetwork->ca_crt) {
ret = connect_ssl(pNetwork);
}
else
{
ret = connect_tcp(pNetwork);
}
#else
if (NULL == pNetwork->ca_crt) {
ret = connect_tcp(pNetwork);
}
#endif
return ret;