lixian
/
doubao_chat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
doubao_chat/lib/net/uC-HTTPc/Client/Source/http-c_conn.c

816 lines
27 KiB
C
Raw Blame History

/*
*********************************************************************************************************
* uC/HTTP
* Hypertext Transfer Protocol
*
* Copyright 2004-2020 Silicon Laboratories Inc. www.silabs.com
*
* SPDX-License-Identifier: APACHE-2.0
*
* This software is subject to an open source license and is distributed by
* Silicon Laboratories Inc. pursuant to the terms of the Apache License,
* Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
*
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*
* HTTP CLIENT CONNECTIION MODULE
*
* Filename : http-c_conn.c
* Version : V3.01.00
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*********************************************************************************************************
* INCLUDE FILES
*********************************************************************************************************
*********************************************************************************************************
*/
#define MICRIUM_SOURCE
#define HTTPc_CONN_MODULE
#include <net_ascii.h>
#include <net_util.h>
#include <net.h>
#include <net_cfg_net.h>
#include <net_app.h>
#include <net_sock.h>
#include "http-c_conn.h"
#include "http-c_sock.h"
#include "http-c_req.h"
#include "http-c_resp.h"
#ifdef HTTPc_TASK_MODULE_EN
#include "http-c_task.h"
#endif
#ifdef HTTPc_WEBSOCK_MODULE_EN
#include "http-c_websock.h"
#endif
//to do : 添加
#undef HTTPc_SIGNAL_TASK_MODULE_EN
/*
*********************************************************************************************************
* HTTPcConn_Process()
*
* Description : Process a connection in its CONNECT state.
*
* Argument(s) : p_conn Pointer to current HTTPc Connection object.
*
* Return(s) : None.
*
* Caller(s) : HTTPcTask_Handler().
*
* Note(s) : None.
*********************************************************************************************************
*/
void HTTPcConn_Process(HTTPc_CONN *p_conn)
{
HTTPc_CONN_OBJ *p_conn_const;
CPU_BOOLEAN is_connect;
CPU_BOOLEAN result;
#ifdef HTTPc_TASK_MODULE_EN
CPU_BOOLEAN no_block;
#endif
HTTPc_ERR err;
p_conn_const = (HTTPc_CONN_OBJ *)p_conn;
switch (p_conn->State) {
case HTTPc_CONN_STATE_NONE:
break;
case HTTPc_CONN_STATE_CONNECT: /* CONNECT STATE */
is_connect = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_CONNECT);
if (is_connect == DEF_NO) {
HTTPcConn_Connect(p_conn, &err); /* Connection Connect. */
if (err != HTTPc_ERR_NONE) {
p_conn->ErrCode = err;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_NONE;
p_conn->State = HTTPc_CONN_STATE_NONE;
result = DEF_FAIL;
HTTPcConn_Remove(p_conn);
} else {
p_conn->State = HTTPc_CONN_STATE_PARAM_VALIDATE;
result = DEF_OK;
}
#ifdef HTTPc_TASK_MODULE_EN
/* No-Blocking mode: notify app with callback that ... */
/* ... connect is done. */
no_block = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_NO_BLOCK);
if ((no_block == DEF_YES) &&
(p_conn->OnConnect != DEF_NULL)) {
p_conn->OnConnect(p_conn_const, result);
}
#ifdef HTTPc_SIGNAL_TASK_MODULE_EN
/* Blocking mode: Signal app that connect is done. */
if (p_conn->ConnectSignal.SemObjPtr != DEF_NULL) {
HTTPcTask_ConnConnectSignal(p_conn, &err);
if (err != HTTPc_ERR_NONE) {
CPU_SW_EXCEPTION(;);
}
}
#endif
#endif
} else {
p_conn->State = HTTPc_CONN_STATE_PARAM_VALIDATE;
}
break;
default:
CPU_SW_EXCEPTION(;);
break;
}
(void)p_conn_const;
(void)result;
}
/*
*********************************************************************************************************
* HTTPcConn_Connect()
*
* Description : (1) Connect to an HTTP server.
* (a) Validate Server Socket Address.
* (b) Connect to Server.
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* HTTPc_ERR_NONE Connection to server successful.
* HTTPc_ERR_CONN_PARAM_PORT_INVALID Invalid HTTP Server port number.
* HTTPc_ERR_CONN_PARAM_ADDR_INVALID Invalid HTTP Server address.
* HTTPc_ERR_CONN_PARAM_ADDR_FAMILY_INVALID Invalid HTTP Server address family.
*
* ------------ RETURNED BY HTTPcSock_Connect() ------------
* See HTTPcSock_Connect() for additional return error codes.
*
*
* Return(s) : None.
*
* Caller(s) : HTTPcTask_Handler(),
* HTTPc_ConnConnect().
*
* Note(s) : None.
*********************************************************************************************************
*/
void HTTPcConn_Connect(HTTPc_CONN *p_conn,
HTTPc_ERR *p_err)
{
CPU_BOOLEAN is_connect;
#ifdef HTTPc_TASK_MODULE_EN
CPU_BOOLEAN no_block;
#endif
is_connect = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_CONNECT);
if (is_connect == DEF_YES) {
*p_err = HTTPc_ERR_CONN_IS_CONNECT;
goto exit;
}
/* ---------------- VALIDATE CALLBACKS ---------------- */
#ifdef HTTPc_TASK_MODULE_EN
no_block = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_NO_BLOCK);
if (no_block == DEF_YES) {
if (p_conn->OnConnect == DEF_NULL) {
*p_err = HTTPc_ERR_CONN_PARAM_CONNECT_CALLBACK_INVALID;
goto exit;
}
}
if (p_conn->OnClose == DEF_NULL) {
*p_err = HTTPc_ERR_CONN_PARAM_CLOSE_CALLBACK_INVALID;
goto exit;
}
#endif
/* -------------- CONNECT TO HTTP SERVER -------------- */
HTTPcSock_Connect(p_conn, p_err);
if (*p_err != HTTPc_ERR_NONE) {
goto exit;
}
DEF_BIT_SET(p_conn->Flags, HTTPc_FLAG_CONN_CONNECT);
*p_err = HTTPc_ERR_NONE;
exit:
return;
}
/*
*********************************************************************************************************
* HTTPcConn_Close()
*
* Description : (1) HTTPc Connection Close Handler:
* (a) Call hook function to advertise connection closing.
* (b) Close Socket
* (c) Release HTTPc Connection related objects.
* (d) Remove connection from list.
*
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* ------------ RETURNED BY HTTPcSock_Close() -------------
* See HTTPcSock_Close() for additional return error codes.
*
* Return(s) : None.
*
* Caller(s) : HTTPcConn_TransProcess(),
* HTTPc_ConnCloseHandler().
*
* Note(s) : None.
*********************************************************************************************************
*/
void HTTPcConn_Close(HTTPc_CONN *p_conn,
HTTPc_ERR *p_err)
{
HTTPc_CONN_OBJ *p_conn_const;
HTTPc_REQ *p_req;
HTTPc_REQ_OBJ *p_req_const;
p_conn_const = (HTTPc_CONN_OBJ *)p_conn;
/* ---------- CLEAR CONNECTION REQUESTS LIST ---------- */
p_req = p_conn->ReqListHeadPtr;
p_req_const = (HTTPc_REQ_OBJ *)p_req;
while (p_req != DEF_NULL) {
#ifdef HTTPc_TASK_MODULE_EN
if (p_req->OnTransComplete != DEF_NULL) {
p_req->OnTransComplete(p_conn_const, p_req_const, p_req->RespPtr, DEF_FAIL);
}
if (p_req->OnErr != DEF_NULL) {
p_req->OnErr(p_conn_const, p_req_const, HTTPc_ERR_CONN_SOCK_CLOSED);
}
#else
(void)p_conn_const;
(void)p_req_const;
#endif
HTTPcConn_ReqRemove(p_conn);
p_req = p_conn->ReqListHeadPtr;
}
DEF_BIT_CLR(p_conn->Flags, HTTPc_FLAG_CONN_CONNECT);
DEF_BIT_CLR(p_conn->Flags, HTTPc_FLAG_CONN_IN_USE);
/* ------------- CLOSE CONNECTION SOCKET -------------- */
HTTPcSock_Close(p_conn, p_err);
if (*p_err != HTTPc_ERR_NONE) {
*p_err = HTTPc_ERR_CONN_SOCK_CLOSE_FATAL;
goto exit;
}
*p_err = HTTPc_ERR_NONE;
exit:
return;
}
/*
*********************************************************************************************************
* HTTPcConn_TransProcess()
*
* Description : Process the connection's transaction state (i.e. request or response state).
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* Return(s) : none.
*
* Caller(s) : HTTPcTask_Handler().
*
* Note(s) : none.
*********************************************************************************************************
*/
void HTTPcConn_TransProcess(HTTPc_CONN *p_conn)
{
HTTPc_CONN_OBJ *p_conn_const;
HTTPc_REQ *p_req;
HTTPc_REQ_OBJ *p_req_const;
CPU_BOOLEAN result;
#ifdef HTTPc_TASK_MODULE_EN
CPU_BOOLEAN no_block;
#endif
CPU_BOOLEAN success;
CPU_BOOLEAN to_close;
HTTPc_ERR err;
#ifdef HTTPc_WEBSOCK_MODULE_EN
CPU_BOOLEAN is_websocket;
#endif
p_conn_const = (HTTPc_CONN_OBJ *)p_conn;
p_req = p_conn->ReqListHeadPtr;
p_req_const = (HTTPc_REQ_OBJ *)p_req;
/* ------------- CONNECTION STATE MACHINE ------------- */
switch (p_conn->State) {
case HTTPc_CONN_STATE_PARAM_VALIDATE: /* REQUEST PREPARATION & VALIDATTION STATE */
result = HTTPcSock_IsRxClosed(p_conn, &err); /* Check if connection half-closed by server. */
if (result == DEF_YES) {
p_conn->ErrCode = HTTPc_ERR_NONE;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_SERVER;
p_conn->State = HTTPc_CONN_STATE_COMPLETED;
} else {
if (p_req != DEF_NULL) {
HTTPcConn_TransParamReset(p_conn); /* Clear Connection internal parameters. */
HTTPcReq_Prepare(p_conn, &err);
if (err != HTTPc_ERR_NONE) {
p_conn->ErrCode = err;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_NONE;
p_conn->State = HTTPc_CONN_STATE_ERR;
} else {
p_conn->State = HTTPc_CONN_STATE_REQ_LINE_METHOD;
}
}
}
break;
case HTTPc_CONN_STATE_REQ_LINE_METHOD:
case HTTPc_CONN_STATE_REQ_LINE_URI:
case HTTPc_CONN_STATE_REQ_LINE_QUERY_STR:
case HTTPc_CONN_STATE_REQ_LINE_PROTO_VER:
case HTTPc_CONN_STATE_REQ_HDR_HOST:
case HTTPc_CONN_STATE_REQ_HDR_CONTENT_TYPE:
case HTTPc_CONN_STATE_REQ_HDR_CONTENT_LEN:
case HTTPc_CONN_STATE_REQ_HDR_TRANSFER_ENCODE:
case HTTPc_CONN_STATE_REQ_HDR_CONN:
case HTTPc_CONN_STATE_REQ_HDR_EXT:
case HTTPc_CONN_STATE_REQ_HDR_LAST:
case HTTPc_CONN_STATE_REQ_BODY:
case HTTPc_CONN_STATE_REQ_BODY_DATA:
case HTTPc_CONN_STATE_REQ_BODY_DATA_CHUNK_SIZE:
case HTTPc_CONN_STATE_REQ_BODY_DATA_CHUNK_DATA:
case HTTPc_CONN_STATE_REQ_BODY_DATA_CHUNK_END:
case HTTPc_CONN_STATE_REQ_BODY_FORM_APP:
case HTTPc_CONN_STATE_REQ_BODY_FORM_MULTIPART_BOUNDARY:
case HTTPc_CONN_STATE_REQ_BODY_FORM_MULTIPART_HDR_CONTENT_DISPO:
case HTTPc_CONN_STATE_REQ_BODY_FORM_MULTIPART_HDR_CONTENT_TYPE:
case HTTPc_CONN_STATE_REQ_BODY_FORM_MULTIPART_DATA:
case HTTPc_CONN_STATE_REQ_BODY_FORM_MULTIPART_DATA_END:
case HTTPc_CONN_STATE_REQ_BODY_FORM_MULTIPART_BOUNDARY_END:
case HTTPc_CONN_STATE_REQ_END: /* REQUEST PROCESSING STATES */
(void)HTTPcReq(p_conn, &err);
switch (err) {
case HTTPc_ERR_NONE:
case HTTPc_ERR_CONN_SOCK_TX:
case HTTPc_ERR_TRANS_TX_BUF_FULL:
break;
case HTTPc_ERR_CONN_SOCK_CLOSED:
p_conn->ErrCode = err;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_SERVER;
p_conn->State = HTTPc_CONN_STATE_ERR;
break;
default:
p_conn->ErrCode = err;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_ERR_INTERNAL;
p_conn->State = HTTPc_CONN_STATE_ERR;
break;
}
break;
case HTTPc_CONN_STATE_RESP_INIT:
case HTTPc_CONN_STATE_RESP_STATUS_LINE:
case HTTPc_CONN_STATE_RESP_HDR:
case HTTPc_CONN_STATE_RESP_BODY:
case HTTPc_CONN_STATE_RESP_BODY_CHUNK_SIZE:
case HTTPc_CONN_STATE_RESP_BODY_CHUNK_DATA:
case HTTPc_CONN_STATE_RESP_BODY_CHUNK_CRLF:
case HTTPc_CONN_STATE_RESP_BODY_CHUNK_LAST:
case HTTPc_CONN_STATE_RESP_COMPLETED: /* RESPONSE PROCESSING STATES */
success = HTTPcResp(p_conn, &err);
switch (err) {
case HTTPc_ERR_NONE:
case HTTPc_ERR_CONN_SOCK_RX:
case HTTPc_ERR_TRANS_RX_MORE_DATA_REQUIRED:
break;
case HTTPc_ERR_CONN_SOCK_CLOSED:
p_conn->ErrCode = err;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_SERVER;
p_conn->State = HTTPc_CONN_STATE_ERR;
break;
default:
p_conn->ErrCode = err;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_ERR_INTERNAL;
p_conn->State = HTTPc_CONN_STATE_ERR;
break;
}
if (success == DEF_YES) {
DEF_BIT_SET(p_conn->RespFlags, HTTPc_FLAG_RESP_COMPLETE_OK);
} else {
DEF_BIT_CLR(p_conn->RespFlags, HTTPc_FLAG_RESP_COMPLETE_OK);
}
break;
case HTTPc_CONN_STATE_ERR: /* ERROR STATE */
#ifdef HTTPc_TASK_MODULE_EN
/* Call callback function for Transaction Error. */
if (p_req != DEF_NULL) {
if (p_req->OnErr != DEF_NULL) {
p_req->OnErr(p_conn_const, p_req_const, p_conn->ErrCode);
}
} else {
CPU_SW_EXCEPTION(;);
}
#endif
p_conn->State = HTTPc_CONN_STATE_COMPLETED;
break;
case HTTPc_CONN_STATE_COMPLETED: /* TRANSACTION COMPLETE STATE */
if (p_req != DEF_NULL) {
success = DEF_BIT_IS_SET(p_conn->RespFlags, HTTPc_FLAG_RESP_COMPLETE_OK);
#ifdef HTTPc_WEBSOCK_MODULE_EN
/* Check if it is a upgrade websocket request. */
result = DEF_BIT_IS_SET(p_req->Flags, HTTPc_FLAG_REQ_UPGRADE_WEBSOCKET);
if ((result == DEF_YES) && (success == DEF_YES)) {
if ((p_req->WebSockPtr->Flags & HTTPc_FLAG_WEBSOCK_ALL) == HTTPc_FLAG_WEBSOCK_ALL) {
if (p_req->RespPtr->StatusCode == HTTP_STATUS_SWITCHING_PROTOCOLS) {
/* The connection is upgrading to websocket. */
DEF_BIT_SET(p_conn->Flags, HTTPc_FLAG_CONN_WEBSOCKET);
p_conn->WebSockPtr = p_req->WebSockPtr->WebSockObjPtr;
}
}
}
if (p_req->WebSockPtr != DEF_NULL) {
HTTPc_Mem_WebSockReqRelease(p_req->WebSockPtr);
}
#endif
HTTPcConn_ReqRemove(p_conn); /* Remove request from list. */
#ifdef HTTPc_TASK_MODULE_EN
/* No-Blocking mode: notify app with callback that ... */
/* ... transaction is done. */
no_block = DEF_BIT_IS_SET(p_req->Flags, HTTPc_FLAG_REQ_NO_BLOCK);
if ((no_block == DEF_YES) &&
(p_req->OnTransComplete != DEF_NULL)) {
p_req->OnTransComplete(p_conn_const, p_req_const, p_req->RespPtr, success);
}
#endif
}
to_close = HTTPcConn_TransComplete(p_conn);
if (to_close == DEF_YES) {
p_conn->State = HTTPc_CONN_STATE_CLOSE;
} else {
#ifdef HTTPc_SIGNAL_TASK_MODULE_EN
/* Blocking mode: Signal app that transaction is done. */
if (p_conn->TransDoneSignal.SemObjPtr != DEF_NULL) {
HTTPcTask_TransDoneSignal(p_conn, &err);
if (err != HTTPc_ERR_NONE) {
CPU_SW_EXCEPTION(;);
}
}
#endif
#ifdef HTTPc_WEBSOCK_MODULE_EN
is_websocket = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_WEBSOCKET);
if (is_websocket == DEF_YES) {
p_conn->State = HTTPc_CONN_STATE_WEBSOCK_INIT;
} else {
p_conn->State = HTTPc_CONN_STATE_PARAM_VALIDATE;
}
#else
p_conn->State = HTTPc_CONN_STATE_PARAM_VALIDATE;
#endif
}
break;
case HTTPc_CONN_STATE_CLOSE: /* CONNECTION CLOSE STATE */
HTTPcConn_Close(p_conn, &err); /* Close Connection. */
HTTPcConn_Remove(p_conn); /* Release Connection. */
#ifdef HTTPc_TASK_MODULE_EN
/* Call callback function for Conn Close. */
if (p_conn->OnClose != DEF_NULL) {
p_conn->OnClose(p_conn_const, p_conn->CloseStatus, p_conn->ErrCode);
}
#ifdef HTTPc_SIGNAL_TASK_MODULE_EN
/* Blocking mode: Signal app that transaction is done. */
if (p_conn->TransDoneSignal.SemObjPtr != DEF_NULL) {
HTTPcTask_TransDoneSignal(p_conn, &err);
if (err != HTTPc_ERR_NONE) {
CPU_SW_EXCEPTION(;);
}
}
/* Blocking mode: Signal App that Conn was closed. */
if (p_conn->CloseSignal.SemObjPtr != DEF_NULL) {
HTTPcTask_ConnCloseSignal(p_conn, &err);
if (err != HTTPc_ERR_NONE) {
CPU_SW_EXCEPTION(;);
}
}
#endif
#endif
p_conn->State = HTTPc_CONN_STATE_NONE;
break;
default:
CPU_SW_EXCEPTION(;);
break;
}
(void)p_conn_const;
(void)p_req_const;
}
/*
*********************************************************************************************************
* HTTPcConn_TransParamReset()
*
* Description : Clear HTTP Connection object members related to internal usage during an HTTP transaction.
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* Return(s) : None.
*
* Caller(s) : HTTPc_ReqSend(),
* HTTPcTask_Handle().
*
* Note(s) : None.
*********************************************************************************************************
*/
void HTTPcConn_TransParamReset(HTTPc_CONN *p_conn)
{
/* ------------ INIT CONNECTION PARAMETERS ------------ */
p_conn->SockFlags = DEF_BIT_NONE;
p_conn->ErrCode = HTTPc_ERR_NONE;
p_conn->CloseStatus = HTTPc_CONN_CLOSE_STATUS_NONE;
DEF_BIT_CLR(p_conn->Flags, HTTPc_FLAG_CONN_TO_CLOSE);
/* ------------- INIT REQUEST PARAMETERS -------------- */
p_conn->ReqFlags = 0u;
#if (HTTPc_CFG_QUERY_STR_EN == DEF_ENABLED)
p_conn->ReqQueryStrTxIx = 0u;
p_conn->ReqQueryStrTempPtr = DEF_NULL;
#endif
#if (HTTPc_CFG_HDR_TX_EN == DEF_ENABLED)
p_conn->ReqHdrTxIx = 0u;
p_conn->ReqHdrTempPtr = DEF_NULL;
#endif
#if (HTTPc_CFG_FORM_EN == DEF_ENABLED)
p_conn->ReqFormDataTxIx = 0u;
#endif
p_conn->ReqDataOffset = 0u;
/* ------------- INIT RESPONSE PARAMETERS ------------- */
DEF_BIT_CLR(p_conn->RespFlags, HTTPc_FLAG_RESP_RX_MORE_DATA);
DEF_BIT_CLR(p_conn->RespFlags, HTTPc_FLAG_RESP_BODY_CHUNK_TRANSFER);
/* --------- INIT CONNECTION BUFFER PARAMETERS -------- */
p_conn->RxBufPtr = p_conn->BufPtr;
p_conn->RxDataLenRem = 0u;
p_conn->RxDataLen = 0u;
p_conn->TxBufPtr = p_conn->BufPtr;
p_conn->TxDataLen = 0u;
p_conn->TxDataPtr = DEF_NULL;
}
/*
*********************************************************************************************************
* HTTPcConn_TransComplete()
*
* Description : HTTP Transaction complete checks if a connection must be closed.
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* Return(s) : DEF_YES, if connection must be closed.
* DEF_NO, otherwise.
*
* Caller(s) : HTTPcTask_Handle(),
* HTTPc_ReqSend().
*
* Note(s) : None.
*********************************************************************************************************
*/
CPU_BOOLEAN HTTPcConn_TransComplete(HTTPc_CONN *p_conn)
{
CPU_BOOLEAN close_hdr;
CPU_BOOLEAN is_connect;
CPU_BOOLEAN to_close;
#ifdef HTTPc_WEBSOCK_MODULE_EN
CPU_BOOLEAN is_websocket;
#endif
to_close = DEF_NO;
close_hdr = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_TO_CLOSE);
is_connect = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_CONNECT);
if ((close_hdr == DEF_YES) &&
(is_connect == DEF_YES)) {
to_close = DEF_YES;
}
#ifdef HTTPc_WEBSOCK_MODULE_EN
is_websocket = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_WEBSOCKET);
if (is_websocket == DEF_YES) {
to_close = DEF_NO;
}
#endif
if (p_conn->CloseStatus != HTTPc_CONN_CLOSE_STATUS_NONE) {
to_close = DEF_YES;
}
return (to_close);
}
/*
*********************************************************************************************************
* HTTPcConn_Add()
*
* Description : (1) Add current HTTPc Connection to connection list if the task is enabled.
* (2) Tag Connection as being used.
*
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* Return(s) : None.
*
* Caller(s) : HTTPcTask(),
* HTTPc_ConnOpen().
*
* Note(s) : None.
*********************************************************************************************************
*/
void HTTPcConn_Add(HTTPc_CONN *p_conn)
{
DEF_BIT_SET(p_conn->Flags, HTTPc_FLAG_CONN_IN_USE);
#ifdef HTTPc_TASK_MODULE_EN
HTTPcTask_ConnAdd(p_conn);
#endif
p_conn->State = HTTPc_CONN_STATE_CONNECT;
}
/*
*********************************************************************************************************
* HTTPcConn_Remove()
*
* Description : (1) Remove current HTTPc Connection from connection list if the task is enabled.
* (2) Release Connection.
*
*
* Argument(s) : p_conn Pointer to current HTTPc Connection.
*
* Return(s) : None.
*
* Caller(s) : HTTPcConn_Process(),
* HTTPcConn_TransProcess().
*
* Note(s) : none.
*********************************************************************************************************
*/
void HTTPcConn_Remove(HTTPc_CONN *p_conn)
{
#ifdef HTTPc_TASK_MODULE_EN
HTTPcTask_ConnRemove(p_conn);
#endif
DEF_BIT_CLR(p_conn->Flags, HTTPc_FLAG_CONN_IN_USE);
}
/*
*********************************************************************************************************
* HTTPcConn_ReqAdd()
*
* Description : Add new Request to the Connection Request list.
*
* Argument(s) : p_req Pointer to the HTTPc Request.
*
* p_err Pointer to variable that will receive the return error code from this function :
*
* HTTPc_ERR_NONE Request added successfully.
* HTTPc_ERR_CONN_IS_RELEASED Connection is not used.
*
* Return(s) : None.
*
* Caller(s) : HTTPcTask(),
* HTTPc_ReqSend().
*
* Note(s) : (1) New Request is added at the end of the list.
*********************************************************************************************************
*/
void HTTPcConn_ReqAdd(HTTPc_REQ *p_req,
HTTPc_ERR *p_err)
{
HTTPc_CONN *p_conn;
HTTPc_REQ *p_req_item;
CPU_BOOLEAN in_use;
p_conn = p_req->ConnPtr;
in_use = DEF_BIT_IS_SET(p_conn->Flags, HTTPc_FLAG_CONN_IN_USE);
if (in_use == DEF_YES) {
DEF_BIT_SET(p_req->Flags, HTTPc_FLAG_REQ_IN_USE);
if (p_conn->ReqListHeadPtr == DEF_NULL) {
p_conn->ReqListHeadPtr = p_req;
p_conn->ReqListEndPtr = p_req;
p_req->NextPtr = 0;
} else {
p_req_item = p_conn->ReqListEndPtr;
p_req_item->NextPtr = p_req;
p_conn->ReqListEndPtr = p_req;
p_req->NextPtr = 0;
}
*p_err = HTTPc_ERR_NONE;
} else {
*p_err = HTTPc_ERR_CONN_IS_RELEASED;
}
}
/*
*********************************************************************************************************
* HTTPcConn_ReqRemove()
*
* Description : Remove the first Request from the Connection Request list.
*
* Argument(s) : p_conn Pointer to the HTTPc Connection.
*
* Return(s) : None.
*
* Caller(s) : HTTPcConn_Close(),
* HTTPcConn_TransComplete().
*
* Note(s) : (1) The Head of the Request list is removed.
*********************************************************************************************************
*/
void HTTPcConn_ReqRemove(HTTPc_CONN *p_conn)
{
HTTPc_REQ *p_req_item;
CPU_SR_ALLOC();
p_req_item = p_conn->ReqListHeadPtr;
if (p_req_item == DEF_NULL) {
p_conn->ReqListEndPtr = DEF_NULL;
} else if (p_req_item->NextPtr == DEF_NULL) {
p_conn->ReqListHeadPtr = DEF_NULL;
p_conn->ReqListEndPtr = DEF_NULL;
p_req_item->NextPtr = 0;
} else {
p_conn->ReqListHeadPtr = p_req_item->NextPtr;
p_req_item->NextPtr = 0;
}
if (p_req_item != DEF_NULL) {
CPU_CRITICAL_ENTER();
DEF_BIT_CLR(p_req_item->Flags, HTTPc_FLAG_REQ_IN_USE);
CPU_CRITICAL_EXIT();
}
}
Reference in New Issue View Git Blame Copy Permalink