PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update qcloud sdk

Browse Source 
1. iot-hub sdk update to 3.2.0
2. iot-explorer update to 3.1.1
This commit is contained in:
daishengdong
2020-05-07 11:11:04 +08:00
parent c8e39739d3
commit 3e631cd96a
594 changed files with 47287 additions and 44165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1151
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/at_socket/at_client.c vendored
View File

File diff suppressed because it is too large Load Diff

520
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/at_socket/at_socket_inf.c vendored
View File

@@ -18,12 +18,12 @@
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdint.h>
#include "qcloud_iot_export.h"
#include "qcloud_iot_import.h"
#include "utils_param_check.h"
#include "utils_param_check.h"
#include "at_socket_inf.h"
/** The global array of available at */
@@ -35,83 +35,83 @@ static void *sg_at_socket_mutex;
/**at device driver ops*/
static at_device_op_t *sg_at_device_ops = NULL;
#define MAX_RECV_PKT_PER_CHAIN (10)
#define MAX_RECV_PKT_PER_CHAIN (10)
static at_device_op_t * _at_device_op_get(void)
{
return sg_at_device_ops;
return sg_at_device_ops;
}
static int _at_socket_ctx_free(at_socket_ctx_t *pCtx)
{
POINTER_SANITY_CHECK(pCtx, QCLOUD_ERR_INVAL);
pCtx->fd = UNUSED_SOCKET;
pCtx->net_type = eNET_DEFAULT;
POINTER_SANITY_CHECK(pCtx, QCLOUD_ERR_INVAL);
if(pCtx->recvpkt_list){
list_destroy(pCtx->recvpkt_list);
pCtx->recvpkt_list = NULL;
}
if(pCtx->recv_lock){
HAL_MutexDestroy(pCtx->recv_lock);
pCtx->recv_lock = NULL;
}
return QCLOUD_RET_SUCCESS;
pCtx->fd = UNUSED_SOCKET;
pCtx->net_type = eNET_DEFAULT;
if (pCtx->recvpkt_list) {
list_destroy(pCtx->recvpkt_list);
pCtx->recvpkt_list = NULL;
}
if (pCtx->recv_lock) {
HAL_MutexDestroy(pCtx->recv_lock);
pCtx->recv_lock = NULL;
}
return QCLOUD_RET_SUCCESS;
}
static at_socket_ctx_t *_at_socket_ctx_alloc(void)
{
int i;
int i;
for (i = 0; i < MAX_AT_SOCKET_NUM; i++) {
if (at_socket_ctxs[i].state == eSOCKET_CLOSED) {
at_socket_ctxs[i].net_type = eNET_DEFAULT;
at_socket_ctxs[i].send_timeout_ms = AT_SOCKET_SEND_TIMEOUT_MS;
at_socket_ctxs[i].recv_timeout_ms = AT_SOCKET_RECV_TIMEOUT_MS;
at_socket_ctxs[i].dev_op = _at_device_op_get();
at_socket_ctxs[i].recv_lock = HAL_MutexCreate();
if(NULL == at_socket_ctxs[i].recv_lock){
Log_e("create recv lock fail");
goto exit;
}
at_socket_ctxs[i].recvpkt_list = list_new();
if(NULL != at_socket_ctxs[i].recvpkt_list){
at_socket_ctxs[i].recvpkt_list->free = HAL_Free;
}else {
Log_e("no memory to allocate recvpkt_list");
goto exit;
}
at_socket_ctxs[i].state = eSOCKET_ALLOCED;
return &at_socket_ctxs[i];
}
}
for (i = 0; i < MAX_AT_SOCKET_NUM; i++) {
if (at_socket_ctxs[i].state == eSOCKET_CLOSED) {
at_socket_ctxs[i].net_type = eNET_DEFAULT;
at_socket_ctxs[i].send_timeout_ms = AT_SOCKET_SEND_TIMEOUT_MS;
at_socket_ctxs[i].recv_timeout_ms = AT_SOCKET_RECV_TIMEOUT_MS;
at_socket_ctxs[i].dev_op = _at_device_op_get();
at_socket_ctxs[i].recv_lock = HAL_MutexCreate();
if (NULL == at_socket_ctxs[i].recv_lock) {
Log_e("create recv lock fail");
goto exit;
}
at_socket_ctxs[i].recvpkt_list = list_new();
if (NULL != at_socket_ctxs[i].recvpkt_list) {
at_socket_ctxs[i].recvpkt_list->free = HAL_Free;
} else {
Log_e("no memory to allocate recvpkt_list");
goto exit;
}
at_socket_ctxs[i].state = eSOCKET_ALLOCED;
return &at_socket_ctxs[i];
}
}
exit:
if(i < MAX_AT_SOCKET_NUM){
_at_socket_ctx_free(&at_socket_ctxs[i]);
}
return NULL;
if (i < MAX_AT_SOCKET_NUM) {
_at_socket_ctx_free(&at_socket_ctxs[i]);
}
return NULL;
}
static at_socket_ctx_t *_at_socket_find(int fd)
{
int i;
for (i = 0; i < MAX_AT_SOCKET_NUM; i++) {
if (at_socket_ctxs[i].fd == fd) {
return &at_socket_ctxs[i];
}
}
int i;
return NULL;
for (i = 0; i < MAX_AT_SOCKET_NUM; i++) {
if (at_socket_ctxs[i].fd == fd) {
return &at_socket_ctxs[i];
}
}
return NULL;
}
/* get a block to the AT socket receive list*/
@@ -119,15 +119,15 @@ static int _at_recvpkt_put(List *rlist, const char *ptr, size_t length)
{
at_recv_pkt *pkt = NULL;
if(rlist->len > MAX_RECV_PKT_PER_CHAIN){
Log_e("Too many recv packets wait for read");
HAL_Free(pkt);
return QCLOUD_ERR_FAILURE;
}
if (rlist->len > MAX_RECV_PKT_PER_CHAIN) {
Log_e("Too many recv packets wait for read");
HAL_Free(pkt);
return QCLOUD_ERR_FAILURE;
}
pkt = (at_recv_pkt *) HAL_Malloc(sizeof(struct at_recv_pkt));
if (pkt == NULL){
Log_e("No memory for receive packet table!");
if (pkt == NULL) {
Log_e("No memory for receive packet table!");
return QCLOUD_ERR_FAILURE;
}
@@ -135,281 +135,281 @@ static int _at_recvpkt_put(List *rlist, const char *ptr, size_t length)
pkt->bfsz_index = 0;
pkt->buff = (char *) ptr;
ListNode *node = list_node_new(pkt);
ListNode *node = list_node_new(pkt);
if (NULL == node) {
Log_e("run list_node_new is error!");
HAL_Free(pkt);
HAL_Free(pkt);
return QCLOUD_ERR_FAILURE;
}
list_rpush(rlist, node);
return length;
}
/* get a block from AT socket receive list */
static int _at_recvpkt_get(List *pkt_list, char *buff, size_t len)
{
ListIterator *iter;
ListNode *node = NULL;
at_recv_pkt *pkt;
size_t readlen = 0, page_len = 0;
POINTER_SANITY_CHECK(buff, QCLOUD_ERR_INVAL);
ListIterator *iter;
ListNode *node = NULL;
at_recv_pkt *pkt;
size_t readlen = 0, page_len = 0;
POINTER_SANITY_CHECK(buff, QCLOUD_ERR_INVAL);
if (pkt_list->len) {
iter = list_iterator_new(pkt_list, LIST_HEAD);
iter = list_iterator_new(pkt_list, LIST_HEAD);
if (NULL == iter) {
Log_e("new listiterator fail");
return QCLOUD_ERR_TCP_READ_FAIL;
Log_e("new listiterator fail");
return QCLOUD_ERR_TCP_READ_FAIL;
}
/*traverse recv pktlist*/
do{
node = list_iterator_next(iter);
/*traverse recv pktlist*/
do {
node = list_iterator_next(iter);
if (!node) {
break;
break;
}
/*get recv packet*/
pkt = (at_recv_pkt *)(node->val);
if(!pkt){
Log_e("pkt is invalid!");
list_remove(pkt_list, node);
continue;
}
page_len = pkt->bfsz_totle - pkt->bfsz_index;
if(page_len >= (len - readlen)){
memcpy(buff + readlen, pkt->buff + pkt->bfsz_index, (len - readlen));
pkt->bfsz_index += len - readlen;
readlen = len;
break;
}else{
memcpy(buff + readlen, pkt->buff + pkt->bfsz_index, page_len);
readlen += page_len;
/*delete pkt after read*/
HAL_Free(pkt->buff);
list_remove(pkt_list, node);
}
}while(1);
/*get recv packet*/
pkt = (at_recv_pkt *)(node->val);
if (!pkt) {
Log_e("pkt is invalid!");
list_remove(pkt_list, node);
continue;
}
page_len = pkt->bfsz_totle - pkt->bfsz_index;
if (page_len >= (len - readlen)) {
memcpy(buff + readlen, pkt->buff + pkt->bfsz_index, (len - readlen));
pkt->bfsz_index += len - readlen;
readlen = len;
break;
} else {
memcpy(buff + readlen, pkt->buff + pkt->bfsz_index, page_len);
readlen += page_len;
/*delete pkt after read*/
HAL_Free(pkt->buff);
list_remove(pkt_list, node);
}
} while (1);
list_iterator_destroy(iter);
}
return readlen;
return readlen;
}
static void _at_socket_recv_cb(int fd, at_socket_evt_t event, char *buff, size_t bfsz)
{
POINTER_SANITY_CHECK_RTN(buff);
at_socket_ctx_t *pAtSocket;
if(event == AT_SOCKET_EVT_RECV){
HAL_MutexLock(sg_at_socket_mutex);
pAtSocket = _at_socket_find(fd + MAX_AT_SOCKET_NUM);
if(_at_recvpkt_put(pAtSocket->recvpkt_list, buff, bfsz) < 0){
Log_e("put recv package to list fail");
HAL_Free(buff);
}
HAL_MutexUnlock(sg_at_socket_mutex);
}
POINTER_SANITY_CHECK_RTN(buff);
at_socket_ctx_t *pAtSocket;
if (event == AT_SOCKET_EVT_RECV) {
HAL_MutexLock(sg_at_socket_mutex);
pAtSocket = _at_socket_find(fd + MAX_AT_SOCKET_NUM);
if (_at_recvpkt_put(pAtSocket->recvpkt_list, buff, bfsz) < 0) {
Log_e("put recv package to list fail");
HAL_Free(buff);
}
HAL_MutexUnlock(sg_at_socket_mutex);
}
}
static void _at_socket_closed_cb(int fd, at_socket_evt_t event, char *buff, size_t bfsz)
{
//fancyxu
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd + MAX_AT_SOCKET_NUM);
if(event == AT_SOCKET_EVT_CLOSED) {
HAL_MutexLock(sg_at_socket_mutex);
pAtSocket->state = eSOCKET_CLOSED;
_at_socket_ctx_free(pAtSocket);
HAL_MutexUnlock(sg_at_socket_mutex);
}
//fancyxu
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd + MAX_AT_SOCKET_NUM);
if (event == AT_SOCKET_EVT_CLOSED) {
HAL_MutexLock(sg_at_socket_mutex);
pAtSocket->state = eSOCKET_CLOSED;
_at_socket_ctx_free(pAtSocket);
HAL_MutexUnlock(sg_at_socket_mutex);
}
}
int at_device_op_register(at_device_op_t *device_op)
{
int rc;
if(NULL == sg_at_device_ops){
sg_at_device_ops = device_op;
rc = QCLOUD_RET_SUCCESS;
}else{
Log_e("pre device op already register");
rc = QCLOUD_ERR_FAILURE;
}
int rc;
return rc;
if (NULL == sg_at_device_ops) {
sg_at_device_ops = device_op;
rc = QCLOUD_RET_SUCCESS;
} else {
Log_e("pre device op already register");
rc = QCLOUD_ERR_FAILURE;
}
return rc;
}
int at_socket_init(void)
{
int i;
int rc = QCLOUD_RET_SUCCESS;
int i;
int rc = QCLOUD_RET_SUCCESS;
for(i = 0; i < MAX_AT_SOCKET_NUM; i++){
at_socket_ctxs[i].fd = UNUSED_SOCKET;
at_socket_ctxs[i].state = eSOCKET_CLOSED;
at_socket_ctxs[i].dev_op = NULL;
at_socket_ctxs[i].recvpkt_list = NULL;
}
for (i = 0; i < MAX_AT_SOCKET_NUM; i++) {
at_socket_ctxs[i].fd = UNUSED_SOCKET;
at_socket_ctxs[i].state = eSOCKET_CLOSED;
at_socket_ctxs[i].dev_op = NULL;
at_socket_ctxs[i].recvpkt_list = NULL;
}
sg_at_socket_mutex = HAL_MutexCreate();
if (sg_at_socket_mutex == NULL) {
Log_e("create sg_at_socket_mutex fail \n");
rc = QCLOUD_ERR_FAILURE;
}
sg_at_socket_mutex = HAL_MutexCreate();
if (sg_at_socket_mutex == NULL) {
Log_e("create sg_at_socket_mutex fail \n");
rc = QCLOUD_ERR_FAILURE;
}
if(NULL != sg_at_device_ops){
if(QCLOUD_RET_SUCCESS == sg_at_device_ops->init()){
Log_d("at device %s init success", (NULL == sg_at_device_ops->deviceName)?"noname":sg_at_device_ops->deviceName);
sg_at_device_ops->set_event_cb(AT_SOCKET_EVT_RECV, _at_socket_recv_cb);
sg_at_device_ops->set_event_cb(AT_SOCKET_EVT_CLOSED, _at_socket_closed_cb);
}else{
Log_e("at device %s init fail", (NULL == sg_at_device_ops->deviceName)?"noname":sg_at_device_ops->deviceName);
}
}
if (NULL != sg_at_device_ops) {
if (QCLOUD_RET_SUCCESS == sg_at_device_ops->init()) {
Log_d("at device %s init success", (NULL == sg_at_device_ops->deviceName) ? "noname" : sg_at_device_ops->deviceName);
sg_at_device_ops->set_event_cb(AT_SOCKET_EVT_RECV, _at_socket_recv_cb);
sg_at_device_ops->set_event_cb(AT_SOCKET_EVT_CLOSED, _at_socket_closed_cb);
} else {
Log_e("at device %s init fail", (NULL == sg_at_device_ops->deviceName) ? "noname" : sg_at_device_ops->deviceName);
}
}
return rc;
return rc;
}
int at_socket_parse_domain(const char *host_name, char *host_ip, size_t host_ip_len)
{
at_device_op_t *at_op = _at_device_op_get();
POINTER_SANITY_CHECK(at_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(at_op->parse_domain, QCLOUD_ERR_INVAL);
at_device_op_t *at_op = _at_device_op_get();
POINTER_SANITY_CHECK(at_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(at_op->parse_domain, QCLOUD_ERR_INVAL);
return at_op->parse_domain(host_name, host_ip, host_ip_len);
return at_op->parse_domain(host_name, host_ip, host_ip_len);
}
int at_socket_get_local_mac(char *macbuff, size_t bufflen)
{
at_device_op_t *at_op = _at_device_op_get();
POINTER_SANITY_CHECK(at_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(at_op->get_local_mac, QCLOUD_ERR_INVAL);
return at_op->get_local_mac(macbuff, bufflen);
at_device_op_t *at_op = _at_device_op_get();
POINTER_SANITY_CHECK(at_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(at_op->get_local_mac, QCLOUD_ERR_INVAL);
return at_op->get_local_mac(macbuff, bufflen);
}
int at_socket_get_local_ip(char *ip, size_t iplen, char *gw, size_t gwlen, char *mask, size_t masklen)
{
at_device_op_t *at_op = _at_device_op_get();
POINTER_SANITY_CHECK(at_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(at_op->get_local_ip, QCLOUD_ERR_INVAL);
return at_op->get_local_ip(ip, iplen, gw, gwlen, mask, masklen);
at_device_op_t *at_op = _at_device_op_get();
POINTER_SANITY_CHECK(at_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(at_op->get_local_ip, QCLOUD_ERR_INVAL);
return at_op->get_local_ip(ip, iplen, gw, gwlen, mask, masklen);
}
int at_socket_connect(const char *host, uint16_t port, eNetProto eProto)
{
at_socket_ctx_t *pAtSocket;
int fd;
{
at_socket_ctx_t *pAtSocket;
int fd;
HAL_MutexLock(sg_at_socket_mutex);
pAtSocket = _at_socket_ctx_alloc();
HAL_MutexUnlock(sg_at_socket_mutex);
if((NULL == pAtSocket) || (NULL == pAtSocket->dev_op)|| (NULL == pAtSocket->dev_op->connect)){
Log_e("alloc socket fail");
return QCLOUD_ERR_FAILURE;
}
HAL_MutexLock(sg_at_socket_mutex);
pAtSocket = _at_socket_ctx_alloc();
HAL_MutexUnlock(sg_at_socket_mutex);
fd = pAtSocket->dev_op->connect(host, port, eProto);
if(fd < 0){
Log_e("dev_op connect fail,pls check at device driver!");
_at_socket_ctx_free(pAtSocket);
}else{
pAtSocket->fd = fd + MAX_AT_SOCKET_NUM;
pAtSocket->state = eSOCKET_CONNECTED;
}
return pAtSocket->fd;
if ((NULL == pAtSocket) || (NULL == pAtSocket->dev_op) || (NULL == pAtSocket->dev_op->connect)) {
Log_e("alloc socket fail");
return QCLOUD_ERR_FAILURE;
}
fd = pAtSocket->dev_op->connect(host, port, eProto);
if (fd < 0) {
Log_e("dev_op connect fail,pls check at device driver!");
_at_socket_ctx_free(pAtSocket);
} else {
pAtSocket->fd = fd + MAX_AT_SOCKET_NUM;
pAtSocket->state = eSOCKET_CONNECTED;
}
return pAtSocket->fd;
}
int at_socket_close(int fd)
{
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd);
if(NULL==pAtSocket) { //server close the connection
Log_e("socket was closed");
return QCLOUD_ERR_TCP_PEER_SHUTDOWN;
}
int rc;
if((eSOCKET_CONNECTED == pAtSocket->state) && (NULL != pAtSocket->dev_op) && (NULL != pAtSocket->dev_op->close)) {
rc = pAtSocket->dev_op->close(pAtSocket->fd - MAX_AT_SOCKET_NUM);
} else {
rc = QCLOUD_ERR_FAILURE;
}
return rc;
{
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd);
if (NULL == pAtSocket) { //server close the connection
Log_e("socket was closed");
return QCLOUD_ERR_TCP_PEER_SHUTDOWN;
}
int rc;
if ((eSOCKET_CONNECTED == pAtSocket->state) && (NULL != pAtSocket->dev_op) && (NULL != pAtSocket->dev_op->close)) {
rc = pAtSocket->dev_op->close(pAtSocket->fd - MAX_AT_SOCKET_NUM);
} else {
rc = QCLOUD_ERR_FAILURE;
}
return rc;
}
int at_socket_send(int fd, const void *buf, size_t len)
{
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd);
POINTER_SANITY_CHECK(pAtSocket, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op->send, QCLOUD_ERR_INVAL);
if(pAtSocket->state != eSOCKET_CONNECTED){
Log_e("socket was closed");
return QCLOUD_ERR_TCP_PEER_SHUTDOWN;
}else{
return pAtSocket->dev_op->send(fd - MAX_AT_SOCKET_NUM, buf, len);
}
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd);
POINTER_SANITY_CHECK(pAtSocket, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op->send, QCLOUD_ERR_INVAL);
if (pAtSocket->state != eSOCKET_CONNECTED) {
Log_e("socket was closed");
return QCLOUD_ERR_TCP_PEER_SHUTDOWN;
} else {
return pAtSocket->dev_op->send(fd - MAX_AT_SOCKET_NUM, buf, len);
}
}
int at_socket_recv(int fd, void *buf, size_t len)
{
at_socket_ctx_t *pAtSocket;
size_t recv_len;
pAtSocket = _at_socket_find(fd);
POINTER_SANITY_CHECK(pAtSocket, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op->recv_timeout, QCLOUD_ERR_INVAL);
at_socket_ctx_t *pAtSocket;
size_t recv_len;
if(pAtSocket->state != eSOCKET_CONNECTED){
Log_e("socket was closed");
return QCLOUD_ERR_TCP_READ_FAIL;
}else{
HAL_MutexLock(pAtSocket->recv_lock);
pAtSocket = _at_socket_find(fd);
POINTER_SANITY_CHECK(pAtSocket, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op->recv_timeout, QCLOUD_ERR_INVAL);
//call at device recv driver for os and nonos
if(pAtSocket->recvpkt_list->len == 0) {
if(pAtSocket->dev_op->recv_timeout(fd - MAX_AT_SOCKET_NUM, buf, len, pAtSocket->recv_timeout_ms) != QCLOUD_RET_SUCCESS) {
Log_e("at device recv err"); //do not return yet
}
}
if (pAtSocket->state != eSOCKET_CONNECTED) {
Log_e("socket was closed");
return QCLOUD_ERR_TCP_READ_FAIL;
} else {
HAL_MutexLock(pAtSocket->recv_lock);
/* receive packet list last transmission of remaining data */
recv_len = _at_recvpkt_get(pAtSocket->recvpkt_list, (char *)buf, len);
HAL_MutexUnlock(pAtSocket->recv_lock);
}
//call at device recv driver for os and nonos
if (pAtSocket->recvpkt_list->len == 0) {
if (pAtSocket->dev_op->recv_timeout(fd - MAX_AT_SOCKET_NUM, buf, len, pAtSocket->recv_timeout_ms) != QCLOUD_RET_SUCCESS) {
Log_e("at device recv err"); //do not return yet
}
}
return recv_len;
/* receive packet list last transmission of remaining data */
recv_len = _at_recvpkt_get(pAtSocket->recvpkt_list, (char *)buf, len);
HAL_MutexUnlock(pAtSocket->recv_lock);
}
return recv_len;
}
int at_socket_recv_timeout(int fd, void *buf, size_t len, uint32_t timeout)
{
at_socket_ctx_t *pAtSocket;
pAtSocket = _at_socket_find(fd);
POINTER_SANITY_CHECK(pAtSocket, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op->recv_timeout, QCLOUD_ERR_INVAL);
at_socket_ctx_t *pAtSocket;
if(pAtSocket->state != eSOCKET_CONNECTED){
Log_e("socket was closed");
return QCLOUD_ERR_TCP_PEER_SHUTDOWN;
}else{
return pAtSocket->dev_op->recv_timeout(fd - MAX_AT_SOCKET_NUM, buf, len, timeout);
}
pAtSocket = _at_socket_find(fd);
POINTER_SANITY_CHECK(pAtSocket, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pAtSocket->dev_op->recv_timeout, QCLOUD_ERR_INVAL);
if (pAtSocket->state != eSOCKET_CONNECTED) {
Log_e("socket was closed");
return QCLOUD_ERR_TCP_PEER_SHUTDOWN;
} else {
return pAtSocket->dev_op->recv_timeout(fd - MAX_AT_SOCKET_NUM, buf, len, timeout);
}
}

452
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/at_socket/at_utils.c vendored
View File

@@ -38,29 +38,21 @@ void at_print_raw_cmd(const char *name, const char *buf, int size)
{
int i, j;
for (i = 0; i < size; i += WIDTH_SIZE)
{
for (i = 0; i < size; i += WIDTH_SIZE) {
HAL_Printf("%s: %04X-%04X: ", name, i, i + WIDTH_SIZE);
for (j = 0; j < WIDTH_SIZE; j++)
{
if (i + j < size)
{
for (j = 0; j < WIDTH_SIZE; j++) {
if (i + j < size) {
HAL_Printf("%02X ", buf[i + j]);
}
else
{
} else {
HAL_Printf(" ");
}
if ((j + 1) % 8 == 0)
{
if ((j + 1) % 8 == 0) {
HAL_Printf(" ");
}
}
HAL_Printf(" ");
for (j = 0; j < WIDTH_SIZE; j++)
{
if (i + j < size)
{
for (j = 0; j < WIDTH_SIZE; j++) {
if (i + j < size) {
HAL_Printf("%c", __is_print(buf[i + j]) ? buf[i + j] : '.');
}
}
@@ -98,214 +90,210 @@ int at_vprintfln(const char *format, va_list args)
/**
* at_sscanf - Unformat a buffer into a list of arguments, rewrite sscanf
* @buf: input buffer
* @fmt: format of buffer
* @args: arguments
* @buf: input buffer
* @fmt: format of buffer
* @args: arguments
*/
int at_sscanf(const char * buf, const char * fmt, va_list args)
{
const char *str = buf;
char *next;
int num = 0;
int qualifier;
int base;
int field_width = -1;
int is_sign = 0;
const char *str = buf;
char *next;
int num = 0;
int qualifier;
int base;
int field_width = -1;
int is_sign = 0;
while(*fmt && *str) {
/* skip any white space in format */
/* white space in format matchs any amount of
* white space, including none, in the input.
*/
if (isspace(*fmt)) {
while (isspace(*fmt))
++fmt;
while (isspace(*str))
++str;
}
while (*fmt && *str) {
/* skip any white space in format */
/* white space in format matchs any amount of
* white space, including none, in the input.
*/
if (isspace(*fmt)) {
while (isspace(*fmt))
++fmt;
while (isspace(*str))
++str;
}
/* anything that is not a conversion must match exactly */
if (*fmt != '%' && *fmt) {
if (*fmt++ != *str++)
break;
continue;
}
/* anything that is not a conversion must match exactly */
if (*fmt != '%' && *fmt) {
if (*fmt++ != *str++)
break;
continue;
}
if (!*fmt)
break;
++fmt;
/* skip this conversion.
* advance both strings to next white space
*/
if (*fmt == '*') {
while (!isspace(*fmt) && *fmt)
fmt++;
while (!isspace(*str) && *str)
str++;
continue;
}
if (!*fmt)
break;
++fmt;
/* get field width */
if (isdigit(*fmt))
field_width = atoi(fmt);
/* skip this conversion.
* advance both strings to next white space
*/
if (*fmt == '*') {
while (!isspace(*fmt) && *fmt)
fmt++;
while (!isspace(*str) && *str)
str++;
continue;
}
/* get conversion qualifier */
qualifier = -1;
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'Z') {
qualifier = *fmt;
fmt++;
}
base = 10;
is_sign = 0;
/* get field width */
if (isdigit(*fmt))
field_width = atoi(fmt);
if (!*fmt || !*str)
break;
/* get conversion qualifier */
qualifier = -1;
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'Z') {
qualifier = *fmt;
fmt++;
}
base = 10;
is_sign = 0;
switch(*fmt++) {
case 'c':
{
char *s = (char *) va_arg(args,char*);
if (field_width == -1)
field_width = 1;
do {
*s++ = *str++;
} while(field_width-- > 0 && *str);
num++;
}
continue;
case 's':
{
char *s = (char *) va_arg(args, char *);
if(field_width == -1)
field_width = INT_MAX;
/* first, skip leading white space in buffer */
while (isspace(*str))
str++;
if (!*fmt || !*str)
break;
/* now copy until next white space */
while (*str && ((*str) != ',')) {
if(isspace(*str)){
str++;
}else{
*s++ = *str++;
}
}
*s = '\0';
num++;
}
continue;
/* S for special handling for MQTTPUB JSON content */
case 'S':
{
char *s = (char *) va_arg(args, char *);
if(field_width == -1)
field_width = INT_MAX;
/* first, skip leading white space in buffer */
while (isspace(*str))
str++;
switch (*fmt++) {
case 'c': {
char *s = (char *) va_arg(args, char*);
if (field_width == -1)
field_width = 1;
do {
*s++ = *str++;
} while (field_width-- > 0 && *str);
num++;
}
continue;
case 's': {
char *s = (char *) va_arg(args, char *);
if (field_width == -1)
field_width = INT_MAX;
/* first, skip leading white space in buffer */
while (isspace(*str))
str++;
/* now copy until next white space */
while (*str) {
if(isspace(*str)){
str++;
}else{
*s++ = *str++;
}
}
*s = '\0';
num++;
}
continue;
case 'n':
/* return number of characters read so far */
{
int *i = (int *)va_arg(args,int*);
*i = str - buf;
}
continue;
case 'o':
base = 8;
break;
case 'x':
case 'X':
base = 16;
break;
case 'd':
case 'i':
is_sign = 1;
case 'u':
break;
case '%':
/* looking for '%' in str */
if (*str++ != '%')
return num;
continue;
default:
/* invalid format; stop here */
return num;
}
/* now copy until next white space */
while (*str && ((*str) != ',')) {
if (isspace(*str)) {
str++;
} else {
*s++ = *str++;
}
}
*s = '\0';
num++;
}
continue;
/* S for special handling for MQTTPUB JSON content */
case 'S': {
char *s = (char *) va_arg(args, char *);
if (field_width == -1)
field_width = INT_MAX;
/* first, skip leading white space in buffer */
while (isspace(*str))
str++;
/* have some sort of integer conversion.
* first, skip white space in buffer.
*/
while (isspace(*str))
str++;
/* now copy until next white space */
while (*str) {
if (isspace(*str)) {
str++;
} else {
*s++ = *str++;
}
}
*s = '\0';
num++;
}
continue;
case 'n':
/* return number of characters read so far */
{
int *i = (int *)va_arg(args, int*);
*i = str - buf;
}
continue;
case 'o':
base = 8;
break;
case 'x':
case 'X':
base = 16;
break;
case 'd':
case 'i':
is_sign = 1;
case 'u':
break;
case '%':
/* looking for '%' in str */
if (*str++ != '%')
return num;
continue;
default:
/* invalid format; stop here */
return num;
}
if (!*str || !isdigit(*str))
break;
/* have some sort of integer conversion.
* first, skip white space in buffer.
*/
while (isspace(*str))
str++;
switch(qualifier) {
case 'h':
if (is_sign) {
short *s = (short *) va_arg(args,short *);
*s = (short) strtol(str,&next,base);
} else {
unsigned short *s = (unsigned short *) va_arg(args, unsigned short *);
*s = (unsigned short) strtoul(str, &next, base);
}
break;
case 'l':
if (is_sign) {
long *l = (long *) va_arg(args,long *);
*l = strtol(str,&next,base);
} else {
unsigned long *l = (unsigned long*) va_arg(args,unsigned long*);
*l = strtoul(str,&next,base);
}
break;
case 'L':
if (is_sign) {
long long *l = (long long*) va_arg(args,long long *);
*l = strtoll(str,&next,base);
} else {
unsigned long long *l = (unsigned long long*) va_arg(args,unsigned long long*);
*l = strtoull(str,&next,base);
}
break;
case 'Z':
{
unsigned long *s = (unsigned long*) va_arg(args,unsigned long*);
*s = (unsigned long) strtoul(str,&next,base);
}
break;
default:
if (is_sign) {
int *i = (int *) va_arg(args, int*);
*i = (int) strtol(str,&next,base);
} else {
unsigned int *i = (unsigned int*) va_arg(args, unsigned int*);
*i = (unsigned int) strtoul(str,&next,base);
}
break;
}
num++;
if (!*str || !isdigit(*str))
break;
if (!next)
break;
str = next;
}
return num;
switch (qualifier) {
case 'h':
if (is_sign) {
short *s = (short *) va_arg(args, short *);
*s = (short) strtol(str, &next, base);
} else {
unsigned short *s = (unsigned short *) va_arg(args, unsigned short *);
*s = (unsigned short) strtoul(str, &next, base);
}
break;
case 'l':
if (is_sign) {
long *l = (long *) va_arg(args, long *);
*l = strtol(str, &next, base);
} else {
unsigned long *l = (unsigned long*) va_arg(args, unsigned long*);
*l = strtoul(str, &next, base);
}
break;
case 'L':
if (is_sign) {
long long *l = (long long*) va_arg(args, long long *);
*l = strtoll(str, &next, base);
} else {
unsigned long long *l = (unsigned long long*) va_arg(args, unsigned long long*);
*l = strtoull(str, &next, base);
}
break;
case 'Z': {
unsigned long *s = (unsigned long*) va_arg(args, unsigned long*);
*s = (unsigned long) strtoul(str, &next, base);
}
break;
default:
if (is_sign) {
int *i = (int *) va_arg(args, int*);
*i = (int) strtol(str, &next, base);
} else {
unsigned int *i = (unsigned int*) va_arg(args, unsigned int*);
*i = (unsigned int) strtoul(str, &next, base);
}
break;
}
num++;
if (!next)
break;
str = next;
}
return num;
}
/**
@@ -316,7 +304,7 @@ int at_sscanf(const char * buf, const char * fmt, va_list args)
*
* @return -1 : parse arguments failed
* 0 : parse without match
* >0 : The number of arguments successfully parsed
* >0 : The number of arguments successfully parsed
*/
int at_req_parse_args(const char *req_args, const char *req_expr, ...)
{
@@ -328,9 +316,9 @@ int at_req_parse_args(const char *req_args, const char *req_expr, ...)
va_start(args, req_expr);
//req_args_num = vsscanf(req_args, req_expr, args);
//req_args_num = vsscanf(req_args, req_expr, args);
req_args_num = at_sscanf(req_args, req_expr, args);
va_end(args);
@@ -339,34 +327,30 @@ int at_req_parse_args(const char *req_args, const char *req_expr, ...)
void at_strip(char *str, const char patten)
{
char *start, *end;
start = str;
end = str + strlen(str) -1;
if(*str == patten)
{
start++;
}
char *start, *end;
if(*end == patten)
{
*end-- = '\0';
}
start = str;
end = str + strlen(str) - 1;
strcpy(str, start);
if (*str == patten) {
start++;
}
if (*end == patten) {
*end-- = '\0';
}
strcpy(str, start);
}
void chr_strip(char *str, const char patten)
{
char *end = str + strlen(str);
while(*str != '\0')
{
if(*str == patten)
{
memmove(str, str+1, end - str);
}
str++;
}
char *end = str + strlen(str);
while (*str != '\0') {
if (*str == patten) {
memmove(str, str + 1, end - str);
}
str++;
}
}

183
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/at_socket/network_at_tcp.c vendored
View File

@@ -32,119 +32,112 @@
int network_at_tcp_init(Network *pNetwork)
{
int rc;
/*at device init entry: at_client init, device driver register to at_socket*/
rc = at_device_init();
if(QCLOUD_RET_SUCCESS != rc)
{
Log_e("at device init fail,rc:%d",rc);
return rc;
}
/*do after at device init*/
rc = at_socket_init();
if(QCLOUD_RET_SUCCESS != rc)
{
Log_e("at socket init fail,rc:%d",rc);
}
int rc;
return rc;
/*at device init entry: at_client init, device driver register to at_socket*/
rc = at_device_init();
if (QCLOUD_RET_SUCCESS != rc) {
Log_e("at device init fail,rc:%d", rc);
return rc;
}
/*do after at device init*/
rc = at_socket_init();
if (QCLOUD_RET_SUCCESS != rc) {
Log_e("at socket init fail,rc:%d", rc);
}
return rc;
}
int network_at_tcp_connect(Network *pNetwork)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
int fd = at_socket_connect(pNetwork->host, pNetwork->port, eNET_TCP);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
if (fd < 0) {
Log_e("fail to connect with TCP server: %s:%u", pNetwork->host, pNetwork->port);
pNetwork->handle = AT_NO_CONNECTED_FD;
return -1;
}
else {
Log_d("connected with TCP server: %s:%u", pNetwork->host, pNetwork->port);
pNetwork->handle = fd;
return 0;
}
int fd = at_socket_connect(pNetwork->host, pNetwork->port, eNET_TCP);
if (fd < 0) {
Log_e("fail to connect with TCP server: %s:%u", pNetwork->host, pNetwork->port);
pNetwork->handle = AT_NO_CONNECTED_FD;
return -1;
} else {
Log_d("connected with TCP server: %s:%u", pNetwork->host, pNetwork->port);
pNetwork->handle = fd;
return 0;
}
}
int network_at_tcp_read(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *read_len)
{
int ret, err_code;
uint32_t len_recv;
Timer timer;
InitTimer(&timer);
countdown_ms(&timer, timeout_ms);
len_recv = 0;
err_code = 0;
do {
if (expired(&timer)) {
err_code = QCLOUD_ERR_TCP_READ_TIMEOUT;
break;
}
ret = at_socket_recv(pNetwork->handle, data + len_recv, datalen - len_recv);
if (ret > 0) {
len_recv += ret;
}
else if (ret == 0) {
err_code = QCLOUD_ERR_TCP_NOTHING_TO_READ;
}
else {//ret < 0
Log_e("recv fail\n");
err_code = QCLOUD_ERR_TCP_READ_FAIL;
break;
}
} while ((len_recv < datalen));
if (err_code == QCLOUD_ERR_TCP_READ_TIMEOUT && len_recv == 0) {
err_code = QCLOUD_ERR_TCP_NOTHING_TO_READ;
}
*read_len = len_recv;
return (datalen == len_recv) ? QCLOUD_RET_SUCCESS : err_code;
}
int network_at_tcp_write(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *written_len)
{
int ret;
uint32_t len_sent;
Timer timer;
int net_err = 0;
int ret, err_code;
uint32_t len_recv;
Timer timer;
InitTimer(&timer);
countdown_ms(&timer, timeout_ms);
len_sent = 0;
ret = 1; /* send one time if timeout_ms is value 0 */
len_recv = 0;
err_code = 0;
do {
ret = at_socket_send(pNetwork->handle, data + len_sent, datalen - len_sent);
do {
if (expired(&timer)) {
err_code = QCLOUD_ERR_TCP_READ_TIMEOUT;
break;
}
if (ret > 0) {
len_sent += ret;
}
else if (0 == ret) {
Log_e("No data be sent\n");
}
else {
Log_e("send fail, ret:%d\n", ret);
net_err = 1;
break;
}
} while (!net_err && (len_sent < datalen) && (!expired(&timer)));
ret = at_socket_recv(pNetwork->handle, data + len_recv, datalen - len_recv);
*written_len = (size_t)len_sent;
if (ret > 0) {
len_recv += ret;
} else if (ret == 0) {
err_code = QCLOUD_ERR_TCP_NOTHING_TO_READ;
} else { //ret < 0
Log_e("recv fail\n");
err_code = QCLOUD_ERR_TCP_READ_FAIL;
break;
}
return (len_sent > 0 && net_err == 0) ? QCLOUD_RET_SUCCESS : QCLOUD_ERR_TCP_WRITE_FAIL;
} while ((len_recv < datalen));
if (err_code == QCLOUD_ERR_TCP_READ_TIMEOUT && len_recv == 0) {
err_code = QCLOUD_ERR_TCP_NOTHING_TO_READ;
}
*read_len = len_recv;
return (datalen == len_recv) ? QCLOUD_RET_SUCCESS : err_code;
}
int network_at_tcp_write(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *written_len)
{
int ret;
uint32_t len_sent;
Timer timer;
int net_err = 0;
InitTimer(&timer);
countdown_ms(&timer, timeout_ms);
len_sent = 0;
ret = 1; /* send one time if timeout_ms is value 0 */
do {
ret = at_socket_send(pNetwork->handle, data + len_sent, datalen - len_sent);
if (ret > 0) {
len_sent += ret;
} else if (0 == ret) {
Log_e("No data be sent\n");
} else {
Log_e("send fail, ret:%d\n", ret);
net_err = 1;
break;
}
} while (!net_err && (len_sent < datalen) && (!expired(&timer)));
*written_len = (size_t)len_sent;
return (len_sent > 0 && net_err == 0) ? QCLOUD_RET_SUCCESS : QCLOUD_ERR_TCP_WRITE_FAIL;
}
void network_at_tcp_disconnect(Network *pNetwork)

30
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/network_interface.c vendored
View File

@@ -21,13 +21,15 @@ extern "C" {
#include "qcloud_iot_export_error.h"
#include "utils_param_check.h"
int is_network_connected(Network *pNetwork) {
return pNetwork->handle;
int is_network_connected(Network *pNetwork)
{
return pNetwork->handle;
}
#ifdef AT_TCP_ENABLED
int is_network_at_connected(Network *pNetwork) {
return pNetwork->handle== AT_NO_CONNECTED_FD ? 0: pNetwork->handle == AT_NO_CONNECTED_FD;
int is_network_at_connected(Network *pNetwork)
{
return pNetwork->handle == AT_NO_CONNECTED_FD ? 0 : pNetwork->handle == AT_NO_CONNECTED_FD;
}
#endif
@@ -36,20 +38,20 @@ int network_init(Network *pNetwork)
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
// to avoid process crash when writing to a broken socket
#if defined(__linux__)
#if defined(__linux__)
signal(SIGPIPE, SIG_IGN);
#endif
switch(pNetwork->type) {
switch (pNetwork->type) {
case NETWORK_TCP:
#ifdef AT_TCP_ENABLED
pNetwork->init = network_at_tcp_init;
pNetwork->connect = network_at_tcp_connect;
pNetwork->read = network_at_tcp_read;
pNetwork->write = network_at_tcp_write;
pNetwork->disconnect = network_at_tcp_disconnect;
pNetwork->is_connected = is_network_at_connected;
pNetwork->handle = AT_NO_CONNECTED_FD;
pNetwork->init = network_at_tcp_init;
pNetwork->connect = network_at_tcp_connect;
pNetwork->read = network_at_tcp_read;
pNetwork->write = network_at_tcp_write;
pNetwork->disconnect = network_at_tcp_disconnect;
pNetwork->is_connected = is_network_at_connected;
pNetwork->handle = AT_NO_CONNECTED_FD;
#else
pNetwork->init = network_tcp_init;
pNetwork->connect = network_tcp_connect;
@@ -98,7 +100,7 @@ int network_init(Network *pNetwork)
#endif
default:
Log_e("unknown network type: %d", pNetwork->type);
return QCLOUD_ERR_INVAL;
return QCLOUD_ERR_INVAL;
}
return pNetwork->init(pNetwork);
}

52
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/socket/network_socket.c vendored
View File

@@ -21,7 +21,7 @@
/*
* TCP/UDP socket API
*/
int network_tcp_init(Network *pNetwork)
{
return QCLOUD_RET_SUCCESS;
@@ -56,7 +56,7 @@ int network_tcp_write(Network *pNetwork, unsigned char *data, size_t datalen, ui
int rc = 0;
rc =HAL_TCP_Write(pNetwork->handle, data, datalen, timeout_ms, written_len);
rc = HAL_TCP_Write(pNetwork->handle, data, datalen, timeout_ms, written_len);
return rc;
}
@@ -83,49 +83,49 @@ int network_udp_init(Network *pNetwork)
int network_udp_read(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *read_len)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
int ret = HAL_UDP_ReadTimeout(pNetwork->handle, data, datalen, timeout_ms);
if (ret > 0) {
*read_len = ret;
ret = 0;
}
int ret = HAL_UDP_ReadTimeout(pNetwork->handle, data, datalen, timeout_ms);
if (ret > 0) {
*read_len = ret;
ret = 0;
}
return ret;
return ret;
}
int network_udp_write(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *written_len)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
int ret = HAL_UDP_Write(pNetwork->handle, data, datalen);
if (ret > 0) {
*written_len = ret;
ret = 0;
}
int ret = HAL_UDP_Write(pNetwork->handle, data, datalen);
if (ret > 0) {
*written_len = ret;
ret = 0;
}
return ret;
return ret;
}
void network_udp_disconnect(Network *pNetwork)
{
POINTER_SANITY_CHECK_RTN(pNetwork);
POINTER_SANITY_CHECK_RTN(pNetwork);
HAL_UDP_Disconnect(pNetwork->handle);
pNetwork->handle = 0;
HAL_UDP_Disconnect(pNetwork->handle);
pNetwork->handle = 0;
return ;
return ;
}
int network_udp_connect(Network *pNetwork)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
pNetwork->handle = HAL_UDP_Connect(pNetwork->host, pNetwork->port);
if (0 == pNetwork->handle) {
return -1;
}
return 0;
pNetwork->handle = HAL_UDP_Connect(pNetwork->host, pNetwork->port);
if (0 == pNetwork->handle) {
return -1;
}
return 0;
}
#endif

38
components/connectivity/qcloud-iot-explorer-sdk/3rdparty/sdk_src/network/tls/network_tls.c vendored
View File

@@ -21,7 +21,7 @@
/*
* TLS/DTLS network API
*/
#ifndef AUTH_WITH_NOTLS
#ifndef AUTH_WITH_NOTLS
int network_tls_init(Network *pNetwork)
{
@@ -31,14 +31,14 @@ int network_tls_init(Network *pNetwork)
int network_tls_connect(Network *pNetwork)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
int ret = QCLOUD_ERR_FAILURE;
pNetwork->handle = (uintptr_t)HAL_TLS_Connect(&(pNetwork->ssl_connect_params), pNetwork->host, pNetwork->port);
if (pNetwork->handle != 0) {
ret = QCLOUD_RET_SUCCESS;
}
return ret;
}
@@ -77,40 +77,40 @@ int network_dtls_init(Network *pNetwork)
int network_dtls_read(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *read_len)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
return HAL_DTLS_Read(pNetwork->handle, data, datalen, timeout_ms, read_len);
return HAL_DTLS_Read(pNetwork->handle, data, datalen, timeout_ms, read_len);
}
int network_dtls_write(Network *pNetwork, unsigned char *data, size_t datalen, uint32_t timeout_ms, size_t *written_len)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
return HAL_DTLS_Write(pNetwork->handle, data, datalen, written_len);
return HAL_DTLS_Write(pNetwork->handle, data, datalen, written_len);
}
void network_dtls_disconnect(Network *pNetwork)
{
POINTER_SANITY_CHECK_RTN(pNetwork);
POINTER_SANITY_CHECK_RTN(pNetwork);
HAL_DTLS_Disconnect(pNetwork->handle);
pNetwork->handle = 0;
HAL_DTLS_Disconnect(pNetwork->handle);
pNetwork->handle = 0;
return ;
return ;
}
int network_dtls_connect(Network *pNetwork)
{
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
POINTER_SANITY_CHECK(pNetwork, QCLOUD_ERR_INVAL);
int ret = QCLOUD_ERR_FAILURE;
int ret = QCLOUD_ERR_FAILURE;
pNetwork->handle = (uintptr_t)HAL_DTLS_Connect(&(pNetwork->ssl_connect_params), pNetwork->host, pNetwork->port);
if (pNetwork->handle != 0) {
ret = QCLOUD_RET_SUCCESS;
}
pNetwork->handle = (uintptr_t)HAL_DTLS_Connect(&(pNetwork->ssl_connect_params), pNetwork->host, pNetwork->port);
if (pNetwork->handle != 0) {
ret = QCLOUD_RET_SUCCESS;
}
return ret;
return ret;
}
#endif