godot/core/io/http_client.cpp
2014-05-01 09:53:37 -03:00

683 lines
18 KiB
C++

/*************************************************************************/
/* http_client.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/*************************************************************************/
#include "http_client.h"
#include "io/stream_peer_ssl.h"
Error HTTPClient::connect_url(const String& p_url) {
return OK;
}
Error HTTPClient::connect(const String &p_host, int p_port, bool p_ssl,bool p_verify_host){
close();
conn_port=p_port;
conn_host=p_host;
if (conn_host.begins_with("http://")) {
conn_host=conn_host.replace_first("http://","");
} else if (conn_host.begins_with("https://")) {
//use https
conn_host=conn_host.replace_first("https://","");
}
ssl=p_ssl;
ssl_verify_host=p_verify_host;
connection=tcp_connection;
if (conn_host.is_valid_ip_address()) {
//is ip
Error err = tcp_connection->connect(IP_Address(conn_host),p_port);
if (err) {
status=STATUS_CANT_CONNECT;
return err;
}
status=STATUS_CONNECTING;
} else {
//is hostname
resolving=IP::get_singleton()->resolve_hostname_queue_item(conn_host);
status=STATUS_RESOLVING;
}
return OK;
}
void HTTPClient::set_connection(const Ref<StreamPeer>& p_connection){
close();
connection=p_connection;
}
Error HTTPClient::request( Method p_method, const String& p_url, const Vector<String>& p_headers,const String& p_body) {
ERR_FAIL_INDEX_V(p_method,METHOD_MAX,ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(status!=STATUS_CONNECTED,ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(connection.is_null(),ERR_INVALID_DATA);
static const char* _methods[METHOD_MAX]={
"GET",
"HEAD",
"POST",
"PUT",
"DELETE",
"OPTIONS",
"TRACE",
"CONNECT"};
String request=String(_methods[p_method])+" "+p_url+" HTTP/1.1\r\n";
request+="Host: "+conn_host+":"+itos(conn_port)+"\r\n";
bool add_clen=p_body.length()>0;
for(int i=0;i<p_headers.size();i++) {
request+=p_headers[i]+"\r\n";
if (add_clen && p_headers[i].find("Content-Length:")==0) {
add_clen=false;
}
}
if (add_clen) {
request+="Content-Length: "+itos(p_body.utf8().length())+"\r\n";
//should it add utf8 encoding? not sure
}
request+="\r\n";
request+=p_body;
CharString cs=request.utf8();
Error err = connection->put_data((const uint8_t*)cs.ptr(),cs.length());
if (err) {
close();
status=STATUS_CONNECTION_ERROR;
return err;
}
status=STATUS_REQUESTING;
return OK;
}
Error HTTPClient::send_body_text(const String& p_body){
return OK;
}
Error HTTPClient::send_body_data(const ByteArray& p_body){
return OK;
}
bool HTTPClient::has_response() const {
return response_headers.size()!=0;
}
bool HTTPClient::is_response_chunked() const {
return chunked;
}
int HTTPClient::get_response_code() const {
return response_num;
}
Error HTTPClient::get_response_headers(List<String> *r_response) {
if (!response_headers.size())
return ERR_INVALID_PARAMETER;
for(int i=0;i<response_headers.size();i++) {
r_response->push_back(response_headers[i]);
}
response_headers.clear();
return OK;
}
void HTTPClient::close(){
if (tcp_connection->get_status()!=StreamPeerTCP::STATUS_NONE)
tcp_connection->disconnect();
connection.unref();
status=STATUS_DISCONNECTED;
if (resolving!=IP::RESOLVER_INVALID_ID) {
IP::get_singleton()->erase_resolve_item(resolving);
resolving=IP::RESOLVER_INVALID_ID;
}
response_headers.clear();
response_str.clear();
body_size=0;
body_left=0;
chunk_left=0;
response_num=0;
}
Error HTTPClient::poll(){
switch(status) {
case STATUS_RESOLVING: {
ERR_FAIL_COND_V(resolving==IP::RESOLVER_INVALID_ID,ERR_BUG);
IP::ResolverStatus rstatus = IP::get_singleton()->get_resolve_item_status(resolving);
switch(rstatus) {
case IP::RESOLVER_STATUS_WAITING: return OK; //still resolving
case IP::RESOLVER_STATUS_DONE: {
IP_Address host = IP::get_singleton()->get_resolve_item_address(resolving);
Error err = tcp_connection->connect(host,conn_port);
IP::get_singleton()->erase_resolve_item(resolving);
resolving=IP::RESOLVER_INVALID_ID;
if (err) {
status=STATUS_CANT_CONNECT;
return err;
}
status=STATUS_CONNECTING;
} break;
case IP::RESOLVER_STATUS_NONE:
case IP::RESOLVER_STATUS_ERROR: {
IP::get_singleton()->erase_resolve_item(resolving);
resolving=IP::RESOLVER_INVALID_ID;
close();
status=STATUS_CANT_RESOLVE;
return ERR_CANT_RESOLVE;
} break;
}
} break;
case STATUS_CONNECTING: {
StreamPeerTCP::Status s = tcp_connection->get_status();
switch(s) {
case StreamPeerTCP::STATUS_CONNECTING: {
return OK; //do none
} break;
case StreamPeerTCP::STATUS_CONNECTED: {
if (ssl) {
Ref<StreamPeerSSL> ssl = StreamPeerSSL::create();
Error err = ssl->connect(tcp_connection,true,ssl_verify_host?conn_host:String());
if (err!=OK) {
close();
status=STATUS_SSL_HANDSHAKE_ERROR;
return ERR_CANT_CONNECT;
}
print_line("SSL! TURNED ON!");
connection=ssl;
}
status=STATUS_CONNECTED;
return OK;
} break;
case StreamPeerTCP::STATUS_ERROR:
case StreamPeerTCP::STATUS_NONE: {
close();
status=STATUS_CANT_CONNECT;
return ERR_CANT_CONNECT;
} break;
}
} break;
case STATUS_CONNECTED: {
//request something please
return OK;
} break;
case STATUS_REQUESTING: {
while(true) {
uint8_t byte;
int rec=0;
Error err = connection->get_partial_data(&byte,1,rec);
if (err!=OK) {
close();
status=STATUS_CONNECTION_ERROR;
return ERR_CONNECTION_ERROR;
}
if (rec==0)
return OK; //keep trying!
response_str.push_back(byte);
int rs = response_str.size();
if (
(rs>=2 && response_str[rs-2]=='\n' && response_str[rs-1]=='\n') ||
(rs>=4 && response_str[rs-4]=='\r' && response_str[rs-3]=='\n' && rs>=4 && response_str[rs-2]=='\r' && response_str[rs-1]=='\n')
) {
//end of response, parse.
response_str.push_back(0);
String response;
response.parse_utf8((const char*)response_str.ptr());
print_line("END OF RESPONSE? :\n"+response+"\n------");
Vector<String> responses = response.split("\n");
body_size=0;
chunked=false;
body_left=0;
chunk_left=0;
response_headers.clear();
response_num = RESPONSE_OK;
for(int i=0;i<responses.size();i++) {
String s = responses[i].strip_edges();
if (s.length()==0)
continue;
if (s.begins_with("Content-Length:")) {
body_size = s.substr(s.find(":")+1,s.length()).strip_edges().to_int();
body_left=body_size;
}
if (s.begins_with("Transfer-Encoding:")) {
String encoding = s.substr(s.find(":")+1,s.length()).strip_edges();
print_line("TRANSFER ENCODING: "+encoding);
if (encoding=="chunked") {
chunked=true;
}
}
if (i==0 && responses[i].begins_with("HTTP")) {
String num = responses[i].get_slice(" ",1);
response_num=num.to_int();
} else {
response_headers.push_back(s);
}
}
if (body_size==0 && !chunked) {
status=STATUS_CONNECTED; //ask for something again?
} else {
status=STATUS_BODY;
}
return OK;
}
}
//wait for response
return OK;
} break;
case STATUS_DISCONNECTED: {
return ERR_UNCONFIGURED;
} break;
case STATUS_CONNECTION_ERROR: {
return ERR_CONNECTION_ERROR;
} break;
case STATUS_CANT_CONNECT: {
return ERR_CANT_CONNECT;
} break;
case STATUS_CANT_RESOLVE: {
return ERR_CANT_RESOLVE;
} break;
}
return OK;
}
Dictionary HTTPClient::_get_response_headers_as_dictionary() {
List<String> rh;
get_response_headers(&rh);
Dictionary ret;
for(const List<String>::Element *E=rh.front();E;E=E->next()) {
String s = E->get();
int sp = s.find(":");
if (sp==-1)
continue;
String key = s.substr(0,sp).strip_edges();
String value = s.substr(sp+1,s.length()).strip_edges();
ret[key]=value;
}
return ret;
}
StringArray HTTPClient::_get_response_headers() {
List<String> rh;
get_response_headers(&rh);
StringArray ret;
ret.resize(rh.size());
int idx=0;
for(const List<String>::Element *E=rh.front();E;E=E->next()) {
ret.set(idx++,E->get());
}
return ret;
}
int HTTPClient::get_response_body_length() const {
return body_size;
}
ByteArray HTTPClient::read_response_body_chunk() {
ERR_FAIL_COND_V( status !=STATUS_BODY, ByteArray() );
Error err=OK;
if (chunked) {
while(true) {
if (chunk_left==0) {
//reading len
uint8_t b;
int rec=0;
err = connection->get_partial_data(&b,1,rec);
if (rec==0)
break;
chunk.push_back(b);
if (chunk.size()>32) {
ERR_PRINT("HTTP Invalid chunk hex len");
status=STATUS_CONNECTION_ERROR;
return ByteArray();
}
if (chunk.size()>2 && chunk[chunk.size()-2]=='\r' && chunk[chunk.size()-1]=='\n') {
int len=0;
for(int i=0;i<chunk.size()-2;i++) {
char c = chunk[i];
int v=0;
if (c>='0' && c<='9')
v=c-'0';
else if (c>='a' && c<='f')
v=c-'a'+10;
else if (c>='A' && c<='F')
v=c-'A'+10;
else {
ERR_PRINT("HTTP Chunk len not in hex!!");
status=STATUS_CONNECTION_ERROR;
return ByteArray();
}
len<<=4;
len|=v;
if (len>(1<<24)) {
ERR_PRINT("HTTP Chunk too big!! >16mb");
status=STATUS_CONNECTION_ERROR;
return ByteArray();
}
}
if (len==0) {
//end!
status=STATUS_CONNECTED;
chunk.clear();
return ByteArray();
}
chunk_left=len+2;
chunk.resize(chunk_left);
}
} else {
int rec=0;
err = connection->get_partial_data(&chunk[chunk.size()-chunk_left],chunk_left,rec);
if (rec==0) {
break;
}
chunk_left-=rec;
if (chunk_left==0) {
if (chunk[chunk.size()-2]!='\r' || chunk[chunk.size()-1]!='\n') {
ERR_PRINT("HTTP Invalid chunk terminator (not \\r\\n)");
status=STATUS_CONNECTION_ERROR;
return ByteArray();
}
ByteArray ret;
ret.resize(chunk.size()-2);
{
ByteArray::Write w = ret.write();
copymem(w.ptr(),chunk.ptr(),chunk.size()-2);
}
chunk.clear();
return ret;
}
break;
}
}
} else {
ByteArray::Write r = tmp_read.write();
int rec=0;
err = connection->get_partial_data(r.ptr(),MIN(body_left,tmp_read.size()),rec);
if (rec>0) {
ByteArray ret;
ret.resize(rec);
ByteArray::Write w = ret.write();
copymem(w.ptr(),r.ptr(),rec);
body_left-=rec;
if (body_left==0) {
status=STATUS_CONNECTED;
}
return ret;
}
}
if (err!=OK) {
close();
if (err==ERR_FILE_EOF) {
status=STATUS_DISCONNECTED; //server disconnected
} else {
status=STATUS_CONNECTION_ERROR;
}
} else if (body_left==0 && !chunked) {
status=STATUS_CONNECTED;
}
return ByteArray();
}
HTTPClient::Status HTTPClient::get_status() const {
return status;
}
void HTTPClient::set_blocking_mode(bool p_enable) {
blocking=p_enable;
}
bool HTTPClient::is_blocking_mode_enabled() const{
return blocking;
}
void HTTPClient::_bind_methods() {
ObjectTypeDB::bind_method(_MD("connect:Error","host","port","use_ssl"),&HTTPClient::connect,DEFVAL(false),DEFVAL(true));
ObjectTypeDB::bind_method(_MD("set_connection","connection:StreamPeer"),&HTTPClient::set_connection);
ObjectTypeDB::bind_method(_MD("request","method","url","headers","body"),&HTTPClient::request,DEFVAL(String()));
ObjectTypeDB::bind_method(_MD("send_body_text","body"),&HTTPClient::send_body_text);
ObjectTypeDB::bind_method(_MD("send_body_data","body"),&HTTPClient::send_body_data);
ObjectTypeDB::bind_method(_MD("close"),&HTTPClient::close);
ObjectTypeDB::bind_method(_MD("has_response"),&HTTPClient::has_response);
ObjectTypeDB::bind_method(_MD("is_response_chunked"),&HTTPClient::is_response_chunked);
ObjectTypeDB::bind_method(_MD("get_response_code"),&HTTPClient::get_response_code);
ObjectTypeDB::bind_method(_MD("get_response_headers"),&HTTPClient::_get_response_headers);
ObjectTypeDB::bind_method(_MD("get_response_headers_as_dictionary"),&HTTPClient::_get_response_headers_as_dictionary);
ObjectTypeDB::bind_method(_MD("get_response_body_length"),&HTTPClient::get_response_body_length);
ObjectTypeDB::bind_method(_MD("read_response_body_chunk"),&HTTPClient::read_response_body_chunk);
ObjectTypeDB::bind_method(_MD("set_blocking_mode","enabled"),&HTTPClient::set_blocking_mode);
ObjectTypeDB::bind_method(_MD("is_blocking_mode_enabled"),&HTTPClient::is_blocking_mode_enabled);
ObjectTypeDB::bind_method(_MD("get_status"),&HTTPClient::get_status);
ObjectTypeDB::bind_method(_MD("poll:Error"),&HTTPClient::poll);
BIND_CONSTANT( METHOD_GET );
BIND_CONSTANT( METHOD_HEAD );
BIND_CONSTANT( METHOD_POST );
BIND_CONSTANT( METHOD_PUT );
BIND_CONSTANT( METHOD_DELETE );
BIND_CONSTANT( METHOD_OPTIONS );
BIND_CONSTANT( METHOD_TRACE );
BIND_CONSTANT( METHOD_CONNECT );
BIND_CONSTANT( METHOD_MAX );
BIND_CONSTANT( STATUS_DISCONNECTED );
BIND_CONSTANT( STATUS_RESOLVING ); //resolving hostname (if passed a hostname)
BIND_CONSTANT( STATUS_CANT_RESOLVE );
BIND_CONSTANT( STATUS_CONNECTING ); //connecting to ip
BIND_CONSTANT( STATUS_CANT_CONNECT );
BIND_CONSTANT( STATUS_CONNECTED ); //connected ); requests only accepted here
BIND_CONSTANT( STATUS_REQUESTING ); // request in progress
BIND_CONSTANT( STATUS_BODY ); // request resulted in body ); which must be read
BIND_CONSTANT( STATUS_CONNECTION_ERROR );
BIND_CONSTANT( STATUS_SSL_HANDSHAKE_ERROR );
BIND_CONSTANT( RESPONSE_CONTINUE );
BIND_CONSTANT( RESPONSE_SWITCHING_PROTOCOLS );
BIND_CONSTANT( RESPONSE_PROCESSING );
// 2xx successful
BIND_CONSTANT( RESPONSE_OK );
BIND_CONSTANT( RESPONSE_CREATED );
BIND_CONSTANT( RESPONSE_ACCEPTED );
BIND_CONSTANT( RESPONSE_NON_AUTHORITATIVE_INFORMATION );
BIND_CONSTANT( RESPONSE_NO_CONTENT );
BIND_CONSTANT( RESPONSE_RESET_CONTENT );
BIND_CONSTANT( RESPONSE_PARTIAL_CONTENT );
BIND_CONSTANT( RESPONSE_MULTI_STATUS );
BIND_CONSTANT( RESPONSE_IM_USED );
// 3xx redirection
BIND_CONSTANT( RESPONSE_MULTIPLE_CHOICES );
BIND_CONSTANT( RESPONSE_MOVED_PERMANENTLY );
BIND_CONSTANT( RESPONSE_FOUND );
BIND_CONSTANT( RESPONSE_SEE_OTHER );
BIND_CONSTANT( RESPONSE_NOT_MODIFIED );
BIND_CONSTANT( RESPONSE_USE_PROXY );
BIND_CONSTANT( RESPONSE_TEMPORARY_REDIRECT );
// 4xx client error
BIND_CONSTANT( RESPONSE_BAD_REQUEST );
BIND_CONSTANT( RESPONSE_UNAUTHORIZED );
BIND_CONSTANT( RESPONSE_PAYMENT_REQUIRED );
BIND_CONSTANT( RESPONSE_FORBIDDEN );
BIND_CONSTANT( RESPONSE_NOT_FOUND );
BIND_CONSTANT( RESPONSE_METHOD_NOT_ALLOWED );
BIND_CONSTANT( RESPONSE_NOT_ACCEPTABLE );
BIND_CONSTANT( RESPONSE_PROXY_AUTHENTICATION_REQUIRED );
BIND_CONSTANT( RESPONSE_REQUEST_TIMEOUT );
BIND_CONSTANT( RESPONSE_CONFLICT );
BIND_CONSTANT( RESPONSE_GONE );
BIND_CONSTANT( RESPONSE_LENGTH_REQUIRED );
BIND_CONSTANT( RESPONSE_PRECONDITION_FAILED );
BIND_CONSTANT( RESPONSE_REQUEST_ENTITY_TOO_LARGE );
BIND_CONSTANT( RESPONSE_REQUEST_URI_TOO_LONG );
BIND_CONSTANT( RESPONSE_UNSUPPORTED_MEDIA_TYPE );
BIND_CONSTANT( RESPONSE_REQUESTED_RANGE_NOT_SATISFIABLE );
BIND_CONSTANT( RESPONSE_EXPECTATION_FAILED );
BIND_CONSTANT( RESPONSE_UNPROCESSABLE_ENTITY );
BIND_CONSTANT( RESPONSE_LOCKED );
BIND_CONSTANT( RESPONSE_FAILED_DEPENDENCY );
BIND_CONSTANT( RESPONSE_UPGRADE_REQUIRED );
// 5xx server error
BIND_CONSTANT( RESPONSE_INTERNAL_SERVER_ERROR );
BIND_CONSTANT( RESPONSE_NOT_IMPLEMENTED );
BIND_CONSTANT( RESPONSE_BAD_GATEWAY );
BIND_CONSTANT( RESPONSE_SERVICE_UNAVAILABLE );
BIND_CONSTANT( RESPONSE_GATEWAY_TIMEOUT );
BIND_CONSTANT( RESPONSE_HTTP_VERSION_NOT_SUPPORTED );
BIND_CONSTANT( RESPONSE_INSUFFICIENT_STORAGE );
BIND_CONSTANT( RESPONSE_NOT_EXTENDED );
}
HTTPClient::HTTPClient(){
tcp_connection = StreamPeerTCP::create_ref();
resolving = IP::RESOLVER_INVALID_ID;
status=STATUS_DISCONNECTED;
conn_port=80;
body_size=0;
chunked=false;
body_left=0;
chunk_left=0;
response_num=0;
ssl=false;
blocking=false;
tmp_read.resize(4096);
}
HTTPClient::~HTTPClient(){
}