parser3/src/main/pa_http.C - diff

Return to pa_http.C CVS log

Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_http.C between versions 1.97 and 1.113

version 1.97, 2020/10/14 21:35:00	version 1.113, 2020/12/17 13:38:45
Line 1	Line 1
/** @file	/** @file
Parser: http support functions.	Parser: http support functions.

Copyright (c) 2001-2017 Art. Lebedev Studio (http://www.artlebedev.com)	Copyright (c) 2001-2020 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

Line 114 public:	Line 114 public:
}	}

bool read(int sock, size_t size){	bool read(int sock, size_t size){
if(length+size>buf_size)	if(length + size > buf_size)
resize(buf_size*2 + size);	resize(buf_size * 2 + size);
ssize_t received_size=recv(sock, buf + length, size, 0);	ssize_t received_size=recv(sock, buf + length, size, 0);
if(received_size==0)	if(received_size == 0)
return false;	return false;
if(received_size<0) {	if(received_size < 0) {
if(int no=pa_socks_errno())	if(int no = pa_socks_errno())
throw Exception("http.timeout", 0, "error receiving response body: %s (%d)", pa_socks_strerr(no), no);	throw Exception("http.timeout", 0, "error receiving response: %s (%d)", pa_socks_strerr(no), no);
return false;	return false;
}	}
length+=received_size;	length+=received_size;
Line 262 int HTTP_response::read_response(int soc	Line 262 int HTTP_response::read_response(int soc
#ifdef PA_USE_ALARM	#ifdef PA_USE_ALARM
static sigjmp_buf timeout_env;	static sigjmp_buf timeout_env;
static void timeout_handler(int /sig/){	static void timeout_handler(int /sig/){
siglongjmp(timeout_env, 1);	siglongjmp(timeout_env, 1);
}	}
	#define ALARM(value) alarm(value)
	#else
	#define ALARM(value)
#endif	#endif

static int http_request(HTTP_response& response, const char* host, short port, const char* request, size_t request_size, int timeout_secs, bool fail_on_status_ne_200) {	static int http_request(HTTP_response& response, const char* host, short port, const char* request, size_t request_size, int timeout_secs, bool fail_on_status_ne_200) {
if(!host)	if(!host)
throw Exception("http.host", 0, "zero hostname"); //never	throw Exception("http.host", 0, "zero hostname"); //never

volatile // to prevent makeing it register variable, because it will be clobbered by longjmp [thanks gcc warning]	volatile int sock=-1; // to prevent makeing it register variable, because it will be clobbered by longjmp [thanks gcc warning]
int sock=-1;
#ifdef PA_USE_ALARM
signal(SIGALRM, timeout_handler);
#endif
#ifdef PA_USE_ALARM	#ifdef PA_USE_ALARM
	signal(SIGALRM, timeout_handler);
if(sigsetjmp(timeout_env, 1)) {	if(sigsetjmp(timeout_env, 1)) {
// stupid gcc [2.95.4] generated bad code	// duplicating closesocket to make code more simple for old compilers
// which failed to handle sigsetjmp+throw: crashed inside of pre-throw code.	if(sock>=0)
// rewritten simplier [athough duplicating closesocket code]	closesocket(sock);
if(sock>=0)	throw Exception("http.timeout", 0, "timeout occurred while retrieving document");
closesocket(sock);
throw Exception("http.timeout", 0, "timeout occurred while retrieving document");
return 0; // never	return 0; // never
} else {	} else
alarm(timeout_secs);
#endif	#endif
	{
	ALARM(timeout_secs);
try {	try {
int result;	int result;
struct sockaddr_in dest;	struct sockaddr_in dest;
Line 325 static int http_request(HTTP_response& r	Line 325 static int http_request(HTTP_response& r

result=response.read_response(sock, fail_on_status_ne_200);	result=response.read_response(sock, fail_on_status_ne_200);
closesocket(sock);	closesocket(sock);
#ifdef PA_USE_ALARM	ALARM(0);
alarm(0);
#endif
return result;	return result;
} catch(...) {	} catch(...) {
#ifdef PA_USE_ALARM	ALARM(0);
alarm(0);
#endif
if(sock>=0)	if(sock>=0)
closesocket(sock);	closesocket(sock);
rethrow;	rethrow;
}	}
#ifdef PA_USE_ALARM
}	}
#endif
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 364 char *pa_http_safe_header_name(const cha	Line 358 char *pa_http_safe_header_name(const cha
return result;	return result;
}	}

static void http_pass_header(HashStringValue::key_type aname,	static void http_pass_header(HashStringValue::key_type aname, HashStringValue::value_type avalue, Http_pass_header_info *info) {
HashStringValue::value_type avalue,
Http_pass_header_info *info) {

const char* name_cstr=aname.cstr();	const char* name_cstr=aname.cstr();

Line 921 File_read_http_result pa_internal_file_r	Line 913 File_read_http_result pa_internal_file_r

/* ******************** httpd ************************* */	/* ******************** httpd ************************* */

	#ifdef HTTPD_DEBUG
	void pa_log(const char* fmt, ...);
	#define LOG(action) action
	#else
	#define LOG(action)
	#endif

	enum EscapeState {
	Initial,
	Default,
	EscapeFirst,
	EscapeSecond
	};

	static bool check_uri(const char *uri){
	EscapeState state=Initial;
	uint escapedValue;

	const char *pattern="/../";
	const char *pos=pattern;

	while(*uri){
	uchar c=(uchar)*(uri++);
	switch(state) {
	case Initial:
	if(c!='/')
	return false;
	state=Default;
	break;
	case Default:
	if(c=='%'){
	state=EscapeFirst;
	continue;
	}
	if(c=='?')
	return true;
	break;
	case EscapeFirst:
	if(isxdigit(c)){
	state=EscapeSecond;
	escapedValue=hex_value[c] << 4;
	continue;
	}
	return false;
	case EscapeSecond:
	if(isxdigit(c)){
	state=Default;
	c=(uchar)(escapedValue + hex_value[c]);

	// implementing Apache AllowEncodedSlashes Off just in case
	if(c=='/' \|\| c=='\\')
	return false;

	break;
	}
	return false;
	}

	if(c==pos \|\| c=='\\' && pos=='/'){
	if(!*(++pos))
	return false;
	} else {
	pos=pattern;
	}
	}
	return true;
	}

class HTTPD_request : public HTTP_response {	class HTTPD_request : public HTTP_response {
public:	public:
const char *method;	const char *method;
Line 928 public:	Line 988 public:

HTTPD_request() : HTTP_response(), method(NULL), uri(NULL){};	HTTPD_request() : HTTP_response(), method(NULL), uri(NULL){};

	ssize_t pa_recv(int sockfd, char *buf, size_t len);

	bool read(int sock, size_t size){
	if(length + size > buf_size)
	resize(buf_size * 2 + size);
	ssize_t received_size=pa_recv(sock, buf + length, size);
	if(received_size == 0)
	return false;
	if(received_size < 0) {
	if(int no = pa_socks_errno())
	throw Exception("httpd.read", 0, "error receiving request: %s (%d)", pa_socks_strerr(no), no);
	return false;
	}
	length+=received_size;
	buf[length]='\0';
	return true;
	}

const char extract_method(char method_line){	const char extract_method(char method_line){
char* uri_start = strchr(method_line, ' ');	char* uri_start = strchr(method_line, ' ');

Line 940 public:	Line 1018 public:
return NULL;	return NULL;

uri=pa_strdup(uri_start+1, uri_end-uri_start-1);	uri=pa_strdup(uri_start+1, uri_end-uri_start-1);
	if(!check_uri(uri))
	throw Exception("httpd.request", 0, "invalid uri '%s'", uri);

return str_upper(method_line, uri_start-method_line);	return str_upper(method_line, uri_start-method_line);
}	}

void read_header(int);
	bool read_header(int);
size_t read_post(int, char *, size_t);	size_t read_post(int, char *, size_t);
};	};

Line 952 enum HTTPD_request_state {	Line 1034 enum HTTPD_request_state {
HTTPD_HEADERS	HTTPD_HEADERS
};	};

void HTTPD_request::read_header(int sock) {	ssize_t HTTPD_request::pa_recv(int sockfd, char *buffer, size_t len){
	LOG(pa_log("httpd [%d] recv %d appending to %d ...", sockfd, len, length));
	if(HTTPD_Server::mode == HTTPD_Server::MULTITHREADED){
	ssize_t result=recv(sockfd, buffer, len, 0);
	LOG(pa_log("httpd [%d] recv got %d bytes", sockfd, result));
	return result;
	}

	#ifdef PA_USE_ALARM
	signal(SIGALRM, timeout_handler);
	if(sigsetjmp(timeout_env, 1)) {
	LOG(pa_log("httpd [%d] recv got %d sec timeout", sockfd, pa_httpd_timeout));
	if(length) // timeout on "void" connection is normal
	throw Exception("httpd.timeout", 0, "timeout occurred while receiving request");
	return 0;
	} else
	#endif
	{
	ALARM(pa_httpd_timeout);
	ssize_t result=recv(sockfd, buffer, len, 0);
	ALARM(0);
	LOG(pa_log("httpd [%d] recv got %d bytes", sockfd, result));
	LOG(pa_log("httpd [%d] %s", sockfd, buffer));
	return result;
	}
	}

	bool HTTPD_request::read_header(int sock) {
enum HTTPD_request_state state = HTTPD_METHOD;	enum HTTPD_request_state state = HTTPD_METHOD;

size_t chunk_size = 0x400*4;	size_t chunk_size = 0x400*4;
Line 985 void HTTPD_request::read_header(int sock	Line 1094 void HTTPD_request::read_header(int sock
break;	break;

parse_headers();	parse_headers();
return;	return true;
}	}
}	}
}	}

	if(!length){ // browsers open connections in advance and they will be empty unless user requests more pages
	LOG(pa_log("httpd [%d] void request", sock));
	return false;
	}

if(state == HTTPD_METHOD)	if(state == HTTPD_METHOD)
throw Exception("httpd.request", 0, "bad request from host - no method found (size=%u)", length);	throw Exception("httpd.request", 0, "bad request from host - no method found (size=%u)", length);

Line 997 void HTTPD_request::read_header(int sock	Line 1111 void HTTPD_request::read_header(int sock
parse_headers();	parse_headers();
body_offset=length;	body_offset=length;
}	}

	return true;
}	}

