2017-10-26 03:39:41 +02:00
/*************************************************************************/
/* http_client_javascript.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2018-01-05 00:50:27 +01:00
/* https://godotengine.org */
2017-10-26 03:39:41 +02:00
/*************************************************************************/
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
2017-10-26 03:39:41 +02:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-01-05 00:50:27 +01:00
2018-09-11 18:13:45 +02:00
# include "core/io/http_client.h"
2020-05-12 17:01:17 +02:00
2021-03-02 16:00:24 +01:00
# ifdef __cplusplus
extern " C " {
# endif
# include "stddef.h"
typedef enum {
GODOT_JS_FETCH_STATE_REQUESTING = 0 ,
GODOT_JS_FETCH_STATE_BODY = 1 ,
GODOT_JS_FETCH_STATE_DONE = 2 ,
GODOT_JS_FETCH_STATE_ERROR = - 1 ,
} godot_js_fetch_state_t ;
extern int godot_js_fetch_create ( const char * p_method , const char * p_url , const char * * p_headers , int p_headers_len , const uint8_t * p_body , int p_body_len ) ;
extern int godot_js_fetch_read_headers ( int p_id , void ( * parse_callback ) ( int p_size , const char * * p_headers , void * p_ref ) , void * p_ref ) ;
extern int godot_js_fetch_read_chunk ( int p_id , uint8_t * p_buf , int p_buf_size ) ;
extern void godot_js_fetch_free ( int p_id ) ;
extern godot_js_fetch_state_t godot_js_fetch_state_get ( int p_id ) ;
extern int godot_js_fetch_body_length_get ( int p_id ) ;
extern int godot_js_fetch_http_status_get ( int p_id ) ;
extern int godot_js_fetch_is_chunked ( int p_id ) ;
# ifdef __cplusplus
}
# endif
void HTTPClient : : _parse_headers ( int p_len , const char * * p_headers , void * p_ref ) {
HTTPClient * client = static_cast < HTTPClient * > ( p_ref ) ;
for ( int i = 0 ; i < p_len ; i + + ) {
client - > response_headers . push_back ( String : : utf8 ( p_headers [ i ] ) ) ;
}
}
2017-10-26 03:39:41 +02:00
Error HTTPClient : : connect_to_host ( const String & p_host , int p_port , bool p_ssl , bool p_verify_host ) {
close ( ) ;
if ( p_ssl & & ! p_verify_host ) {
WARN_PRINT ( " Disabling HTTPClient's host verification is not supported for the HTML5 platform, host will be verified " ) ;
}
2017-12-12 20:02:25 +01:00
port = p_port ;
use_tls = p_ssl ;
2017-10-26 03:39:41 +02:00
host = p_host ;
2017-12-12 20:02:25 +01:00
2017-12-15 15:32:44 +01:00
String host_lower = host . to_lower ( ) ;
2017-12-12 20:02:25 +01:00
if ( host_lower . begins_with ( " http:// " ) ) {
2017-12-15 15:32:44 +01:00
host = host . substr ( 7 , host . length ( ) - 7 ) ;
2017-12-12 20:02:25 +01:00
} else if ( host_lower . begins_with ( " https:// " ) ) {
use_tls = true ;
2017-12-15 15:32:44 +01:00
host = host . substr ( 8 , host . length ( ) - 8 ) ;
2017-10-26 03:39:41 +02:00
}
2017-12-12 20:02:25 +01:00
ERR_FAIL_COND_V ( host . length ( ) < HOST_MIN_LEN , ERR_INVALID_PARAMETER ) ;
if ( port < 0 ) {
if ( use_tls ) {
port = PORT_HTTPS ;
} else {
port = PORT_HTTP ;
}
}
2017-10-26 03:39:41 +02:00
status = host . is_valid_ip_address ( ) ? STATUS_CONNECTING : STATUS_RESOLVING ;
2017-12-12 20:02:25 +01:00
2017-10-26 03:39:41 +02:00
return OK ;
}
void HTTPClient : : set_connection ( const Ref < StreamPeer > & p_connection ) {
2019-08-09 06:49:33 +02:00
ERR_FAIL_MSG ( " Accessing an HTTPClient's StreamPeer is not supported for the HTML5 platform. " ) ;
2017-10-26 03:39:41 +02:00
}
Ref < StreamPeer > HTTPClient : : get_connection ( ) const {
2019-08-09 06:49:33 +02:00
ERR_FAIL_V_MSG ( REF ( ) , " Accessing an HTTPClient's StreamPeer is not supported for the HTML5 platform. " ) ;
2017-10-26 03:39:41 +02:00
}
2021-03-23 15:17:32 +01:00
Error HTTPClient : : request ( Method p_method , const String & p_url , const Vector < String > & p_headers , const uint8_t * p_body , int p_body_len ) {
2017-10-26 03:39:41 +02:00
ERR_FAIL_INDEX_V ( p_method , METHOD_MAX , ERR_INVALID_PARAMETER ) ;
2019-08-09 06:49:33 +02:00
ERR_FAIL_COND_V_MSG ( p_method = = METHOD_TRACE | | p_method = = METHOD_CONNECT , ERR_UNAVAILABLE , " HTTP methods TRACE and CONNECT are not supported for the HTML5 platform. " ) ;
2017-10-26 03:39:41 +02:00
ERR_FAIL_COND_V ( status ! = STATUS_CONNECTED , ERR_INVALID_PARAMETER ) ;
2020-12-29 09:54:59 +01:00
ERR_FAIL_COND_V ( host . is_empty ( ) , ERR_UNCONFIGURED ) ;
2017-10-26 03:39:41 +02:00
ERR_FAIL_COND_V ( port < 0 , ERR_UNCONFIGURED ) ;
2017-12-12 20:02:25 +01:00
ERR_FAIL_COND_V ( ! p_url . begins_with ( " / " ) , ERR_INVALID_PARAMETER ) ;
2017-10-26 03:39:41 +02:00
2018-03-30 14:31:18 +02:00
String url = ( use_tls ? " https:// " : " http:// " ) + host + " : " + itos ( port ) + p_url ;
2021-03-02 16:00:24 +01:00
Vector < CharString > keeper ;
Vector < const char * > c_strings ;
2017-10-26 03:39:41 +02:00
for ( int i = 0 ; i < p_headers . size ( ) ; i + + ) {
2021-03-02 16:00:24 +01:00
keeper . push_back ( p_headers [ i ] . utf8 ( ) ) ;
c_strings . push_back ( keeper [ i ] . get_data ( ) ) ;
}
if ( js_id ) {
godot_js_fetch_free ( js_id ) ;
2017-10-26 03:39:41 +02:00
}
2021-03-02 16:00:24 +01:00
js_id = godot_js_fetch_create ( _methods [ p_method ] , url . utf8 ( ) . get_data ( ) , c_strings . ptrw ( ) , c_strings . size ( ) , p_body , p_body_len ) ;
2017-10-26 03:39:41 +02:00
status = STATUS_REQUESTING ;
return OK ;
}
void HTTPClient : : close ( ) {
host = " " ;
port = - 1 ;
use_tls = false ;
status = STATUS_DISCONNECTED ;
polled_response_code = 0 ;
2021-03-02 16:00:24 +01:00
response_headers . resize ( 0 ) ;
response_buffer . resize ( 0 ) ;
if ( js_id ) {
godot_js_fetch_free ( js_id ) ;
js_id = 0 ;
}
2017-10-26 03:39:41 +02:00
}
HTTPClient : : Status HTTPClient : : get_status ( ) const {
return status ;
}
bool HTTPClient : : has_response ( ) const {
2021-03-02 16:00:24 +01:00
return response_headers . size ( ) > 0 ;
2017-10-26 03:39:41 +02:00
}
bool HTTPClient : : is_response_chunked ( ) const {
2021-03-02 16:00:24 +01:00
return godot_js_fetch_is_chunked ( js_id ) ;
2017-10-26 03:39:41 +02:00
}
int HTTPClient : : get_response_code ( ) const {
return polled_response_code ;
}
Error HTTPClient : : get_response_headers ( List < String > * r_response ) {
2021-03-02 16:00:24 +01:00
if ( ! response_headers . size ( ) ) {
2017-10-26 03:39:41 +02:00
return ERR_INVALID_PARAMETER ;
}
2021-03-02 16:00:24 +01:00
for ( int i = 0 ; i < response_headers . size ( ) ; i + + ) {
r_response - > push_back ( response_headers [ i ] ) ;
}
response_headers . clear ( ) ;
2017-10-26 03:39:41 +02:00
return OK ;
}
int HTTPClient : : get_response_body_length ( ) const {
2021-03-02 16:00:24 +01:00
return godot_js_fetch_body_length_get ( js_id ) ;
2017-10-26 03:39:41 +02:00
}
2020-02-17 22:06:54 +01:00
PackedByteArray HTTPClient : : read_response_body_chunk ( ) {
ERR_FAIL_COND_V ( status ! = STATUS_BODY , PackedByteArray ( ) ) ;
2017-10-26 03:39:41 +02:00
2021-03-02 16:00:24 +01:00
if ( response_buffer . size ( ) ! = read_limit ) {
response_buffer . resize ( read_limit ) ;
}
int read = godot_js_fetch_read_chunk ( js_id , response_buffer . ptrw ( ) , read_limit ) ;
// Check if the stream is over.
godot_js_fetch_state_t state = godot_js_fetch_state_get ( js_id ) ;
if ( state = = GODOT_JS_FETCH_STATE_DONE ) {
status = STATUS_DISCONNECTED ;
} else if ( state ! = GODOT_JS_FETCH_STATE_BODY ) {
status = STATUS_CONNECTION_ERROR ;
2017-10-26 03:39:41 +02:00
}
2021-03-02 16:00:24 +01:00
PackedByteArray chunk ;
if ( ! read ) {
return chunk ;
}
chunk . resize ( read ) ;
2021-04-27 16:19:21 +02:00
memcpy ( chunk . ptrw ( ) , response_buffer . ptr ( ) , read ) ;
2017-10-26 03:39:41 +02:00
return chunk ;
}
void HTTPClient : : set_blocking_mode ( bool p_enable ) {
2019-08-09 06:49:33 +02:00
ERR_FAIL_COND_MSG ( p_enable , " HTTPClient blocking mode is not supported for the HTML5 platform. " ) ;
2017-10-26 03:39:41 +02:00
}
bool HTTPClient : : is_blocking_mode_enabled ( ) const {
return false ;
}
void HTTPClient : : set_read_chunk_size ( int p_size ) {
read_limit = p_size ;
}
2019-11-24 13:20:24 +01:00
int HTTPClient : : get_read_chunk_size ( ) const {
return read_limit ;
}
2017-10-26 03:39:41 +02:00
Error HTTPClient : : poll ( ) {
switch ( status ) {
case STATUS_DISCONNECTED :
return ERR_UNCONFIGURED ;
case STATUS_RESOLVING :
status = STATUS_CONNECTING ;
return OK ;
case STATUS_CONNECTING :
status = STATUS_CONNECTED ;
return OK ;
case STATUS_CONNECTED :
return OK ;
2021-03-02 16:00:24 +01:00
case STATUS_BODY : {
godot_js_fetch_state_t state = godot_js_fetch_state_get ( js_id ) ;
if ( state = = GODOT_JS_FETCH_STATE_DONE ) {
status = STATUS_DISCONNECTED ;
} else if ( state ! = GODOT_JS_FETCH_STATE_BODY ) {
status = STATUS_CONNECTION_ERROR ;
return ERR_CONNECTION_ERROR ;
}
return OK ;
}
2017-10-26 03:39:41 +02:00
case STATUS_CONNECTION_ERROR :
return ERR_CONNECTION_ERROR ;
2018-10-02 02:30:27 +02:00
case STATUS_REQUESTING : {
2018-02-17 17:42:58 +01:00
# ifdef DEBUG_ENABLED
2021-03-02 16:00:24 +01:00
// forcing synchronous requests is not possible on the web
if ( last_polling_frame = = Engine : : get_singleton ( ) - > get_process_frames ( ) ) {
WARN_PRINT ( " HTTPClient polled multiple times in one frame, "
" but request cannot progress more than once per "
" frame on the HTML5 platform. " ) ;
2018-02-17 17:42:58 +01:00
}
2021-01-10 11:05:38 +01:00
last_polling_frame = Engine : : get_singleton ( ) - > get_process_frames ( ) ;
2018-02-17 17:42:58 +01:00
# endif
2021-03-02 16:00:24 +01:00
polled_response_code = godot_js_fetch_http_status_get ( js_id ) ;
godot_js_fetch_state_t js_state = godot_js_fetch_state_get ( js_id ) ;
if ( js_state = = GODOT_JS_FETCH_STATE_REQUESTING ) {
2018-02-16 05:11:25 +01:00
return OK ;
2021-03-02 16:00:24 +01:00
} else if ( js_state = = GODOT_JS_FETCH_STATE_ERROR ) {
// Fetch is in error state.
status = STATUS_CONNECTION_ERROR ;
return ERR_CONNECTION_ERROR ;
}
if ( godot_js_fetch_read_headers ( js_id , & _parse_headers , this ) ) {
// Failed to parse headers.
2018-02-16 05:11:25 +01:00
status = STATUS_CONNECTION_ERROR ;
return ERR_CONNECTION_ERROR ;
2017-10-26 03:39:41 +02:00
}
status = STATUS_BODY ;
break ;
2018-10-02 02:30:27 +02:00
}
default :
ERR_FAIL_V ( ERR_BUG ) ;
2017-10-26 03:39:41 +02:00
}
return OK ;
}
HTTPClient : : HTTPClient ( ) {
}
HTTPClient : : ~ HTTPClient ( ) {
2021-03-02 16:00:24 +01:00
close ( ) ;
2017-10-26 03:39:41 +02:00
}