Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-01-15 17:02:53 +08:00
Code Issues Packages Projects Releases Wiki Activity
pikapython/port/linux/package/pikascript/pikascript-lib/requests/webclient.c

1732 lines
49 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2022, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2013-05-05 Bernard the first version
* 2013-06-10 Bernard fix the slow speed issue when download file.
* 2015-11-14 aozima add content_length_remainder.
* 2017-12-23 aozima update gethostbyname to getaddrinfo.
* 2018-01-04 aozima add ipv6 address support.
* 2018-07-26 chenyong modify log information
* 2018-08-07 chenyong modify header processing
* 2021-06-09 xiangxistu add shard download function
*/
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "webclient.h"
#include <sys/errno.h>
#define DBG_ENABLE
#define DBG_SECTION_NAME "web"
#ifdef WEBCLIENT_DEBUG
#define DBG_LEVEL DBG_LOG
#else
#define DBG_LEVEL DBG_INFO
#endif /* WEBCLIENT_DEBUG */
#define DBG_COLOR
// #include <rtdbg.h>
/* default receive or send timeout */
#define WEBCLIENT_DEFAULT_TIMEO 6
extern long int strtol(const char* nptr, char** endptr, int base);
static int webclient_strncasecmp(const char* a, const char* b, size_t n) {
uint8_t c1, c2;
if (n <= 0)
return 0;
do {
c1 = tolower(*a++);
c2 = tolower(*b++);
} while (--n && c1 && c1 == c2);
return c1 - c2;
}
static const char* webclient_strstri(const char* str, const char* subStr) {
int len = strlen(subStr);
if (len == 0) {
return RT_NULL;
}
while (*str) {
if (webclient_strncasecmp(str, subStr, len) == 0) {
return str;
}
++str;
}
return RT_NULL;
}
static int webclient_send(struct webclient_session* session,
const void* buffer,
size_t len,
int flag) {
#ifdef WEBCLIENT_USING_MBED_TLS
if (session->tls_session) {
return mbedtls_client_write(session->tls_session, buffer, len);
}
#endif
return __platform_send(session->socket, buffer, len, flag);
}
static int webclient_recv(struct webclient_session* session,
void* buffer,
size_t len,
int flag) {
#ifdef WEBCLIENT_USING_MBED_TLS
if (session->tls_session) {
return mbedtls_client_read(session->tls_session, buffer, len);
}
#endif
return __platform_recv(session->socket, buffer, len, flag);
}
static int webclient_read_line(struct webclient_session* session,
char* buffer,
int size) {
int rc, count = 0;
char ch = 0, last_ch = 0;
RT_ASSERT(session);
RT_ASSERT(buffer);
/* Keep reading until we fill the buffer. */
while (count < size) {
rc = webclient_recv(session, (unsigned char*)&ch, 1, 0);
#if defined(WEBCLIENT_USING_MBED_TLS) || defined(WEBCLIENT_USING_SAL_TLS)
if (session->is_tls && (rc == MBEDTLS_ERR_SSL_WANT_READ ||
rc == MBEDTLS_ERR_SSL_WANT_WRITE)) {
continue;
}
#endif
if (rc <= 0)
return rc;
if (ch == '\n' && last_ch == '\r')
break;
buffer[count++] = ch;
last_ch = ch;
}
if (count > size) {
LOG_E(
"read line failed. The line data length is out of buffer size(%d)!",
count);
return -WEBCLIENT_ERROR;
}
return count;
}
/**
* resolve server address
*
* @param session http session
* @param res the server address information
* @param url the input server URI address
* @param request the pointer to point the request url, for example, /index.html
*
* @return 0 on resolve server address OK, others failed
*
* URL example:
* http://www.rt-thread.org
* http://www.rt-thread.org:80
* https://www.rt-thread.org/
* http://192.168.1.1:80/index.htm
* http://[fe80::1]
* http://[fe80::1]/
* http://[fe80::1]/index.html
* http://[fe80::1]:80/index.html
*/
static int webclient_resolve_address(struct webclient_session* session,
struct addrinfo** res,
const char* url,
const char** request) {
int rc = WEBCLIENT_OK;
char* ptr;
char port_str[6] = "80"; /* default port of 80(http) */
const char* port_ptr;
const char* path_ptr;
const char* host_addr = 0;
int url_len, host_addr_len = 0;
RT_ASSERT(res);
RT_ASSERT(request);
/* make sure *res = NULL before getaddrinfo */
*res = RT_NULL;
url_len = strlen(url);
/* strip protocol(http or https) */
if (strncmp(url, "http://", 7) == 0) {
host_addr = url + 7;
} else if (strncmp(url, "https://", 8) == 0) {
strncpy(port_str, "443", 4);
host_addr = url + 8;
} else {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
/* ipv6 address */
if (host_addr[0] == '[') {
host_addr += 1;
ptr = strstr(host_addr, "]");
if (!ptr) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
host_addr_len = ptr - host_addr;
}
path_ptr = strstr(host_addr, "/");
*request = path_ptr ? path_ptr : "/";
/* resolve port */
port_ptr = strstr(host_addr + host_addr_len, ":");
if (port_ptr && (!path_ptr || (port_ptr < path_ptr))) {
if (!path_ptr) {
strcpy(port_str, port_ptr + 1);
} else {
int port_len = path_ptr - port_ptr - 1;
strncpy(port_str, port_ptr + 1, port_len);
port_str[port_len] = '\0';
}
} else {
port_ptr = RT_NULL;
}
if (port_ptr && (!path_ptr)) {
strcpy(port_str, port_ptr + 1);
}
/* ipv4 or domain. */
if (!host_addr_len) {
if (port_ptr) {
host_addr_len = port_ptr - host_addr;
} else if (path_ptr) {
host_addr_len = path_ptr - host_addr;
} else {
host_addr_len = strlen(host_addr);
}
}
if ((host_addr_len < 1) || (host_addr_len > url_len)) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
/* get host address ok. */
{
char* host_addr_new = web_malloc(host_addr_len + 1);
if (!host_addr_new) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
rt_memcpy(host_addr_new, host_addr, host_addr_len);
host_addr_new[host_addr_len] = '\0';
session->host = host_addr_new;
}
LOG_D("host address: %s , port: %s", session->host, port_str);
#ifdef WEBCLIENT_USING_MBED_TLS
if (session->tls_session) {
session->tls_session->port = web_strdup(port_str);
session->tls_session->host = web_strdup(session->host);
if (session->tls_session->port == RT_NULL ||
session->tls_session->host == RT_NULL) {
return -WEBCLIENT_NOMEM;
}
return rc;
}
#endif
/* resolve the host name. */
{
struct addrinfo hint;
int ret;
web_memset(&hint, 0, sizeof(hint));
ret = __platform_getaddrinfo(session->host, port_str, &hint, res);
if (ret != 0) {
LOG_E("getaddrinfo err: %d '%s'.", ret, session->host);
rc = -WEBCLIENT_ERROR;
goto __exit;
}
}
__exit:
if (rc != WEBCLIENT_OK) {
if (session->host) {
web_free(session->host);
session->host = RT_NULL;
}
if (*res) {
__platform_freeaddrinfo(*res);
*res = RT_NULL;
}
}
return rc;
}
#ifdef WEBCLIENT_USING_MBED_TLS
/**
* create and initialize https session.
*
* @param session webclient session
* @param URI input server URI address
*
* @return <0: create failed, no memory or other errors
* =0: success
*/
static int webclient_open_tls(struct webclient_session* session,
const char* URI) {
int tls_ret = 0;
const char* pers = "webclient";
RT_ASSERT(session);
session->tls_session =
(MbedTLSSession*)web_calloc(1, sizeof(MbedTLSSession));
if (session->tls_session == RT_NULL) {
return -WEBCLIENT_NOMEM;
}
session->tls_session->buffer_len = WEBCLIENT_RESPONSE_BUFSZ;
session->tls_session->buffer = web_malloc(session->tls_session->buffer_len);
if (session->tls_session->buffer == RT_NULL) {
LOG_E("no memory for tls_session buffer!");
return -WEBCLIENT_ERROR;
}
if ((tls_ret = mbedtls_client_init(session->tls_session, (void*)pers,
strlen(pers))) < 0) {
LOG_E("initialize https client failed return: -0x%x.", -tls_ret);
return -WEBCLIENT_ERROR;
}
return WEBCLIENT_OK;
}
#endif
/**
* connect to http server.
*
* @param session webclient session
* @param URI the input server URI address
*
* @return <0: connect failed or other error
* =0: connect success
*/
static int webclient_connect(struct webclient_session* session,
const char* URI) {
int rc = WEBCLIENT_OK;
int socket_handle;
struct timeval timeout;
struct addrinfo* res = RT_NULL;
const char* req_url;
RT_ASSERT(session);
RT_ASSERT(URI);
timeout.tv_sec = WEBCLIENT_DEFAULT_TIMEO;
timeout.tv_usec = 0;
if (strncmp(URI, "https://", 8) == 0) {
#if defined(WEBCLIENT_USING_SAL_TLS)
session->is_tls = RT_TRUE;
#elif defined(WEBCLIENT_USING_MBED_TLS)
if (webclient_open_tls(session, URI) < 0) {
LOG_E("connect failed, https client open URI(%s) failed!", URI);
return -WEBCLIENT_ERROR;
}
session->is_tls = RT_TRUE;
#else
LOG_E(
"not support https connect, please enable webclient https "
"configure!");
rc = -WEBCLIENT_ERROR;
goto __exit;
#endif
}
/* Check valid IP address and URL */
rc = webclient_resolve_address(session, &res, URI, &req_url);
if (rc != WEBCLIENT_OK) {
LOG_E("connect failed, resolve address error(%d).", rc);
goto __exit;
}
/* Not use 'getaddrinfo()' for https connection */
if (session->is_tls == RT_FALSE && res == RT_NULL) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
/* copy host address */
if (req_url) {
session->req_url = web_strdup(req_url);
} else {
LOG_E("connect failed, resolve request address error.");
rc = -WEBCLIENT_ERROR;
goto __exit;
}
#ifdef WEBCLIENT_USING_MBED_TLS
if (session->tls_session) {
int tls_ret = 0;
if ((tls_ret = mbedtls_client_context(session->tls_session)) < 0) {
LOG_E("connect failed, https client context return: -0x%x",
-tls_ret);
return -WEBCLIENT_ERROR;
}
if ((tls_ret = mbedtls_client_connect(session->tls_session)) < 0) {
LOG_E("connect failed, https client connect return: -0x%x",
-tls_ret);
return -WEBCLIENT_CONNECT_FAILED;
}
socket_handle = session->tls_session->server_fd.fd;
/* set recv timeout option */
__platform_setsockopt(socket_handle, SOL_SOCKET, SO_RCVTIMEO,
(void*)&timeout, sizeof(timeout));
__platform_setsockopt(socket_handle, SOL_SOCKET, SO_SNDTIMEO,
(void*)&timeout, sizeof(timeout));
session->socket = socket_handle;
return WEBCLIENT_OK;
}
#endif
{
#ifdef WEBCLIENT_USING_SAL_TLS
if (session->is_tls) {
socket_handle =
__platform_socket(res->ai_family, SOCK_STREAM, PROTOCOL_TLS);
} else {
socket_handle =
__platform_socket(res->ai_family, SOCK_STREAM, IPPROTO_TCP);
}
#else
socket_handle =
__platform_socket(res->ai_family, SOCK_STREAM, IPPROTO_TCP);
#endif
if (socket_handle < 0) {
LOG_E("connect failed, create __platform_socket(%d) error.",
socket_handle);
rc = -WEBCLIENT_NOSOCKET;
goto __exit;
}
/* set receive and send timeout option */
__platform_setsockopt(socket_handle, SOL_SOCKET, SO_RCVTIMEO,
(void*)&timeout, sizeof(timeout));
__platform_setsockopt(socket_handle, SOL_SOCKET, SO_SNDTIMEO,
(void*)&timeout, sizeof(timeout));
if (__platform_connect(socket_handle, res->ai_addr, res->ai_addrlen) !=
0) {
/* connect failed, close socket */
LOG_E("connect failed, connect __platform_socket(%d) error.",
socket_handle);
__platform_close(socket_handle);
rc = -WEBCLIENT_CONNECT_FAILED;
goto __exit;
}
session->socket = socket_handle;
}
__exit:
if (res) {
__platform_freeaddrinfo(res);
}
return rc;
}
/**
* add fields data to request header data.
*
* @param session webclient session
* @param fmt fields format
*
* @return >0: data length of successfully added
* <0: not enough header buffer size
*/
int webclient_header_fields_add(struct webclient_session* session,
const char* fmt,
...) {
rt_int32_t length;
va_list args;
RT_ASSERT(session);
RT_ASSERT(session->header->buffer);
va_start(args, fmt);
length = web_vsnprintf(session->header->buffer + session->header->length,
session->header->size - session->header->length, fmt,
args);
va_end(args);
if (length < 0) {
LOG_E("add fields header data failed, return length(%d) error.",
length);
return -WEBCLIENT_ERROR;
}
session->header->length += length;
/* check header size */
if (session->header->length >= session->header->size) {
LOG_E("not enough header buffer size(%d)!", session->header->size);
return -WEBCLIENT_ERROR;
}
return length;
}
/**
* get fields information from request/response header data.
*
* @param session webclient session
* @param fields fields keyword
*
* @return = NULL: get fields data failed
* != NULL: success get fields data
*/
const char* webclient_header_fields_get(struct webclient_session* session,
const char* fields) {
char* resp_buf = RT_NULL;
size_t resp_buf_len = 0;
RT_ASSERT(session);
RT_ASSERT(session->header->buffer);
resp_buf = session->header->buffer;
while (resp_buf_len < session->header->length) {
if (webclient_strstri(resp_buf, fields) == resp_buf) {
char* mime_ptr = RT_NULL;
/* jump space */
mime_ptr = strstr(resp_buf, ":");
if (mime_ptr != NULL) {
mime_ptr += 1;
while (*mime_ptr && (*mime_ptr == ' ' || *mime_ptr == '\t'))
mime_ptr++;
return mime_ptr;
}
}
if (*resp_buf == '\0')
break;
resp_buf += strlen(resp_buf) + 1;
resp_buf_len += strlen(resp_buf) + 1;
}
return RT_NULL;
}
/**
* get http response status code.
*
* @param session webclient session
*
* @return response status code
*/
int webclient_resp_status_get(struct webclient_session* session) {
RT_ASSERT(session);
return session->resp_status;
}
/**
* get http response data content length.
*
* @param session webclient session
*
* @return response content length
*/
int webclient_content_length_get(struct webclient_session* session) {
RT_ASSERT(session);
return session->content_length;
}
static int webclient_send_header(struct webclient_session* session,
int method) {
int rc = WEBCLIENT_OK;
char* header = RT_NULL;
RT_ASSERT(session);
header = session->header->buffer;
if (session->header->length == 0 && method <= WEBCLIENT_GET) {
/* use default header data */
if (webclient_header_fields_add(session, "GET %s HTTP/1.1\r\n",
session->req_url) < 0)
return -WEBCLIENT_NOMEM;
if (webclient_header_fields_add(session, "Host: %s\r\n",
session->host) < 0)
return -WEBCLIENT_NOMEM;
if (webclient_header_fields_add(
session, "User-Agent: RT-Thread HTTP Agent\r\n\r\n") < 0)
return -WEBCLIENT_NOMEM;
webclient_write(session, (unsigned char*)session->header->buffer,
session->header->length);
} else {
if (method != WEBCLIENT_USER_METHOD) {
/* check and add fields header data */
if (web_memcmp(header, "HTTP/1.", strlen("HTTP/1."))) {
char* header_buffer = RT_NULL;
int length = 0;
header_buffer = web_strdup(session->header->buffer);
if (header_buffer == RT_NULL) {
LOG_E("no memory for header buffer!");
rc = -WEBCLIENT_NOMEM;
goto __exit;
}
/* splice http request header data */
if (method == WEBCLIENT_GET)
length = web_snprintf(
session->header->buffer, session->header->size,
"GET %s HTTP/1.1\r\n%s",
session->req_url ? session->req_url : "/",
header_buffer);
else if (method == WEBCLIENT_POST)
length = web_snprintf(
session->header->buffer, session->header->size,
"POST %s HTTP/1.1\r\n%s",
session->req_url ? session->req_url : "/",
header_buffer);
else if (method == WEBCLIENT_HEAD)
length = web_snprintf(
session->header->buffer, session->header->size,
"HEAD %s HTTP/1.1\r\n%s",
session->req_url ? session->req_url : "/",
header_buffer);
session->header->length = length;
web_free(header_buffer);
}
if (strstr(header, "Host:") == RT_NULL) {
if (webclient_header_fields_add(session, "Host: %s\r\n",
session->host) < 0)
return -WEBCLIENT_NOMEM;
}
if (strstr(header, "User-Agent:") == RT_NULL) {
if (webclient_header_fields_add(
session, "User-Agent: RT-Thread HTTP Agent\r\n") < 0)
return -WEBCLIENT_NOMEM;
}
if (strstr(header, "Accept:") == RT_NULL) {
if (webclient_header_fields_add(session, "Accept: */*\r\n") < 0)
return -WEBCLIENT_NOMEM;
}
/* header data end */
web_snprintf(session->header->buffer + session->header->length,
session->header->size - session->header->length,
"\r\n");
session->header->length += 2;
/* check header size */
if (session->header->length > session->header->size) {
LOG_E("send header failed, not enough header buffer size(%d)!",
session->header->size);
rc = -WEBCLIENT_NOBUFFER;
goto __exit;
}
webclient_write(session, (unsigned char*)session->header->buffer,
session->header->length);
} else {
webclient_write(session, (unsigned char*)session->header->buffer,
session->header->length);
}
}
/* get and echo request header data */
{
char *header_str, *header_ptr;
int header_line_len;
LOG_D("request header:");
for (header_str = session->header->buffer;
(header_ptr = strstr(header_str, "\r\n")) != RT_NULL;) {
header_line_len = header_ptr - header_str;
if (header_line_len > 0) {
LOG_D("%.*s", header_line_len, header_str);
}
header_str = header_ptr + strlen("\r\n");
}
#ifdef WEBCLIENT_DEBUG
LOG_RAW("\n");
#endif
}
__exit:
return rc;
}
/**
* resolve server response data.
*
* @param session webclient session
*
* @return <0: resolve response data failed
* =0: success
*/
int webclient_handle_response(struct webclient_session* session) {
int rc = WEBCLIENT_OK;
char* mime_buffer = RT_NULL;
char* mime_ptr = RT_NULL;
const char* transfer_encoding;
int i;
RT_ASSERT(session);
/* clean header buffer and size */
web_memset(session->header->buffer, 0x00, session->header->size);
session->header->length = 0;
LOG_D("response header:");
/* We now need to read the header information */
while (1) {
mime_buffer = session->header->buffer + session->header->length;
/* read a line from the header information. */
rc = webclient_read_line(
session, mime_buffer,
session->header->size - session->header->length);
if (rc < 0)
break;
/* End of headers is a blank line. exit. */
if (rc == 0)
break;
if ((rc == 1) && (mime_buffer[0] == '\r')) {
mime_buffer[0] = '\0';
break;
}
/* set terminal charater */
mime_buffer[rc - 1] = '\0';
/* echo response header data */
LOG_D("%s", mime_buffer);
session->header->length += rc;
if (session->header->length >= session->header->size) {
LOG_E("not enough header buffer size(%d)!", session->header->size);
return -WEBCLIENT_NOMEM;
}
}
/* get HTTP status code */
mime_ptr = web_strdup(session->header->buffer);
if (mime_ptr == RT_NULL) {
LOG_E("no memory for get http status code buffer!");
return -WEBCLIENT_NOMEM;
}
if (strstr(mime_ptr, "HTTP/1.")) {
char* ptr = mime_ptr;
ptr += strlen("HTTP/1.x");
while (*ptr && (*ptr == ' ' || *ptr == '\t'))
ptr++;
/* Terminate string after status code */
for (i = 0; ((ptr[i] != ' ') && (ptr[i] != '\t')); i++)
;
ptr[i] = '\0';
session->resp_status = (int)strtol(ptr, RT_NULL, 10);
}
/* get content length */
if (webclient_header_fields_get(session, "Content-Length") != RT_NULL) {
session->content_length =
atoi(webclient_header_fields_get(session, "Content-Length"));
}
session->content_remainder =
session->content_length ? (size_t)session->content_length : 0xFFFFFFFF;
transfer_encoding =
webclient_header_fields_get(session, "Transfer-Encoding");
if (transfer_encoding && strcmp(transfer_encoding, "chunked") == 0) {
rt_uint16_t len = session->header->size;
char* line = rt_malloc(len);
/* chunk mode, we should get the first chunk size */
webclient_read_line(session, line, len);
session->chunk_sz = strtol(line, RT_NULL, len);
session->chunk_offset = 0;
rt_free(line);
}
if (mime_ptr) {
web_free(mime_ptr);
}
if (rc < 0) {
return rc;
}
return session->resp_status;
}
/**
* create webclient session, set maximum header and response size
*
* @param header_sz maximum send header size
* @param resp_sz maximum response data size
*
* @return webclient session structure
*/
struct webclient_session* webclient_session_create(size_t header_sz) {
struct webclient_session* session;
/* create session */
session = (struct webclient_session*)web_calloc(
1, sizeof(struct webclient_session));
if (session == RT_NULL) {
LOG_E("webclient create failed, no memory for webclient session!");
return RT_NULL;
}
/* initialize the socket of session */
session->socket = -1;
session->content_length = -1;
session->header = (struct webclient_header*)web_calloc(
1, sizeof(struct webclient_header));
if (session->header == RT_NULL) {
LOG_E("webclient create failed, no memory for session header!");
web_free(session);
session = RT_NULL;
return RT_NULL;
}
session->header->size = header_sz;
session->header->buffer = (char*)web_calloc(1, header_sz);
if (session->header->buffer == RT_NULL) {
LOG_E("webclient create failed, no memory for session header buffer!");
web_free(session->header);
web_free(session);
session = RT_NULL;
return RT_NULL;
}
return session;
}
static int webclient_clean(struct webclient_session* session);
/**
* send GET request to http server and get response header.
*
* @param session webclient session
* @param URI input server URI address
* @param header GET request header
* = NULL: use default header data
* != NULL: use custom header data
*
* @return <0: send GET request failed
* >0: response http status code
*/
int webclient_get(struct webclient_session* session, const char* URI) {
int rc = WEBCLIENT_OK;
int resp_status = 0;
RT_ASSERT(session);
RT_ASSERT(URI);
rc = webclient_connect(session, URI);
if (rc != WEBCLIENT_OK) {
/* connect to webclient server failed. */
return rc;
}
rc = webclient_send_header(session, WEBCLIENT_GET);
if (rc != WEBCLIENT_OK) {
/* send header to webclient server failed. */
return rc;
}
/* handle the response header of webclient server */
resp_status = webclient_handle_response(session);
LOG_D("get position handle response(%d).", resp_status);
if (resp_status > 0) {
const char* location = webclient_header_fields_get(session, "Location");
/* relocation */
if ((resp_status == 302 || resp_status == 301) && location) {
char* new_url;
new_url = web_strdup(location);
if (new_url == RT_NULL) {
return -WEBCLIENT_NOMEM;
}
/* clean webclient session */
webclient_clean(session);
/* clean webclient session header */
session->header->length = 0;
web_memset(session->header->buffer, 0, session->header->size);
rc = webclient_get(session, new_url);
web_free(new_url);
return rc;
}
}
return resp_status;
}
/**
* register a handle function for http breakpoint resume and shard download.
*
* @param function
*
* @return the pointer
*/
int* webclient_register_shard_position_function(
struct webclient_session* session,
int (*handle_function)(char* buffer, int size)) {
session->handle_function = handle_function;
return (int*)session->handle_function;
}
/**
* http breakpoint resume and shard download.
*
* @param session webclient session
* @param URI input server URI address
* @param length the length of point
*
* @return <0: send GET request failed
* >0: response http status code
*/
int webclient_shard_head_function(struct webclient_session* session,
const char* URI,
int* length) {
RT_ASSERT(session);
RT_ASSERT(URI);
int rc = WEBCLIENT_OK;
int resp_status = 0;
if (session->socket == -1) {
rc = webclient_connect(session, URI);
if (rc != WEBCLIENT_OK) {
return rc;
}
}
/* clean header buffer and size */
web_memset(session->header->buffer, 0x00, session->header->size);
session->header->length = 0;
rc = webclient_send_header(session, WEBCLIENT_HEAD);
if (rc != WEBCLIENT_OK) {
return rc;
}
/* handle the response header of webclient server by HEAD request */
resp_status = webclient_handle_response(session);
if (resp_status >= 0) {
*length = webclient_content_length_get(session);
LOG_D("The length[%04d] of real data of URI.", *length);
}
return rc;
}
/**
* http breakpoint resume and shard download.
*
* @param session webclient session
* @param URI input server URI address
* @param start the position of you want to receive
* @param length the length of data length from "webclient_shard_head_function"
* @param mem_size the buffer size that you alloc
*
* @return <0: send GET request failed
* >0: response http status code
*/
int webclient_shard_position_function(struct webclient_session* session,
const char* URI,
int start,
int length,
int mem_size) {
int rc = WEBCLIENT_OK;
int result = RT_EOK;
int resp_status = 0;
size_t resp_len = 0;
char* buffer = RT_NULL;
int start_position, end_position = 0;
int total_len = 0;
RT_ASSERT(session);
RT_ASSERT(URI);
RT_ASSERT(mem_size);
/* set the offset of "Range" and "total_len" */
end_position = start;
total_len = start + length;
/* clean header buffer and size */
web_memset(session->header->buffer, 0x00, session->header->size);
session->header->length = 0;
for (start_position = end_position; total_len != end_position + 1;) {
RT_ASSERT(start_position <= total_len);
int data_len = 0;
end_position = start_position + mem_size - 1;
if (end_position >= total_len) {
end_position = total_len - 1;
}
/* splice header and send header */
LOG_D("Range: [%04d -> %04d]", start_position, end_position);
webclient_header_fields_add(session, "Range: bytes=%d-%d\r\n",
start_position, end_position);
rc = webclient_send_header(session, WEBCLIENT_GET);
if (rc != WEBCLIENT_OK) {
return rc;
}
/* handle the response header of webclient server */
resp_status = webclient_handle_response(session);
LOG_D("get position handle response(%d).", resp_status);
if (resp_status == 206) {
/* normal resp_status */
} else if (resp_status > 0) {
const char* location =
webclient_header_fields_get(session, "Location");
/* relocation */
if ((resp_status == 302 || resp_status == 301) && location) {
char* new_url;
new_url = web_strdup(location);
if (new_url == RT_NULL) {
return -WEBCLIENT_NOMEM;
}
/* clean webclient session */
webclient_clean(session);
/* clean webclient session header */
session->header->length = 0;
web_memset(session->header->buffer, 0, session->header->size);
rc = webclient_shard_position_function(session, new_url, start,
length, mem_size);
web_free(new_url);
return rc;
}
} else {
if (resp_status == -WEBCLIENT_ERROR) {
if (session->socket == -WEBCLIENT_ERROR) {
/* clean webclient session */
webclient_clean(session);
if (webclient_connect(session, URI) == WEBCLIENT_OK) {
LOG_D("webclient reconnect success, retry at [%06d]",
end_position);
end_position = start_position;
continue;
} else {
LOG_E(
"webclient reconnect failed. Please retry by "
"yourself.");
return -WEBCLIENT_ERROR;
}
}
}
}
/* receive the incoming data */
data_len = webclient_response(session, (void**)&buffer, &resp_len);
if (data_len > 0) {
start_position += data_len;
result = session->handle_function(buffer, data_len);
if (result != RT_EOK) {
return -WEBCLIENT_ERROR;
}
} else {
/* clean webclient session */
webclient_clean(session);
if (session->socket == -WEBCLIENT_ERROR) {
webclient_connect(session, URI);
}
}
/* clean header buffer and size */
web_memset(session->header->buffer, 0x00, session->header->size);
session->header->length = 0;
}
return rc;
}
/**
* send POST request to server and get response header data.
*
* @param session webclient session
* @param URI input server URI address
* @param post_data data send to the server
* = NULL: just connect server and send header
* != NULL: send header and body data, resolve response data
* @param data_len the length of send data
*
* @return <0: send POST request failed
* =0: send POST header success
* >0: response http status code
*/
int webclient_post(struct webclient_session* session,
const char* URI,
const void* post_data,
size_t data_len) {
int rc = WEBCLIENT_OK;
int resp_status = 0;
RT_ASSERT(session);
RT_ASSERT(URI);
if ((post_data != RT_NULL) && (data_len == 0)) {
LOG_E("input post data length failed");
return -WEBCLIENT_ERROR;
}
rc = webclient_connect(session, URI);
if (rc != WEBCLIENT_OK) {
/* connect to webclient server failed. */
return rc;
}
rc = webclient_send_header(session, WEBCLIENT_POST);
if (rc != WEBCLIENT_OK) {
/* send header to webclient server failed. */
return rc;
}
if (post_data && (data_len > 0)) {
webclient_write(session, post_data, data_len);
/* resolve response data, get http status code */
resp_status = webclient_handle_response(session);
LOG_D("post handle response(%d).", resp_status);
}
return resp_status;
}
/**
* set receive and send data timeout.
*
* @param session http session
* @param millisecond timeout millisecond
*
* @return 0: set timeout success
*/
int webclient_set_timeout(struct webclient_session* session, int millisecond) {
struct timeval timeout;
int second = rt_tick_from_millisecond(millisecond) / 1000;
RT_ASSERT(session);
timeout.tv_sec = second;
timeout.tv_usec = 0;
/* set recv timeout option */
__platform_setsockopt(session->socket, SOL_SOCKET, SO_RCVTIMEO,
(void*)&timeout, sizeof(timeout));
__platform_setsockopt(session->socket, SOL_SOCKET, SO_SNDTIMEO,
(void*)&timeout, sizeof(timeout));
return 0;
}
static int webclient_next_chunk(struct webclient_session* session) {
char line[64];
int length;
RT_ASSERT(session);
web_memset(line, 0x00, sizeof(line));
length = webclient_read_line(session, line, sizeof(line));
if (length > 0) {
if (strcmp(line, "\r") == 0) {
length = webclient_read_line(session, line, sizeof(line));
if (length <= 0) {
__platform_close(session->socket);
session->socket = -1;
return length;
}
}
} else {
__platform_close(session->socket);
session->socket = -1;
return length;
}
session->chunk_sz = strtol(line, RT_NULL, 16);
session->chunk_offset = 0;
if (session->chunk_sz == 0) {
/* end of chunks */
__platform_close(session->socket);
session->socket = -1;
session->chunk_sz = -1;
}
return session->chunk_sz;
}
/**
* read data from http server.
*
* @param session http session
* @param buffer read buffer
* @param length the maximum of read buffer size
*
* @return <0: read data error
* =0: http server disconnect
* >0: successfully read data length
*/
int webclient_read(struct webclient_session* session,
void* buffer,
size_t length) {
int bytes_read = 0;
int total_read = 0;
int left;
RT_ASSERT(session);
/* get next chunk size is zero, client is already closed, return zero */
if (session->chunk_sz < 0) {
return 0;
}
if (session->socket < 0) {
return -WEBCLIENT_DISCONNECT;
}
if (length == 0) {
return 0;
}
/* which is transfered as chunk mode */
if (session->chunk_sz) {
if ((int)length > (session->chunk_sz - session->chunk_offset)) {
length = session->chunk_sz - session->chunk_offset;
}
bytes_read = webclient_recv(session, buffer, length, 0);
if (bytes_read <= 0) {
if (errno == EWOULDBLOCK || errno == EAGAIN) {
/* recv timeout */
return -WEBCLIENT_TIMEOUT;
} else {
__platform_close(session->socket);
session->socket = -1;
return 0;
}
}
session->chunk_offset += bytes_read;
if (session->chunk_offset >= session->chunk_sz) {
webclient_next_chunk(session);
}
return bytes_read;
}
if (session->content_length > 0) {
if (length > session->content_remainder) {
length = session->content_remainder;
}
if (length == 0) {
return 0;
}
}
/*
* Read until: there is an error, we've read "size" bytes or the remote
* side has closed the connection.
*/
left = length;
do {
bytes_read = webclient_recv(
session, (void*)((char*)buffer + total_read), left, 0);
if (bytes_read <= 0) {
#if defined(WEBCLIENT_USING_SAL_TLS) || defined(WEBCLIENT_USING_MBED_TLS)
if (session->is_tls && (bytes_read == MBEDTLS_ERR_SSL_WANT_READ ||
bytes_read == MBEDTLS_ERR_SSL_WANT_WRITE)) {
continue;
}
#endif
LOG_D("receive data error(%d).", bytes_read);
if (total_read) {
break;
} else {
if (errno == EWOULDBLOCK || errno == EAGAIN) {
/* recv timeout */
LOG_E("receive data timeout.");
return -WEBCLIENT_TIMEOUT;
} else {
__platform_close(session->socket);
session->socket = -1;
return 0;
}
}
}
left -= bytes_read;
total_read += bytes_read;
} while (left);
if (session->content_length > 0) {
session->content_remainder -= total_read;
}
return total_read;
}
/**
* write data to http server.
*
* @param session http session
* @param buffer write buffer
* @param length write buffer size
*
* @return <0: write data error
* =0: http server disconnect
* >0: successfully write data length
*/
int webclient_write(struct webclient_session* session,
const void* buffer,
size_t length) {
int bytes_write = 0;
int total_write = 0;
int left = length;
RT_ASSERT(session);
if (session->socket < 0) {
return -WEBCLIENT_DISCONNECT;
}
if (length == 0) {
return 0;
}
/* send all of data on the buffer. */
do {
bytes_write = webclient_send(
session, (void*)((char*)buffer + total_write), left, 0);
if (bytes_write <= 0) {
#if defined(WEBCLIENT_USING_SAL_TLS) || defined(WEBCLIENT_USING_MBED_TLS)
if (session->is_tls &&
(bytes_write == MBEDTLS_ERR_SSL_WANT_READ ||
bytes_write == MBEDTLS_ERR_SSL_WANT_WRITE)) {
continue;
}
#endif
if (errno == EWOULDBLOCK || errno == EAGAIN) {
/* send timeout */
if (total_write) {
return total_write;
}
continue;
/* TODO: whether return the TIMEOUT
* return -WEBCLIENT_TIMEOUT; */
} else {
__platform_close(session->socket);
session->socket = -1;
if (total_write == 0) {
return -WEBCLIENT_DISCONNECT;
}
break;
}
}
left -= bytes_write;
total_write += bytes_write;
} while (left);
return total_write;
}
/* close session socket, free host and request url */
static int webclient_clean(struct webclient_session* session) {
#ifdef WEBCLIENT_USING_MBED_TLS
if (session->tls_session) {
mbedtls_client_close(session->tls_session);
} else {
if (session->socket >= 0) {
__platform_close(session->socket);
session->socket = -1;
}
}
#else
if (session->socket >= 0) {
__platform_close(session->socket);
session->socket = -1;
}
#endif
if (session->host) {
web_free(session->host);
session->host = RT_NULL;
}
if (session->req_url) {
web_free(session->req_url);
session->req_url = RT_NULL;
}
session->content_length = -1;
return 0;
}
/**
* close a webclient client session.
*
* @param session http client session
*
* @return 0: close success
*/
int webclient_close(struct webclient_session* session) {
RT_ASSERT(session);
webclient_clean(session);
if (session->header && session->header->buffer) {
web_free(session->header->buffer);
}
if (session->header) {
web_free(session->header);
}
if (session) {
web_free(session);
session = RT_NULL;
}
return 0;
}
/**
* get wenclient request response data.
*
* @param session wenclient session
* @param response response buffer address
* @param resp_len response buffer length
*
* @return response data size
*/
int webclient_response(struct webclient_session* session,
void** response,
size_t* resp_len) {
unsigned char* buf_ptr;
unsigned char* response_buf = 0;
int length, total_read = 0;
RT_ASSERT(session);
RT_ASSERT(response);
/* initialize response */
*response = RT_NULL;
/* not content length field kind */
if (session->content_length < 0) {
size_t result_sz;
total_read = 0;
while (1) {
unsigned char* new_resp = RT_NULL;
result_sz = total_read + WEBCLIENT_RESPONSE_BUFSZ;
new_resp = web_realloc(response_buf, result_sz + 1);
if (new_resp == RT_NULL) {
LOG_E("no memory for realloc new response buffer!");
break;
}
response_buf = new_resp;
buf_ptr = (unsigned char*)response_buf + total_read;
/* read result */
length = webclient_read(session, buf_ptr, result_sz - total_read);
if (length <= 0)
break;
total_read += length;
}
} else {
int result_sz;
result_sz = session->content_length;
response_buf = web_calloc(1, result_sz + 1);
if (response_buf == RT_NULL) {
return -WEBCLIENT_NOMEM;
}
buf_ptr = (unsigned char*)response_buf;
for (total_read = 0; total_read < result_sz;) {
length = webclient_read(session, buf_ptr, result_sz - total_read);
if (length <= 0)
break;
buf_ptr += length;
total_read += length;
}
}
if ((total_read == 0) && (response_buf != 0)) {
web_free(response_buf);
response_buf = RT_NULL;
}
if (response_buf) {
*response = (void*)response_buf;
*(response_buf + total_read) = '\0';
*resp_len = total_read;
}
return total_read;
}
/**
* add request(GET/POST) header data.
*
* @param request_header add request buffer address
* @param fmt fields format
*
* @return <=0: add header failed
* >0: add header data size
*/
int webclient_request_header_add(char** request_header, const char* fmt, ...) {
rt_int32_t length, header_length;
char* header;
va_list args;
RT_ASSERT(request_header);
if (*request_header == RT_NULL) {
header = rt_calloc(1, WEBCLIENT_HEADER_BUFSZ);
if (header == RT_NULL) {
LOG_E("No memory for webclient request header add.");
return RT_NULL;
}
*request_header = header;
} else {
header = *request_header;
}
va_start(args, fmt);
header_length = strlen(header);
length = web_vsnprintf(header + header_length,
WEBCLIENT_HEADER_BUFSZ - header_length, fmt, args);
if (length < 0) {
LOG_E("add request header data failed, return length(%d) error.",
length);
return -WEBCLIENT_ERROR;
}
va_end(args);
/* check header size */
if (strlen(header) >= WEBCLIENT_HEADER_BUFSZ) {
LOG_E("not enough request header data size(%d)!",
WEBCLIENT_HEADER_BUFSZ);
return -WEBCLIENT_ERROR;
}
return length;
}
/**
* send request(GET/POST) to server and get response data.
*
* @param URI input server address
* @param header send header data
* = NULL: use default header data, must be GET request
* != NULL: user custom header data, GET or POST request
* @param post_data data sent to the server
* = NULL: it is GET request
* != NULL: it is POST request
* @param data_len send data length
* @param response response buffer address
* @param resp_len response buffer length
*
* @return <0: request failed
* >=0: response buffer size
*/
int webclient_request(const char* URI,
const char* header,
const void* post_data,
size_t data_len,
void** response,
size_t* resp_len) {
struct webclient_session* session = RT_NULL;
int rc = WEBCLIENT_OK;
int totle_length = 0;
RT_ASSERT(URI);
if (post_data == RT_NULL && response == RT_NULL) {
LOG_E("request get failed, get response data cannot be empty.");
return -WEBCLIENT_ERROR;
}
if ((post_data != RT_NULL) && (data_len == 0)) {
LOG_E("input post data length failed");
return -WEBCLIENT_ERROR;
}
if ((response != RT_NULL && resp_len == RT_NULL) ||
(response == RT_NULL && resp_len != RT_NULL)) {
LOG_E("input response data or length failed");
return -WEBCLIENT_ERROR;
}
if (post_data == RT_NULL) {
/* send get request */
session = webclient_session_create(WEBCLIENT_HEADER_BUFSZ);
if (session == RT_NULL) {
rc = -WEBCLIENT_NOMEM;
goto __exit;
}
if (header != RT_NULL) {
char *header_str, *header_ptr;
int header_line_length;
for (header_str = (char*)header;
(header_ptr = strstr(header_str, "\r\n")) != RT_NULL;) {
header_line_length = header_ptr + strlen("\r\n") - header_str;
webclient_header_fields_add(session, "%.*s", header_line_length,
header_str);
header_str += header_line_length;
}
}
if (webclient_get(session, URI) != 200) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
totle_length = webclient_response(session, response, resp_len);
if (totle_length <= 0) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
} else {
/* send post request */
session = webclient_session_create(WEBCLIENT_HEADER_BUFSZ);
if (session == RT_NULL) {
rc = -WEBCLIENT_NOMEM;
goto __exit;
}
if (header != RT_NULL) {
char *header_str, *header_ptr;
int header_line_length;
for (header_str = (char*)header;
(header_ptr = strstr(header_str, "\r\n")) != RT_NULL;) {
header_line_length = header_ptr + strlen("\r\n") - header_str;
webclient_header_fields_add(session, "%.*s", header_line_length,
header_str);
header_str += header_line_length;
}
}
if (strstr(session->header->buffer, "Content-Length") == RT_NULL) {
webclient_header_fields_add(session, "Content-Length: %d\r\n",
strlen(post_data));
}
if (strstr(session->header->buffer, "Content-Type") == RT_NULL) {
webclient_header_fields_add(
session, "Content-Type: application/octet-stream\r\n");
}
if (webclient_post(session, URI, post_data, data_len) != 200) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
totle_length = webclient_response(session, response, resp_len);
if (totle_length <= 0) {
rc = -WEBCLIENT_ERROR;
goto __exit;
}
}
__exit:
if (session) {
webclient_close(session);
session = RT_NULL;
}
if (rc < 0) {
return rc;
}
return totle_length;
}
Reference in New Issue View Git Blame Copy Permalink