size_t HTTPD_request::read_post(int sock, char *body, size_t max_bytes) {	size_t HTTPD_request::read_post(int sock, char *body, size_t max_bytes) {
size_t total_read = min(length - body_offset, max_bytes);	size_t total_read = min(length - body_offset, max_bytes);
memcpy(body, buf, total_read);	memcpy(body, buf + body_offset, total_read);

while (total_read < max_bytes){	while (total_read < max_bytes){
ssize_t received_size = recv(sock, buf + total_read, max_bytes - total_read, 0);	ssize_t received_size = pa_recv(sock, body + total_read, max_bytes - total_read);
if(received_size == 0)	if(received_size == 0)
return total_read;	return total_read;
if(received_size < 0) {	if(received_size < 0) {
if(int no = pa_socks_errno())	if(int no = pa_socks_errno())
throw Exception("httpd.timeout", new String(uri), "error receiving request body: %s (%d)", pa_socks_strerr(no), no);	throw Exception("httpd.read", new String(uri), "error receiving request body: %s (%d)", pa_socks_strerr(no), no);
return total_read;	return total_read;
}	}
total_read += received_size;	total_read += received_size;
Line 1039 uint64_t HTTPD_Connection::content_lengt	Line 1155 uint64_t HTTPD_Connection::content_lengt
return request->headers.content_length;	return request->headers.content_length;
}	}

void HTTPD_Connection::read_header(){	bool HTTPD_Connection::read_header(){
request = new HTTPD_request();	request = new HTTPD_request();
request->read_header(sock);	bool result = request->read_header(sock);
	LOG(if(result){
	pa_log("httpd [%d] got %s \"%s\"", sock, method(), uri());
	})
	return result;
}	}

size_t HTTPD_Connection::read_post(char *body, size_t max_bytes) {	size_t HTTPD_Connection::read_post(char *body, size_t max_bytes) {
Line 1049 size_t HTTPD_Connection::read_post(char	Line 1169 size_t HTTPD_Connection::read_post(char
}	}

size_t HTTPD_Connection::send_body(const void *buf, size_t size) {	size_t HTTPD_Connection::send_body(const void *buf, size_t size) {
	LOG(pa_log("httpd [%d] response %d bytes", sock, size));
	LOG(pa_log("httpd [%d] %s", sock, buf));
if(send(sock, (const char*)buf, size, 0) != (ssize_t)size) {	if(send(sock, (const char*)buf, size, 0) != (ssize_t)size) {
int no=pa_socks_errno();	int no=pa_socks_errno();
throw Exception("httpd.timeout", 0, "error sending response: %s (%d)", pa_socks_strerr(no), no);	throw Exception("httpd.write", 0, "error sending response: %s (%d)", pa_socks_strerr(no), no);
}	}
return size;	return size;
}	}

HTTPD_Connection::~HTTPD_Connection(){	HTTPD_Connection::~HTTPD_Connection(){
if(sock != -1)	if(sock != -1){
	LOG(pa_log("httpd [%d] closed", sock));
closesocket(sock);	closesocket(sock);
	}
}	}

static int sock_ready(int fd,int operation,int timeout_value){	static int sock_ready(int fd,int operation,int timeout_value){
Line 1095 bool HTTPD_Connection::accept(int server	Line 1219 bool HTTPD_Connection::accept(int server
}	}

remote_addr = pa_strdup(inet_ntoa(addr.sin_addr));	remote_addr = pa_strdup(inet_ntoa(addr.sin_addr));
	LOG(pa_log("httpd [%d] accepted from %s", sock, remote_addr));
return true;	return true;
}	}

	HTTPD_Server::HTTPD_MODE HTTPD_Server::mode = HTTPD_Server::SEQUENTIAL;

	void HTTPD_Server::set_mode(const String &value){
	if(value == "sequental") mode = SEQUENTIAL;
	#ifdef HAVE_TLS
	else if (value == "threaded") mode = MULTITHREADED;
	#endif
	#ifdef _MSC_VER
	else throw Exception("httpd.mode", &value, "$main:HTTPD.mode must be 'sequental' or 'threaded'");
	#else
	else if (value == "parallel") mode = PARALLEL;
	else throw Exception("httpd.mode", &value, "$main:HTTPD.mode must be 'sequental', 'parallel' or 'threaded'");
	#endif
	}

int HTTPD_Server::bind(const char *host_port){	int HTTPD_Server::bind(const char *host_port){
struct sockaddr_in me;	struct sockaddr_in me;

Line 1110 int HTTPD_Server::bind(const char *host_	Line 1250 int HTTPD_Server::bind(const char *host_
port = host_port;	port = host_port;
}	}

if(!set_addr(&me, host, pa_atoui(port))){	if(!set_addr(&me, host, (short)pa_atoui(port))){
if (host)	if (host)
throw Exception("httpd.bind", 0, "can not resolve hostname \"%s\"", host);	throw Exception("httpd.bind", 0, "can not resolve hostname \"%s\"", host);
me.sin_addr.s_addr=INADDR_ANY;	me.sin_addr.s_addr=INADDR_ANY;

E-mail:

Removed from v.1.97
changed lines
	Added in v.1.113