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
ucloud-iot-rtthread-package/uiot/http/http_upload_file.c

232 lines
8.4 KiB
C
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink