parser3/src/classes/curl.C - diff

Return to curl.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/curl.C between versions 1.4 and 1.49

version 1.4, 2010/05/16 00:23:00	version 1.49, 2016/12/28 22:50:06
Line 1	Line 1
/** @file	/** @file
Parser: @b curl parser class.	Parser: @b curl parser class.

Copyright(c) 2001-2009 ArtLebedev Group(http://www.artlebedev.com)	Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com)
*/	*/

#include "pa_config_includes.h"	#include "pa_config_includes.h"

#ifdef HAVE_CURL

static const char * const IDENT_INET_C="$Date$";

#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
#include "pa_charsets.h"	#include "pa_charsets.h"
#include "pa_vstring.h"	#include "pa_vstring.h"
	#include "pa_vdate.h"
#include "pa_vtable.h"	#include "pa_vtable.h"
#include "pa_common.h"	#include "pa_common.h"
#include "ltdl.h"	#include "pa_http.h"
	#include "ltdl.h"

	volatile const char * IDENT_CURL_C="$Id$";

class MCurl: public Methoded {	class MCurl: public Methoded {
public:	public:
MCurl();	MCurl();

public: // Methoded
bool used_directly() { return true; }
};	};

// global variables	// global variables

DECLARE_CLASS_VAR(curl, new MCurl, 0);	DECLARE_CLASS_VAR(curl, new MCurl);

// from file.C
extern bool is_text_mode(const String& mode);

#include "curl.h"	#include "curl.h"

Line 50 typedef void (*t_curl_formfree)(struct c	Line 44 typedef void (*t_curl_formfree)(struct c
#define GLINK(name) f_##name=(t_##name)lt_dlsym(handle, #name);	#define GLINK(name) f_##name=(t_##name)lt_dlsym(handle, #name);
#define DLINK(name) GLINK(name) if(!f_##name) return "function " #name " was not found";	#define DLINK(name) GLINK(name) if(!f_##name) return "function " #name " was not found";

const char dlink(const char dlopen_file_spec) {	static const char dlink(const char dlopen_file_spec) {
if(lt_dlinit())	pa_dlinit();
return lt_dlerror();

lt_dlhandle handle=lt_dlopen(dlopen_file_spec);	lt_dlhandle handle=lt_dlopen(dlopen_file_spec);

Line 78 const char dlink(const char dlopen_fil	Line 71 const char dlink(const char dlopen_fil

class ParserOptions {	class ParserOptions {
public:	public:
const char *filename;	// real options
	const String *filename;
const String *content_type;	const String *content_type;
bool is_text;	bool is_text;
Charset charset, response_charset;	Charset charset, response_charset;

	// stuff for internal use
	const char *url;
struct curl_httppost *f_post;	struct curl_httppost *f_post;
	FILE *f_stderr;

ParserOptions() : filename(0), content_type(0), is_text(true), charset(0), response_charset(0), f_post(0){}	ParserOptions() : filename(0), content_type(0), is_text(true), charset(0), response_charset(0), url(0), f_post(0), f_stderr(0){}
~ParserOptions() {	~ParserOptions() {
f_curl_formfree(f_post);	f_curl_formfree(f_post);
	if(f_stderr)
	fclose(f_stderr);
}	}

};	};

// using thread local variables instead of keeping them in request	// using TLS instead of keeping variables in request
// not necessary for cgi version	THREAD_LOCAL CURL *fcurl = 0;
#ifdef WIN32	THREAD_LOCAL ParserOptions *foptions = 0;
#define __thread __declspec(thread)
#endif
__thread CURL *fcurl = 0;
__thread ParserOptions *foptions = 0;

static CURL *curl(){	static CURL *curl(){
if(!fcurl)	if(!fcurl)
Line 117 class Temp_curl {	Line 113 class Temp_curl {
ParserOptions *saved_options;	ParserOptions *saved_options;
public:	public:
Temp_curl() : saved_curl(fcurl), saved_options(foptions){	Temp_curl() : saved_curl(fcurl), saved_options(foptions){
fcurl = f_curl_easy_init();	fcurl = f_curl_easy_init();
foptions = new ParserOptions();	foptions = new ParserOptions();
f_curl_easy_setopt(fcurl, CURLOPT_POSTFIELDSIZE, 0); // fix libcurl bug	f_curl_easy_setopt(fcurl, CURLOPT_POSTFIELDSIZE, 0); // fix libcurl bug
	f_curl_easy_setopt(fcurl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4); // avoid ipv6 by default
}	}
~Temp_curl() {	~Temp_curl() {
f_curl_easy_cleanup(fcurl);	f_curl_easy_cleanup(fcurl);
Line 130 public:	Line 127 public:
};	};

bool curl_linked = false;	bool curl_linked = false;
#ifdef WIN32
const char *curl_library="libcurl.dll";
#else
const char *curl_library="libcurl.so";
#endif

const char *curl_status = 0;	const char *curl_status = 0;
	const char *curl_library="libcurl" LT_MODULE_EXT;

static void temp_curl(void (*action)(Request&, MethodParams&), Request& r, MethodParams& params){	static void temp_curl(void (*action)(Request&, MethodParams&), Request& r, MethodParams& params){
if(!curl_linked){	if(!curl_linked)
curl_linked=true;
curl_status=dlink(curl_library);	curl_status=dlink(curl_library);
}

if(curl_status == 0){	if(curl_status == 0){
	curl_linked=true;
Temp_curl temp_curl;	Temp_curl temp_curl;
action(r,params);	action(r,params);
} else {	} else {
Line 161 static void _curl_session(Request& r, Me	Line 152 static void _curl_session(Request& r, Me
temp_curl(_curl_session_action, r, params);	temp_curl(_curl_session_action, r, params);
}	}

static void _curl_version_action(Request& r, MethodParams& params){	static void _curl_version_action(Request& r, MethodParams& ){
r.write_no_lang(new VString(new String(f_curl_version(), String::L_TAINTED)));	r.write(new VString(new String(f_curl_version(), String::L_TAINTED)));
}	}

static void _curl_version(Request& r, MethodParams& params){	static void _curl_version(Request& r, MethodParams& params){
fcurl ? _curl_version_action(r, params) : temp_curl(_curl_version_action, r, params);	fcurl ? _curl_version_action(r, params) : temp_curl(_curl_version_action, r, params);
}	}

static char str_lower(const char str){
char *result=pa_strdup(str);
for(char* c=result; *c; c++)
c=(char)tolower((unsigned char)c);
return result;
}

static char str_upper(const char str){
char *result=pa_strdup(str);
for(char* c=result; *c; c++)
c=(char)toupper((unsigned char)c);
return result;
}

class CurlOption {	class CurlOption {
public:	public:

Line 195 public:	Line 172 public:
CURL_FORM,	CURL_FORM,
CURL_HEADERS,	CURL_HEADERS,
CURL_FILE,	CURL_FILE,
	CURL_STDERR,
PARSER_LIBRARY,	PARSER_LIBRARY,
PARSER_NAME,	PARSER_NAME,
PARSER_CONTENT_TYPE,	PARSER_CONTENT_TYPE,
Line 218 public:	Line 196 public:
CURL_OPT(CURL_INT, LOCALPORT);	CURL_OPT(CURL_INT, LOCALPORT);
CURL_OPT(CURL_INT, PORT);	CURL_OPT(CURL_INT, PORT);

	CURL_OPT(CURL_INT, VERBOSE);
	CURL_OPT(CURL_STDERR, STDERR);
	CURL_OPT(CURL_INT, MAXFILESIZE);

CURL_OPT(CURL_INT, HTTPAUTH);	CURL_OPT(CURL_INT, HTTPAUTH);
CURL_OPT(CURL_STRING, USERPWD);	CURL_OPT(CURL_STRING, USERPWD);

#ifdef CURLOPT_USERNAME
CURL_OPT(CURL_STRING, USERNAME);	CURL_OPT(CURL_STRING, USERNAME);
CURL_OPT(CURL_STRING, PASSWORD);	CURL_OPT(CURL_STRING, PASSWORD);
#endif

CURL_OPT(CURL_URLENCODE, USERAGENT);	CURL_OPT(CURL_URLENCODE, USERAGENT);
CURL_OPT(CURL_URLENCODE, REFERER);	CURL_OPT(CURL_URLENCODE, REFERER);
CURL_OPT(CURL_INT, AUTOREFERER);	CURL_OPT(CURL_INT, AUTOREFERER);

CURL_OPT(CURL_STRING, ENCODING); // gzip or deflate	CURL_OPT(CURL_STRING, ENCODING); // gzip or deflate
	CURL_OPT(CURL_STRING, ACCEPT_ENCODING); // gzip or deflate

CURL_OPT(CURL_INT, FOLLOWLOCATION);	CURL_OPT(CURL_INT, FOLLOWLOCATION);
CURL_OPT(CURL_INT, UNRESTRICTED_AUTH);	CURL_OPT(CURL_INT, UNRESTRICTED_AUTH);
	CURL_OPT(CURL_INT, IPRESOLVE);

CURL_OPT(CURL_INT, POST);	CURL_OPT(CURL_INT, POST);
CURL_OPT(CURL_INT, HTTPGET);	CURL_OPT(CURL_INT, HTTPGET);
Line 283 public:	Line 267 public:
CURL_OPT(CURL_STRING, SSLENGINE);	CURL_OPT(CURL_STRING, SSLENGINE);
CURL_OPT(CURL_STRING, SSLENGINE_DEFAULT);	CURL_OPT(CURL_STRING, SSLENGINE_DEFAULT);

#ifdef CURLOPT_ISSUERCERT
CURL_OPT(CURL_FILE, ISSUERCERT);	CURL_OPT(CURL_FILE, ISSUERCERT);
#endif

#ifdef CURLOPT_CRLFILE
CURL_OPT(CURL_FILE, CRLFILE);	CURL_OPT(CURL_FILE, CRLFILE);
#endif

CURL_OPT(CURL_STRING, CAINFO);	CURL_OPT(CURL_STRING, CAINFO);
CURL_OPT(CURL_STRING, CAPATH);	CURL_OPT(CURL_FILE, CAPATH);
CURL_OPT(CURL_INT, SSL_VERIFYPEER);	CURL_OPT(CURL_INT, SSL_VERIFYPEER);
CURL_OPT(CURL_INT, SSL_VERIFYHOST);	CURL_OPT(CURL_INT, SSL_VERIFYHOST);
CURL_OPT(CURL_STRING, SSL_CIPHER_LIST);	CURL_OPT(CURL_STRING, SSL_CIPHER_LIST);
CURL_OPT(CURL_INT, SSL_SESSIONID_CACHE);	CURL_OPT(CURL_INT, SSL_SESSIONID_CACHE);
	CURL_OPT(CURL_INT, SSLVERSION);

PARSER_OPT(PARSER_LIBRARY, "library");	PARSER_OPT(PARSER_LIBRARY, "library");
PARSER_OPT(PARSER_NAME, "name");	PARSER_OPT(PARSER_NAME, "name");
Line 308 public:	Line 288 public:

} *curl_options=0;	} *curl_options=0;

	class CurlInfo {
	public:

	enum OptionType {
	CURL_STRING,
	CURL_INT,
	CURL_DOUBLE
	};

	CURLINFO id;
	OptionType type;
	CurlInfo(CURLINFO aid, OptionType atype): id(aid), type(atype) {}
	};

	class CurlInfoHash: public HashString<CurlInfo*> {
	public:
	CurlInfoHash() {
	#define CURL_INF(type, name) put(str_lower(#name),new CurlInfo(CURLINFO_##name, CurlInfo::type));
	CURL_INF(CURL_DOUBLE, APPCONNECT_TIME);
	CURL_INF(CURL_DOUBLE, CONNECT_TIME);
	CURL_INF(CURL_DOUBLE, CONTENT_LENGTH_DOWNLOAD);
	CURL_INF(CURL_DOUBLE, CONTENT_LENGTH_UPLOAD);
	CURL_INF(CURL_STRING, CONTENT_TYPE);
	CURL_INF(CURL_STRING, EFFECTIVE_URL);
	CURL_INF(CURL_INT, HEADER_SIZE);
	CURL_INF(CURL_INT, HTTPAUTH_AVAIL);
	CURL_INF(CURL_DOUBLE, NAMELOOKUP_TIME);
	CURL_INF(CURL_INT, NUM_CONNECTS);
	CURL_INF(CURL_INT, OS_ERRNO);
	CURL_INF(CURL_DOUBLE, PRETRANSFER_TIME);
	CURL_INF(CURL_STRING, PRIMARY_IP);
	CURL_INF(CURL_INT, PROXYAUTH_AVAIL);
	CURL_INF(CURL_INT, REDIRECT_COUNT);
	CURL_INF(CURL_DOUBLE, REDIRECT_TIME);
	CURL_INF(CURL_STRING, REDIRECT_URL);
	CURL_INF(CURL_INT, REQUEST_SIZE);
	CURL_INF(CURL_INT, RESPONSE_CODE);
	CURL_INF(CURL_DOUBLE, SIZE_DOWNLOAD);
	CURL_INF(CURL_DOUBLE, SIZE_UPLOAD);
	CURL_INF(CURL_DOUBLE, SPEED_DOWNLOAD);
	CURL_INF(CURL_DOUBLE, SPEED_UPLOAD);
	CURL_INF(CURL_INT, SSL_VERIFYRESULT);
	CURL_INF(CURL_DOUBLE, STARTTRANSFER_TIME);
	CURL_INF(CURL_DOUBLE, TOTAL_TIME);
	}

	} *curl_infos=0;

static const char *curl_urlencode(const String &s, Request& r){	static const char *curl_urlencode(const String &s, Request& r){
if(options().charset){	if(options().charset){
Temp_client_charset temp(r.charsets, *options().charset);	Temp_client_charset temp(r.charsets, *options().charset);
Line 321 static struct curl_slist *curl_headers(H	Line 349 static struct curl_slist *curl_headers(H

for(HashStringValue::Iterator i(*value_hash); i; i.next() ){	for(HashStringValue::Iterator i(*value_hash); i; i.next() ){
String header =	String header =
String(capitalize(i.key().cstr()), String::L_URI)	String(pa_http_safe_header_name(capitalize(i.key().cstr())), String::L_AS_IS)
<< ": "	<< ": "
<< String(i.value()->as_string(), String::L_URI);	<< String(i.value()->as_string(), String::L_HTTP_HEADER);

slist=f_curl_slist_append(slist, curl_urlencode(header, r));	slist=f_curl_slist_append(slist, curl_urlencode(header, r));
}	}
Line 367 static void curl_form(HashStringValue *v	Line 395 static void curl_form(HashStringValue *v
}	}
}	}

	static const char *curl_check_file(const String &file_spec){
	const char *file_spec_cstr=file_spec.taint_cstr(String::L_FILE_SPEC);
	struct stat finfo;
	if(pa_stat(file_spec_cstr, &finfo)==0)
	check_safe_mode(finfo, file_spec, file_spec_cstr);
	return file_spec_cstr;
	}

static void curl_setopt(HashStringValue::key_type key, HashStringValue::value_type value, Request& r) {	static void curl_setopt(HashStringValue::key_type key, HashStringValue::value_type value, Request& r) {
CurlOption *opt=curl_options->get(key);	CurlOption *opt=curl_options->get(key);

Line 374 static void curl_setopt(HashStringValue:	Line 410 static void curl_setopt(HashStringValue:
throw Exception("curl", 0, "called with invalid option '%s'", key.cstr());	throw Exception("curl", 0, "called with invalid option '%s'", key.cstr());

CURLcode res = CURLE_OK;	CURLcode res = CURLE_OK;
Value &v=r.process_to_value(*value);	Value &v=r.process(*value);

switch (opt->type){	switch (opt->type){
case CurlOption::CURL_STRING:{	case CurlOption::CURL_STRING:{
Line 391 static void curl_setopt(HashStringValue:	Line 427 static void curl_setopt(HashStringValue:
}	}
case CurlOption::CURL_URL:{	case CurlOption::CURL_URL:{
// url-encoded string curl_url option	// url-encoded string curl_url option
const String url = v.as_string();	const String url = v.as_string();
if(!url.starts_with("http://") && !url.starts_with("https://"))	if(!url.starts_with("http://") && !url.starts_with("https://"))
throw Exception("curl", 0, "failed to set option '%s': invalid url scheme '%s'", key.cstr(), url.cstr());	throw Exception("curl", 0, "failed to set option '%s': invalid url scheme '%s'", key.cstr(), url.cstr());
const char *value_str=curl_urlencode(url, r);	options().url=curl_urlencode(url, r);
res=f_curl_easy_setopt(curl(), opt->id, value_str);	res=f_curl_easy_setopt(curl(), opt->id, options().url);
break;	break;
}	}
case CurlOption::CURL_INT:{	case CurlOption::CURL_INT:{
Line 417 static void curl_setopt(HashStringValue:	Line 453 static void curl_setopt(HashStringValue:
break;	break;
}	}
case CurlOption::CURL_FORM:{	case CurlOption::CURL_FORM:{
HashStringValue *value_hash = v.get_hash();	HashStringValue *value_hash = v.as_hash("failed to set option 'httppost': value");
if(value_hash){	if(value_hash){
curl_form(value_hash, r);	curl_form(value_hash, r);
} else if(v.get_string()->is_empty()){	} else {
f_curl_formfree(options().f_post);	f_curl_formfree(options().f_post);
options().f_post = 0;	options().f_post = 0;
} else {	}
throw Exception("curl", 0, "%s must be a hash", key.cstr());
}
res=f_curl_easy_setopt(curl(), CURLOPT_HTTPPOST, foptions->f_post);	res=f_curl_easy_setopt(curl(), CURLOPT_HTTPPOST, foptions->f_post);
break;	break;
}	}
case CurlOption::CURL_HEADERS:{	case CurlOption::CURL_HEADERS:{
// http headers curl option	// http headers curl option
HashStringValue *value_hash=v.get_hash();	HashStringValue *value_hash=v.as_hash("failed to set option 'httpheader': value");
res=f_curl_easy_setopt(curl(), opt->id, value_hash ? curl_headers(value_hash, r) : 0);	res=f_curl_easy_setopt(curl(), opt->id, value_hash ? curl_headers(value_hash, r) : 0);
break;	break;
}	}
case CurlOption::CURL_FILE:{	case CurlOption::CURL_FILE:{
// file-spec curl option	// file-spec curl option
const char *value_str=r.absolute(v.as_string()).taint_cstr(String::L_FILE_SPEC);	const char *file_spec_cstr=curl_check_file(r.absolute(v.as_string()));
res=f_curl_easy_setopt(curl(), opt->id, value_str);	res=f_curl_easy_setopt(curl(), opt->id, file_spec_cstr);
	break;
	}
	case CurlOption::CURL_STDERR:{
	// verbose output redirection from stderr to file curl option
	const char *file_spec_cstr=curl_check_file(r.absolute(v.as_string()));
	FILE *f_stderr=options().f_stderr=fopen(file_spec_cstr, "wt");
	if (f_stderr){
	res=f_curl_easy_setopt(curl(), opt->id, f_stderr);
	} else {
	throw Exception("curl", 0, "failed to set option '%s': unable to open file '%s'", key.cstr(), file_spec_cstr);
	}
break;	break;
}	}
case CurlOption::PARSER_LIBRARY:{	case CurlOption::PARSER_LIBRARY:{
// 'library' parser option	// 'library' parser option
if(fcurl==0){	if(!curl_linked){
curl_library=v.as_string().taint_cstr(String::L_FILE_SPEC);	curl_library=v.as_string().taint_cstr(String::L_FILE_SPEC);
} else	} else
throw Exception("curl", 0, "failed to set option '%s': %s", key.cstr(), "already loaded");	throw Exception("curl", 0, "failed to set option '%s': already loaded", key.cstr());
break;	break;
}	}
case CurlOption::PARSER_NAME:{	case CurlOption::PARSER_NAME:{
// 'name' parser option	// 'name' parser option
options().filename=v.as_string().taint_cstr(String::L_FILE_SPEC);	options().filename=&v.as_string();
break;	break;
}	}
case CurlOption::PARSER_CONTENT_TYPE:{	case CurlOption::PARSER_CONTENT_TYPE:{
Line 461 static void curl_setopt(HashStringValue:	Line 506 static void curl_setopt(HashStringValue:
}	}
case CurlOption::PARSER_MODE:{	case CurlOption::PARSER_MODE:{
// 'mode' parser option	// 'mode' parser option
options().is_text=is_text_mode(v.as_string());	options().is_text=VFile::is_text_mode(v.as_string());
break;	break;
}	}
case CurlOption::PARSER_CHARSET:{	case CurlOption::PARSER_CHARSET:{
// 'charset' parser option	// 'charset' parser option should be processed before other options
options().charset=&::charsets.get(v.as_string().change_case(r.charsets.source(), String::CC_UPPER));
break;	break;
}	}
case CurlOption::PARSER_RESPONSE_CHARSET:{	case CurlOption::PARSER_RESPONSE_CHARSET:{
// 'charset' parser option	// 'response-charset' parser option
options().response_charset=&::charsets.get(v.as_string().change_case(r.charsets.source(), String::CC_UPPER));	options().response_charset=&pa_charsets.get(v.as_string());
break;	break;
}	}
}	}
Line 484 static void _curl_options(Request& r, Me	Line 528 static void _curl_options(Request& r, Me
if(curl_options==0)	if(curl_options==0)
curl_options=new CurlOptionHash();	curl_options=new CurlOptionHash();

if(HashStringValue* options=params.as_no_junction(0, OPTIONS_MUST_NOT_BE_CODE).get_hash()){	if(HashStringValue* options_hash=params.as_hash(0)){
options->for_each<Request&>(curl_setopt, r);	if(Value* value=options_hash->get("charset")){
} else	// charset should be handled first as params may require transcode
throw Exception("curl", 0, "options must be hash");	Value &v=r.process(*value);
	options().charset=&pa_charsets.get(v.as_string());
	}
	options_hash->for_each<Request&>(curl_setopt, r);
	}
	}

	#define CURL_GETINFO(arg) \
	if((res=f_curl_easy_getinfo(curl(), info->id, &arg)) != CURLE_OK){ \
	throw Exception("curl", 0, "failed to get %s info: %s", key.cstr(), f_curl_easy_strerror(res)); \
	}

	static Value curl_getinfo(const String::Body &key, CurlInfo info=0) {
	if(info==0 && !(info=curl_infos->get(key)))
	throw Exception("curl", 0, "called with invalid parameter '%s'", key.cstr());

	CURLcode res;
	switch (info->type){
	case CurlInfo::CURL_STRING:{
	char *str=0;
	CURL_GETINFO(str);
	return new VString(str ? *new String(pa_strdup(str), String::L_TAINTED) : String::Empty);
	}
	case CurlInfo::CURL_INT:{
	long l=0;
	CURL_GETINFO(l);
	return new VInt(l);
	}
	case CurlInfo::CURL_DOUBLE:{
	double d=0;
	CURL_GETINFO(d);
	return new VDouble(d);
	}
	}
	return VVoid::get();
	}

	static void _curl_info(Request& r, MethodParams& params){
	if(curl_infos==0)
	curl_infos=new CurlInfoHash();
	if(params.count()==1){
	const String &name=params.as_string(0, "name must be string");
	r.write(*curl_getinfo(name));
	} else {
	VHash& result=*new VHash;
	for(CurlInfoHash::Iterator i(*curl_infos); i; i.next() ){
	result.get_hash()->put(i.key(), curl_getinfo(i.key(), i.value()));
	}
	r.write(result);
	}
}	}


Line 516 static int curl_writer(char *data, size_	Line 609 static int curl_writer(char *data, size_
return size;	return size;
}	}

static int curl_header(char data, size_t size, size_t nmemb, HASH_STRING<char > *result){	static int curl_header(char data, size_t size, size_t nmemb, ResponseHeaders result){
if(result == 0)	if(result == 0)
return 0;	return 0;

size=size*nmemb;	size=size*nmemb;
if(size>0){	if(size>0){
char *line=pa_strdup(data, size);	char *header=pa_strdup(data, size);
char *value=lsplit(line,':');	if(!pa_strncasecmp(header, "HTTP/") && !strchr(header, ':')){
if(value && *line){	// response code, clearing possible headers from previous requests
// we need only headers, not the response code	result->clear();
result->put(str_upper(line), value);	} else {
	result->add_header(header);
}	}
}	}
return size;	return size;
Line 548 static void _curl_load_action(Request& r	Line 642 static void _curl_load_action(Request& r
CURL_SETOPT(CURLOPT_WRITEDATA, &body, "curl write buffer");	CURL_SETOPT(CURLOPT_WRITEDATA, &body, "curl write buffer");

// we need a container for headers as VFile fields can be put only after VFile.set	// we need a container for headers as VFile fields can be put only after VFile.set
HASH_STRING<char *> headers;	ResponseHeaders response;
CURL_SETOPT(CURLOPT_HEADERFUNCTION, curl_header, "curl header function");	CURL_SETOPT(CURLOPT_HEADERFUNCTION, curl_header, "curl header function");
CURL_SETOPT(CURLOPT_WRITEHEADER, &headers, "curl header buffer");	CURL_SETOPT(CURLOPT_WRITEHEADER, &response, "curl header buffer");

if((res=f_curl_easy_perform(curl())) != CURLE_OK){	if((res=f_curl_easy_perform(curl())) != CURLE_OK){
char *ex_type = 0;	const char *ex_type = 0;
switch(res){	switch(res){
case CURLE_OPERATION_TIMEDOUT:	case CURLE_OPERATION_TIMEDOUT:
ex_type = "curl.timeout"; break;	ex_type = "curl.timeout"; break;
Line 569 static void _curl_load_action(Request& r	Line 663 static void _curl_load_action(Request& r
case CURLE_SSL_CACERT:	case CURLE_SSL_CACERT:
case CURLE_SSL_ENGINE_INITFAILED:	case CURLE_SSL_ENGINE_INITFAILED:
ex_type = "curl.ssl"; break;	ex_type = "curl.ssl"; break;
	default: break;
}	}
throw Exception( ex_type ? ex_type : "curl.fail", 0, "%s", f_curl_easy_strerror(res));	throw Exception( PA_DEFAULT(ex_type, "curl.fail"), 0, "%s", f_curl_easy_strerror(res));
}	}

// assure trailing zero	// assure trailing zero
body.buf[body.length]=0;	body.buf[body.length]=0;

Value* vcontent_type=
options().content_type ? new VString(*options().content_type) :
options().filename ? new VString(r.mime_type_of(options().filename)) : 0;

VFile& result=*new VFile;	VFile& result=*new VFile;

String::Body ct_header = headers.get(HTTP_CONTENT_TYPE_UPPER);	Charset *asked_charset = options().response_charset;
Charset *remote_charset = ct_header.is_empty() ? 0 : detect_charset(ct_header.trim(String::TRIM_BOTH, " \t\n\r").cstr());	if (!asked_charset && !response.content_type.is_empty())
Charset *asked_charset = options().response_charset ? options().response_charset : (remote_charset ? remote_charset : options().charset);	asked_charset=detect_charset(response.content_type.cstr());

	if(options().is_text)
	asked_charset=pa_charsets.checkBOM(body.buf, body.length, asked_charset);

	if (!asked_charset)
	asked_charset = options().charset;

if(options().is_text && asked_charset != 0){	if(options().is_text && asked_charset != 0){
String::C c=Charset::transcode(String::C(body.buf, body.length), *asked_charset, r.charsets.source());	String::C c=Charset::transcode(String::C(body.buf, body.length), *asked_charset, r.charsets.source());
Line 592 static void _curl_load_action(Request& r	Line 689 static void _curl_load_action(Request& r
body.length=c.length;	body.length=c.length;
}	}

result.set(true /tainted/, body.buf, body.length, options().filename, vcontent_type);	const String *content_type = PA_DEFAULT(options().content_type, response.content_type.is_empty() ? 0 : new String(response.content_type, String::L_TAINTED));
result.set_mode(options().is_text);	const String *filename = PA_DEFAULT(options().filename, new String(options().url));

	result.set(true/tainted/, options().is_text, body.buf, body.length, filename, content_type ? new VString(*content_type) : 0, &r);

long http_status = 0;	long http_status = 0;
if(f_curl_easy_getinfo(curl(), CURLINFO_RESPONSE_CODE, &http_status) == CURLE_OK){	if(f_curl_easy_getinfo(curl(), CURLINFO_RESPONSE_CODE, &http_status) == CURLE_OK){
result.fields().put("status", new VInt(http_status));	result.fields().put("status", new VInt(http_status));
}	}

for(HASH_STRING<char *>::Iterator i(headers); i; i.next() ){	VHash* vtables=new VHash;
String::Body key=i.key();	result.fields().put("tables", vtables);
String::Body value=i.value();
if(asked_charset){	for(Array_iterator<ResponseHeaders::Header> i(response.headers); i.has_next(); ){
key=Charset::transcode(key, *asked_charset, r.charsets.source());	ResponseHeaders::Header header=i.next();
value=Charset::transcode(value, *asked_charset, r.charsets.source());
}	if(asked_charset)
result.fields().put(key, new VString(*new String(value.trim(String::TRIM_BOTH, " \t\n\r"), String::L_TAINTED)));	header.transcode(*asked_charset, r.charsets.source());

	String &header_value=*new String(header.value, String::L_TAINTED);

	tables_update(vtables->hash(), header.name, header_value);
	result.fields().put(header.name, new VString(header_value));
}	}

r.write_no_lang(result);	// filling $.cookies
	if(Value *vcookies=vtables->hash().get("SET-COOKIE"))
	result.fields().put(HTTP_COOKIES_NAME, new VTable(parse_cookies(r, vcookies->get_table())));

	r.write(result);
}	}

static void _curl_load(Request& r, MethodParams& params){	static void _curl_load(Request& r, MethodParams& params){
Line 622 MCurl::MCurl(): Methoded("curl") {	Line 730 MCurl::MCurl(): Methoded("curl") {
add_native_method("session", Method::CT_STATIC, _curl_session, 1, 1);	add_native_method("session", Method::CT_STATIC, _curl_session, 1, 1);
add_native_method("version", Method::CT_STATIC, _curl_version, 0, 0);	add_native_method("version", Method::CT_STATIC, _curl_version, 0, 0);
add_native_method("options", Method::CT_STATIC, _curl_options, 1, 1);	add_native_method("options", Method::CT_STATIC, _curl_options, 1, 1);
	add_native_method("info", Method::CT_STATIC, _curl_info, 0, 1);
add_native_method("load", Method::CT_STATIC, _curl_load, 0, 1);	add_native_method("load", Method::CT_STATIC, _curl_load, 0, 1);
}	}

#else // HAVE_CURL

#include "classes.h"
// global variable
DECLARE_CLASS_VAR(curl, 0, 0); // fictive

#endif // HAVE_CURL

E-mail:

Removed from v.1.4
changed lines
	Added in v.1.49