long aur_login(void) {
long code, ret = 0;
CURLcode status;
struct curl_httppost *post, *last;
struct curl_slist *headers;
static struct write_result response;
post = last = NULL;
headers = NULL;
response.memory = NULL;
response.size = 0;
curl_formadd(&post, &last,
CURLFORM_COPYNAME, AUR_LOGIN_FIELD,
CURLFORM_COPYCONTENTS, config->user, CURLFORM_END);
curl_formadd(&post, &last,
CURLFORM_COPYNAME, AUR_PASSWD_FIELD,
CURLFORM_COPYCONTENTS, config->password, CURLFORM_END);
if (config->persist) {
curl_formadd(&post, &last,
CURLFORM_COPYNAME, AUR_REMEMBERME_FIELD,
CURLFORM_COPYCONTENTS, "on", CURLFORM_END);
}
headers = curl_slist_append(headers, "Expect:");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_response);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
curl_easy_setopt(curl, CURLOPT_URL, AUR_LOGIN_URL);
if (config->verbose > 0) {
printf("Logging in to AUR as user %s\n", config->user);
}
status = curl_easy_perform(curl);
if(status != 0) {
fprintf(stderr, "curl error: unable to send data to %s\n", AUR_LOGIN_URL);
fprintf(stderr, "%s\n", curl_easy_strerror(status));
ret = status;
goto cleanup;
}
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if(code != 200) {
fprintf(stderr, "curl error: server responded with code %ld\n", code);
ret = code;
goto cleanup;
}
if (config->verbose > 1) {
printf("%s\n", response.memory);
}
if (strstr(response.memory, AUR_LOGIN_FAIL_MSG) != NULL) {
fprintf(stderr, "Error: %s\n", AUR_LOGIN_FAIL_MSG);
ret = 1L; /* Reuse an uncommon curl error */
}
cleanup:
free(response.memory);
curl_slist_free_all(headers);
curl_formfree(post);
/* We're done using the password. Overwrite its memory */
config->password = memset(config->password, 42, strlen(config->password));
return(ret);
}
/* test function */
int test(char *URL)
{
int res;
CURLSHcode scode;
char *url;
struct Tdata tdata;
CURL *curl;
CURLSH *share;
struct curl_slist *headers;
int i;
struct userdata user;
user.text = (char *)"Pigs in space";
user.counter = 0;
printf( "GLOBAL_INIT\n" );
curl_global_init( CURL_GLOBAL_ALL );
/* prepare share */
printf( "SHARE_INIT\n" );
share = curl_share_init();
curl_share_setopt( share, CURLSHOPT_LOCKFUNC, lock);
curl_share_setopt( share, CURLSHOPT_UNLOCKFUNC, unlock);
curl_share_setopt( share, CURLSHOPT_USERDATA, &user);
printf( "CURL_LOCK_DATA_COOKIE\n" );
curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
printf( "CURL_LOCK_DATA_DNS\n" );
curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
res = 0;
/* start treads */
for (i=1; i<=THREADS; i++ )
{
/* set thread data */
tdata.url = suburl( URL, i ); /* must be freed */
tdata.share = share;
/* simulate thread, direct call of "thread" function */
printf( "*** run %d\n",i );
fire( &tdata );
free( tdata.url );
}
/* fetch a another one and save cookies */
printf( "*** run %d\n", i );
curl = curl_easy_init();
url = suburl( URL, i );
headers = sethost( NULL );
curl_easy_setopt( curl, CURLOPT_HTTPHEADER, (void*)headers );
curl_easy_setopt( curl, CURLOPT_URL, url );
printf( "CURLOPT_SHARE\n" );
curl_easy_setopt( curl, CURLOPT_SHARE, share );
printf( "CURLOPT_COOKIEJAR\n" );
curl_easy_setopt( curl, CURLOPT_COOKIEJAR, JAR );
printf( "PERFORM\n" );
curl_easy_perform( curl );
/* try to free share, expect to fail because share is in use*/
printf( "try SHARE_CLEANUP...\n" );
scode = curl_share_cleanup( share );
if ( scode==CURLSHE_OK )
{
fprintf(stderr, "curl_share_cleanup succeed but error expected\n");
share = NULL;
}
else
{
printf( "SHARE_CLEANUP failed, correct\n" );
}
/* clean up last handle */
printf( "CLEANUP\n" );
curl_easy_cleanup( curl );
curl_slist_free_all( headers );
free(url);
/* free share */
printf( "SHARE_CLEANUP\n" );
scode = curl_share_cleanup( share );
if ( scode!=CURLSHE_OK )
{
fprintf(stderr, "curl_share_cleanup failed, code errno %d\n", scode);
}
printf( "GLOBAL_CLEANUP\n" );
curl_global_cleanup();
return res;
}
int main(int argc, char **argv)
{
CURL *curl;
CURLcode res;
FILE *hd_src;
struct stat file_info;
curl_off_t fsize;
struct curl_slist *headerlist=NULL;
static const char buf_1 [] = "RNFR " UPLOAD_FILE_AS;
static const char buf_2 [] = "RNTO " RENAME_FILE_TO;
/* get the file size of the local file */
if(stat(LOCAL_FILE, &file_info)) {
printf("Couldnt open '%s': %s\n", LOCAL_FILE, strerror(errno));
return 1;
}
fsize = (curl_off_t)file_info.st_size;
printf("Local file size: %" CURL_FORMAT_CURL_OFF_T " bytes.\n", fsize);
/* get a FILE * of the same file */
hd_src = fopen(LOCAL_FILE, "rb");
/* In windows, this will init the winsock stuff */
curl_global_init(CURL_GLOBAL_ALL);
/* get a curl handle */
curl = curl_easy_init();
if(curl) {
/* build a list of commands to pass to libcurl */
headerlist = curl_slist_append(headerlist, buf_1);
headerlist = curl_slist_append(headerlist, buf_2);
/* we want to use our own read function */
curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* specify target */
curl_easy_setopt(curl,CURLOPT_URL, REMOTE_URL);
/* pass in that last of FTP commands to run after the transfer */
curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist);
/* now specify which file to upload */
curl_easy_setopt(curl, CURLOPT_READDATA, hd_src);
/* Set the size of the file to upload (optional). If you give a *_LARGE
option you MUST make sure that the type of the passed-in argument is a
curl_off_t. If you use CURLOPT_INFILESIZE (without _LARGE) you must
make sure that to pass in a type 'long' argument. */
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE,
(curl_off_t)fsize);
/* Now run off and do what you've been told! */
res = curl_easy_perform(curl);
/* clean up the FTP commands list */
curl_slist_free_all (headerlist);
/* always cleanup */
curl_easy_cleanup(curl);
}
fclose(hd_src); /* close the local file */
curl_global_cleanup();
return 0;
}
/* test function */
int test(char *URL)
{
int res;
CURLSHcode scode = CURLSHE_OK;
char *url = NULL;
struct Tdata tdata;
CURL *curl;
CURLSH *share;
struct curl_slist *headers = NULL;
int i;
struct userdata user;
user.text = (char *)"Pigs in space";
user.counter = 0;
printf( "GLOBAL_INIT\n" );
if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
/* prepare share */
printf( "SHARE_INIT\n" );
if ((share = curl_share_init()) == NULL) {
fprintf(stderr, "curl_share_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
if ( CURLSHE_OK == scode ) {
printf( "CURLSHOPT_LOCKFUNC\n" );
scode = curl_share_setopt( share, CURLSHOPT_LOCKFUNC, my_lock);
}
if ( CURLSHE_OK == scode ) {
printf( "CURLSHOPT_UNLOCKFUNC\n" );
scode = curl_share_setopt( share, CURLSHOPT_UNLOCKFUNC, my_unlock);
}
if ( CURLSHE_OK == scode ) {
printf( "CURLSHOPT_USERDATA\n" );
scode = curl_share_setopt( share, CURLSHOPT_USERDATA, &user);
}
if ( CURLSHE_OK == scode ) {
printf( "CURL_LOCK_DATA_COOKIE\n" );
scode = curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
}
if ( CURLSHE_OK == scode ) {
printf( "CURL_LOCK_DATA_DNS\n" );
scode = curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
}
if ( CURLSHE_OK != scode ) {
fprintf(stderr, "curl_share_setopt() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
/* initial cookie manipulation */
if ((curl = curl_easy_init()) == NULL) {
fprintf(stderr, "curl_easy_init() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
printf( "CURLOPT_SHARE\n" );
test_setopt( curl, CURLOPT_SHARE, share );
printf( "CURLOPT_COOKIELIST injected_and_clobbered\n" );
test_setopt( curl, CURLOPT_COOKIELIST,
"Set-Cookie: injected_and_clobbered=yes; "
"domain=host.foo.com; expires=Sat Feb 2 11:56:27 GMT 2030" );
printf( "CURLOPT_COOKIELIST ALL\n" );
test_setopt( curl, CURLOPT_COOKIELIST, "ALL" );
printf( "CURLOPT_COOKIELIST session\n" );
test_setopt( curl, CURLOPT_COOKIELIST, "Set-Cookie: session=elephants" );
printf( "CURLOPT_COOKIELIST injected\n" );
test_setopt( curl, CURLOPT_COOKIELIST,
"Set-Cookie: injected=yes; domain=host.foo.com; "
"expires=Sat Feb 2 11:56:27 GMT 2030" );
printf( "CURLOPT_COOKIELIST SESS\n" );
test_setopt( curl, CURLOPT_COOKIELIST, "SESS" );
printf( "CLEANUP\n" );
curl_easy_cleanup( curl );
res = 0;
/* start treads */
for (i=1; i<=THREADS; i++ ) {
/* set thread data */
tdata.url = suburl( URL, i ); /* must be curl_free()d */
tdata.share = share;
/* simulate thread, direct call of "thread" function */
printf( "*** run %d\n",i );
fire( &tdata );
curl_free( tdata.url );
}
/* fetch a another one and save cookies */
printf( "*** run %d\n", i );
if ((curl = curl_easy_init()) == NULL) {
fprintf(stderr, "curl_easy_init() failed\n");
curl_share_cleanup(share);
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
url = suburl( URL, i );
headers = sethost( NULL );
test_setopt( curl, CURLOPT_HTTPHEADER, headers );
test_setopt( curl, CURLOPT_URL, url );
printf( "CURLOPT_SHARE\n" );
test_setopt( curl, CURLOPT_SHARE, share );
printf( "CURLOPT_COOKIEJAR\n" );
test_setopt( curl, CURLOPT_COOKIEJAR, JAR );
printf( "CURLOPT_COOKIELIST FLUSH\n" );
test_setopt( curl, CURLOPT_COOKIELIST, "FLUSH" );
printf( "PERFORM\n" );
curl_easy_perform( curl );
/* try to free share, expect to fail because share is in use*/
printf( "try SHARE_CLEANUP...\n" );
scode = curl_share_cleanup( share );
if ( scode==CURLSHE_OK )
{
fprintf(stderr, "curl_share_cleanup succeed but error expected\n");
share = NULL;
} else {
printf( "SHARE_CLEANUP failed, correct\n" );
}
test_cleanup:
/* clean up last handle */
printf( "CLEANUP\n" );
curl_easy_cleanup( curl );
if ( headers )
curl_slist_free_all( headers );
if ( url )
curl_free(url);
/* free share */
printf( "SHARE_CLEANUP\n" );
scode = curl_share_cleanup( share );
if ( scode!=CURLSHE_OK )
fprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
(int)scode);
printf( "GLOBAL_CLEANUP\n" );
curl_global_cleanup();
return res;
}
json_t* authRequest(Parameters& params, std::string url, std::string request, std::string options) {
// nonce
struct timeval tv;
gettimeofday(&tv, NULL);
unsigned long long nonce = (tv.tv_sec * 1000.0) + (tv.tv_usec * 0.001) + 0.5;
// check if options parameter is empty
std::ostringstream oss;
if (options.empty()) {
oss << "{\"request\":\"/v1/" << request << "\",\"nonce\":\"" << nonce << "\"}";
}
else {
oss << "{\"request\":\"/v1/" << request << "\",\"nonce\":\"" << nonce << "\", " << options << "}";
}
std::string tmpPayload = base64_encode(reinterpret_cast<const unsigned char*>(oss.str().c_str()), oss.str().length());
oss.clear();
oss.str("");
oss << "X-GEMINI-PAYLOAD:" << tmpPayload;
std::string payload;
payload = oss.str();
oss.clear();
oss.str("");
// build the signature
unsigned char* digest;
// Using sha384 hash engine
digest = HMAC(EVP_sha384(), params.geminiSecret.c_str(), strlen(params.geminiSecret.c_str()), (unsigned char*)tmpPayload.c_str(), strlen(tmpPayload.c_str()), NULL, NULL);
char mdString[SHA384_DIGEST_LENGTH+100]; // FIXME +100
for (int i = 0; i < SHA384_DIGEST_LENGTH; ++i) {
sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);
}
oss.clear();
oss.str("");
oss << "X-GEMINI-SIGNATURE:" << mdString;
// cURL headers
struct curl_slist *headers = NULL;
std::string api = "X-GEMINI-APIKEY:" + std::string(params.geminiApi);
headers = curl_slist_append(headers, api.c_str());
headers = curl_slist_append(headers, payload.c_str());
headers = curl_slist_append(headers, oss.str().c_str());
// cURL request
CURLcode resCurl;
// curl = curl_easy_init();
if (params.curl) {
std::string readBuffer;
curl_easy_setopt(params.curl, CURLOPT_POST, 1L);
// curl_easy_setopt(params.curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(params.curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(params.curl, CURLOPT_POSTFIELDS, "");
curl_easy_setopt(params.curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(params.curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(params.curl, CURLOPT_WRITEDATA, &readBuffer);
curl_easy_setopt(params.curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(params.curl, CURLOPT_CONNECTTIMEOUT, 10L);
resCurl = curl_easy_perform(params.curl);
json_t *root;
json_error_t error;
while (resCurl != CURLE_OK) {
*params.logFile << "<Gemini> Error with cURL. Retry in 2 sec..." << std::endl;
sleep(2.0);
readBuffer = "";
resCurl = curl_easy_perform(params.curl);
}
root = json_loads(readBuffer.c_str(), 0, &error);
while (!root) {
*params.logFile << "<Gemini> Error with JSON:\n" << error.text << std::endl;
*params.logFile << "<Gemini> Buffer:\n" << readBuffer.c_str() << std::endl;
*params.logFile << "<Gemini> Retrying..." << std::endl;
sleep(2.0);
readBuffer = "";
resCurl = curl_easy_perform(params.curl);
while (resCurl != CURLE_OK) {
*params.logFile << "<Gemini> Error with cURL. Retry in 2 sec..." << std::endl;
sleep(2.0);
readBuffer = "";
resCurl = curl_easy_perform(params.curl);
}
root = json_loads(readBuffer.c_str(), 0, &error);
}
curl_slist_free_all(headers);
curl_easy_reset(params.curl);
return root;
}
else {
*params.logFile << "<Gemini> Error with cURL init." << std::endl;
return NULL;
}
}
GString* http_post_stream_upload(http* h, const gchar* url, goffset len, http_data_fn read_cb, gpointer user_data, GError** err)
{
struct curl_slist* headers = NULL;
glong http_status = 0;
GString* response;
CURLcode res;
struct _stream_data data;
g_return_val_if_fail(h != NULL, NULL);
g_return_val_if_fail(url != NULL, NULL);
g_return_val_if_fail(err == NULL || *err == NULL, NULL);
http_no_expect(h);
// setup post headers and url
curl_easy_setopt(h->curl, CURLOPT_POST, 1L);
curl_easy_setopt(h->curl, CURLOPT_URL, url);
// setup request post body writer
http_set_content_length(h, len);
curl_easy_setopt(h->curl, CURLOPT_POSTFIELDSIZE_LARGE, len);
data.cb = read_cb;
data.user_data = user_data;
curl_easy_setopt(h->curl, CURLOPT_READFUNCTION, (curl_read_callback)curl_read);
curl_easy_setopt(h->curl, CURLOPT_READDATA, &data);
// prepare buffer for the response body
response = g_string_sized_new(512);
curl_easy_setopt(h->curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)append_gstring);
curl_easy_setopt(h->curl, CURLOPT_WRITEDATA, response);
g_hash_table_foreach(h->headers, (GHFunc)add_header, &headers);
curl_easy_setopt(h->curl, CURLOPT_HTTPHEADER, headers);
// perform HTTP request
res = curl_easy_perform(h->curl);
// check the result
if (res == CURLE_OK)
{
if (curl_easy_getinfo(h->curl, CURLINFO_RESPONSE_CODE, &http_status) == CURLE_OK)
{
if (http_status == 200)
{
goto out;
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "Server returned %ld", http_status);
}
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "Can't get http status code");
}
}
else if (res == CURLE_GOT_NOTHING)
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_NO_RESPONSE, "CURL error: %s", curl_easy_strerror(res));
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "CURL error: %s", curl_easy_strerror(res));
}
g_string_free(response, TRUE);
response = NULL;
out:
curl_easy_setopt(h->curl, CURLOPT_HTTPHEADER, NULL);
curl_slist_free_all(headers);
if (response)
return response;
return NULL;
}
json_t *json_rpc_call(CURL *curl, const char *url,
const char *userpass, const char *rpc_req,
bool longpoll_scan, bool longpoll, int *curl_err)
{
json_t *val, *err_val, *res_val;
int rc;
struct data_buffer all_data = {0};
struct upload_buffer upload_data;
json_error_t err;
struct curl_slist *headers = NULL;
char len_hdr[64];
char curl_err_str[CURL_ERROR_SIZE];
long timeout = longpoll ? opt_timeout : 30;
struct header_info hi = {0};
bool lp_scanning = longpoll_scan && !have_longpoll;
/* it is assumed that 'curl' is freshly [re]initialized at this pt */
if (opt_protocol)
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
curl_easy_setopt(curl, CURLOPT_URL, url);
if (opt_cert)
curl_easy_setopt(curl, CURLOPT_CAINFO, opt_cert);
curl_easy_setopt(curl, CURLOPT_ENCODING, "");
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, all_data_cb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &all_data);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, upload_data_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &upload_data);
#if LIBCURL_VERSION_NUM >= 0x071200
curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, &seek_data_cb);
curl_easy_setopt(curl, CURLOPT_SEEKDATA, &upload_data);
#endif
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_err_str);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, resp_hdr_cb);
curl_easy_setopt(curl, CURLOPT_HEADERDATA, &hi);
if (opt_proxy) {
curl_easy_setopt(curl, CURLOPT_PROXY, opt_proxy);
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, opt_proxy_type);
}
if (userpass) {
curl_easy_setopt(curl, CURLOPT_USERPWD, userpass);
curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
}
#if LIBCURL_VERSION_NUM >= 0x070f06
if (longpoll)
curl_easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, sockopt_keepalive_cb);
#endif
curl_easy_setopt(curl, CURLOPT_POST, 1);
if (opt_protocol)
applog(LOG_DEBUG, "JSON protocol request:\n%s\n", rpc_req);
upload_data.buf = rpc_req;
upload_data.len = strlen(rpc_req);
upload_data.pos = 0;
sprintf(len_hdr, "Content-Length: %lu",
(unsigned long) upload_data.len);
headers = curl_slist_append(headers, "Content-Type: application/json");
headers = curl_slist_append(headers, len_hdr);
headers = curl_slist_append(headers, "User-Agent: " USER_AGENT);
headers = curl_slist_append(headers, "X-Mining-Extensions: midstate");
headers = curl_slist_append(headers, "Accept:"); /* disable Accept hdr*/
headers = curl_slist_append(headers, "Expect:"); /* disable Expect hdr*/
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
rc = curl_easy_perform(curl);
if (curl_err != NULL)
*curl_err = rc;
if (rc) {
if (!(longpoll && rc == CURLE_OPERATION_TIMEDOUT))
applog(LOG_ERR, "HTTP request failed: %s", curl_err_str);
goto err_out;
}
/* If X-Stratum was found, activate Stratum */
if (want_stratum && hi.stratum_url &&
!strncasecmp(hi.stratum_url, "stratum+tcp://", 14)) {
have_stratum = true;
tq_push(thr_info[stratum_thr_id].q, hi.stratum_url);
hi.stratum_url = NULL;
}
/* If X-Long-Polling was found, activate long polling */
if (lp_scanning && hi.lp_path && !have_stratum) {
have_longpoll = true;
tq_push(thr_info[longpoll_thr_id].q, hi.lp_path);
hi.lp_path = NULL;
}
if (!all_data.buf) {
applog(LOG_ERR, "Empty data received in json_rpc_call.");
goto err_out;
}
val = JSON_LOADS(all_data.buf, &err);
if (!val) {
applog(LOG_ERR, "JSON decode failed(%d): %s", err.line, err.text);
goto err_out;
}
if (opt_protocol) {
char *s = json_dumps(val, JSON_INDENT(3));
applog(LOG_DEBUG, "JSON protocol response:\n%s", s);
free(s);
}
/* JSON-RPC valid response returns a non-null 'result',
* and a null 'error'. */
res_val = json_object_get(val, "result");
err_val = json_object_get(val, "error");
if (!res_val || json_is_null(res_val) ||
(err_val && !json_is_null(err_val))) {
char *s;
if (err_val)
s = json_dumps(err_val, JSON_INDENT(3));
else
s = strdup("(unknown reason)");
applog(LOG_ERR, "JSON-RPC call failed: %s", s);
free(s);
goto err_out;
}
if (hi.reason)
json_object_set_new(val, "reject-reason", json_string(hi.reason));
databuf_free(&all_data);
curl_slist_free_all(headers);
curl_easy_reset(curl);
return val;
err_out:
free(hi.lp_path);
free(hi.reason);
free(hi.stratum_url);
databuf_free(&all_data);
curl_slist_free_all(headers);
curl_easy_reset(curl);
return NULL;
}
int DownLoad(char *url, DownloadInfo *downloadInfo) {
CURL *curl;
CURLcode res;
curl = curl_easy_init();
char* get_url;
if (curl) {
downloadInfo->SetCurl(curl);
struct curl_slist *chunk = NULL;
int src_url_length = strlen(url);
if (downloadInfo->check_is_tempfile_exits()) {
char *bytes = NULL;
bytes = FileLengthToString(downloadInfo->GetDownloadedSize());
char *header = new char[12 + strlen(bytes) + 2];
strcpy_s(header, 13, "Range:bytes=");
strcat_s(header, strlen(header) + strlen(bytes) + 1, bytes);
strcat_s(header, strlen(header) + 2, "-");
chunk = curl_slist_append(chunk, header);
delete[] bytes;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
get_url = new char[src_url_length + 17];
strcpy_s(get_url, src_url_length + 1, url);
strcat_s(get_url, src_url_length + 17, "&resume_flg=true");
Log(_T("开始断点下载 %d"), downloadInfo->GetDownloadedSize());
} else {
downloadInfo->create_temp_file();
get_url = new char[src_url_length + 1];
strcpy_s(get_url, src_url_length + 1, url);
}
curl_easy_setopt(curl, CURLOPT_URL, get_url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, downloadInfo);
curl_easy_setopt(curl, CURLOPT_HEADERDATA, downloadInfo);
curl_easy_setopt(curl, CURLOPT_HEADER, 0);
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_callback);
curl_easy_setopt(curl, CURLOPT_NOBODY, FALSE);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 30);//连接超时10S
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, FALSE);
if (downloadInfo->downloadType == 0) {
curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, xferinfo);
curl_easy_setopt(curl, CURLOPT_XFERINFODATA, downloadInfo);
} else {
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, xferinfo);
curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, downloadInfo);
}
is_get_header = false;
res = curl_easy_perform(curl);
if (res == CURLE_OK) {
curl_easy_cleanup(curl);
if (chunk)
curl_slist_free_all(chunk);
delete get_url;
return 1;
} else {
TCHAR * error = CharToWchar_New(curl_easy_strerror(res));
Log(_T("下载出错，error：%s %d"), error, res);
delete[] error;
if (res == CURLE_RECV_ERROR)
is_need_reload = true;
}
curl_easy_cleanup(curl);
if (chunk)
curl_slist_free_all(chunk);
delete get_url;
return 0;
}
return 0;
}
int
post(post_state_t *state,
const char *url,
const char *content_type,
const char **additional_headers,
const char *data,
off_t data_size)
{
CURLcode curl_err;
long response_code;
post_state_t localstate;
VERB3 log("%s('%s','%s')", __func__, url, data);
if (!state)
{
memset(&localstate, 0, sizeof(localstate));
state = &localstate;
}
state->curl_result = state->http_resp_code = response_code = -1;
CURL *handle = xcurl_easy_init();
// Buffer[CURL_ERROR_SIZE] curl stores human readable error messages in.
// This may be more helpful than just return code from curl_easy_perform.
// curl will need it until curl_easy_cleanup.
state->errmsg[0] = '\0';
xcurl_easy_setopt_ptr(handle, CURLOPT_ERRORBUFFER, state->errmsg);
// Shut off the built-in progress meter completely
xcurl_easy_setopt_long(handle, CURLOPT_NOPROGRESS, 1);
if (g_verbose >= 2)
{
// "Display a lot of verbose information about its operations.
// Very useful for libcurl and/or protocol debugging and understanding.
// The verbose information will be sent to stderr, or the stream set
// with CURLOPT_STDERR"
xcurl_easy_setopt_long(handle, CURLOPT_VERBOSE, 1);
xcurl_easy_setopt_ptr(handle, CURLOPT_DEBUGFUNCTION, curl_debug);
}
// TODO: do we need to check for CURLE_URL_MALFORMAT error *here*,
// not in curl_easy_perform?
xcurl_easy_setopt_ptr(handle, CURLOPT_URL, url);
// Auth if configured
if (state->username)
{
// bitmask of allowed auth methods
xcurl_easy_setopt_long(handle, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
xcurl_easy_setopt_ptr(handle, CURLOPT_USERNAME, state->username);
xcurl_easy_setopt_ptr(handle, CURLOPT_PASSWORD, (state->password ? state->password : ""));
}
if (data_size != POST_DATA_FROMFILE_PUT)
{
// Do a HTTP POST. This also makes curl use
// a "Content-Type: application/x-www-form-urlencoded" header.
// (This is by far the most commonly used POST method).
xcurl_easy_setopt_long(handle, CURLOPT_POST, 1);
}
// else (only POST_DATA_FROMFILE_PUT): do HTTP PUT.
struct curl_httppost *post = NULL;
struct curl_httppost *last = NULL;
FILE *data_file = NULL;
FILE *body_stream = NULL;
struct curl_slist *httpheader_list = NULL;
// Supply data...
if (data_size == POST_DATA_FROMFILE
|| data_size == POST_DATA_FROMFILE_PUT
) {
// ...from a file
data_file = fopen(data, "r");
if (!data_file)
{
perror_msg("Can't open '%s'", data);
goto ret; // return -1
}
xcurl_easy_setopt_ptr(handle, CURLOPT_READDATA, data_file);
// Want to use custom read function
xcurl_easy_setopt_ptr(handle, CURLOPT_READFUNCTION, (const void*)fread_with_reporting);
fseeko(data_file, 0, SEEK_END);
off_t sz = ftello(data_file);
fseeko(data_file, 0, SEEK_SET);
if (data_size == POST_DATA_FROMFILE)
{
// Without this, curl would send "Content-Length: -1"
// servers don't like that: "413 Request Entity Too Large"
xcurl_easy_setopt_off_t(handle, CURLOPT_POSTFIELDSIZE_LARGE, sz);
}
else
{
xcurl_easy_setopt_long(handle, CURLOPT_UPLOAD, 1);
xcurl_easy_setopt_off_t(handle, CURLOPT_INFILESIZE_LARGE, sz);
}
}
else if (data_size == POST_DATA_FROMFILE_AS_FORM_DATA)
{
// ...from a file, in multipart/formdata format
const char *basename = strrchr(data, '/');
if (basename) basename++;
else basename = data;
#if 0
// Simple way, without custom reader function
CURLFORMcode curlform_err = curl_formadd(&post, &last,
CURLFORM_PTRNAME, "file", // element name
CURLFORM_FILE, data, // filename to read from
CURLFORM_CONTENTTYPE, content_type,
CURLFORM_FILENAME, basename, // filename to put in the form
CURLFORM_END);
#else
data_file = fopen(data, "r");
if (!data_file)
{
perror_msg("Can't open '%s'", data);
goto ret; // return -1
}
// Want to use custom read function
xcurl_easy_setopt_ptr(handle, CURLOPT_READFUNCTION, (const void*)fread_with_reporting);
// Need to know file size
fseeko(data_file, 0, SEEK_END);
off_t sz = ftello(data_file);
fseeko(data_file, 0, SEEK_SET);
// Create formdata
CURLFORMcode curlform_err = curl_formadd(&post, &last,
CURLFORM_PTRNAME, "file", // element name
// use CURLOPT_READFUNCTION for reading, pass data_file as its last param:
CURLFORM_STREAM, data_file,
CURLFORM_CONTENTSLENGTH, (long)sz, // a must if we use CURLFORM_STREAM option
//FIXME: what if file size doesn't fit in long?
CURLFORM_CONTENTTYPE, content_type,
CURLFORM_FILENAME, basename, // filename to put in the form
CURLFORM_END);
#endif
if (curlform_err != 0)
//FIXME:
error_msg_and_die("out of memory or read error (curl_formadd error code: %d)", (int)curlform_err);
xcurl_easy_setopt_ptr(handle, CURLOPT_HTTPPOST, post);
}
else if (data_size == POST_DATA_STRING_AS_FORM_DATA)
{
CURLFORMcode curlform_err = curl_formadd(&post, &last,
CURLFORM_PTRNAME, "file", // element name
// curl bug - missing filename
// http://curl.haxx.se/mail/lib-2011-07/0176.html
// https://github.com/bagder/curl/commit/45d883d
// fixed in curl-7.22.0~144
// tested with curl-7.24.0-3
// should be working on F17
CURLFORM_BUFFER, "*buffer*", // provides filename
CURLFORM_BUFFERPTR, data,
CURLFORM_BUFFERLENGTH, (long)strlen(data),
//FIXME: what if file size doesn't fit in long?
CURLFORM_CONTENTTYPE, content_type,
CURLFORM_END);
if (curlform_err != 0)
error_msg_and_die("out of memory or read error (curl_formadd error code: %d)", (int)curlform_err);
xcurl_easy_setopt_ptr(handle, CURLOPT_HTTPPOST, post);
}
else
{
// ...from a blob in memory
xcurl_easy_setopt_ptr(handle, CURLOPT_POSTFIELDS, data);
// note1: if data_size == POST_DATA_STRING == -1, curl will use strlen(data)
xcurl_easy_setopt_long(handle, CURLOPT_POSTFIELDSIZE, data_size);
// We don't use CURLOPT_POSTFIELDSIZE_LARGE because
// I'm not sure CURLOPT_POSTFIELDSIZE_LARGE special-cases -1.
// Not a big problem: memory blobs >4GB are very unlikely.
}
// Override "Content-Type:"
if (data_size != POST_DATA_FROMFILE_AS_FORM_DATA
&& data_size != POST_DATA_STRING_AS_FORM_DATA)
{
char *content_type_header = xasprintf("Content-Type: %s", content_type);
// Note: curl_slist_append() copies content_type_header
httpheader_list = curl_slist_append(httpheader_list, content_type_header);
if (!httpheader_list)
error_msg_and_die("out of memory");
free(content_type_header);
}
for (; additional_headers && *additional_headers; additional_headers++)
{
httpheader_list = curl_slist_append(httpheader_list, *additional_headers);
if (!httpheader_list)
error_msg_and_die("out of memory");
}
// Add User-Agent: ABRT/N.M
httpheader_list = curl_slist_append(httpheader_list, "User-Agent: ABRT/"VERSION);
if (!httpheader_list)
error_msg_and_die("out of memory");
if (httpheader_list)
xcurl_easy_setopt_ptr(handle, CURLOPT_HTTPHEADER, httpheader_list);
// Disabled: was observed to also handle "305 Use proxy" redirect,
// apparently with POST->GET remapping - which server didn't like at all.
// Attempted to suppress remapping on 305 using CURLOPT_POSTREDIR of -1,
// but it still did not work.
#if 0
// Please handle 301/302 redirects for me
xcurl_easy_setopt_long(handle, CURLOPT_FOLLOWLOCATION, 1);
xcurl_easy_setopt_long(handle, CURLOPT_MAXREDIRS, 10);
// Bitmask to control how libcurl acts on redirects after POSTs.
// Bit 0 set (value CURL_REDIR_POST_301) makes libcurl
// not convert POST requests into GET requests when following
// a 301 redirection. Bit 1 (value CURL_REDIR_POST_302) makes libcurl
// maintain the request method after a 302 redirect.
// CURL_REDIR_POST_ALL is a convenience define that sets both bits.
// The non-RFC behaviour is ubiquitous in web browsers, so the library
// does the conversion by default to maintain consistency.
// However, a server may require a POST to remain a POST.
xcurl_easy_setopt_long(handle, CURLOPT_POSTREDIR, -1L /*CURL_REDIR_POST_ALL*/ );
#endif
// Prepare for saving information
if (state->flags & POST_WANT_HEADERS)
{
xcurl_easy_setopt_ptr(handle, CURLOPT_HEADERFUNCTION, (void*)save_headers);
xcurl_easy_setopt_ptr(handle, CURLOPT_WRITEHEADER, state);
}
if (state->flags & POST_WANT_BODY)
{
body_stream = open_memstream(&state->body, &state->body_size);
if (!body_stream)
error_msg_and_die("out of memory");
xcurl_easy_setopt_ptr(handle, CURLOPT_WRITEDATA, body_stream);
}
if (!(state->flags & POST_WANT_SSL_VERIFY))
{
xcurl_easy_setopt_long(handle, CURLOPT_SSL_VERIFYPEER, 0);
xcurl_easy_setopt_long(handle, CURLOPT_SSL_VERIFYHOST, 0);
}
// This is the place where everything happens.
// Here errors are not limited to "out of memory", can't just die.
state->curl_result = curl_err = curl_easy_perform_with_proxy(handle, url);
if (curl_err)
{
VERB2 log("curl_easy_perform: error %d", (int)curl_err);
if (state->flags & POST_WANT_ERROR_MSG)
{
state->curl_error_msg = check_curl_error(curl_err, "curl_easy_perform");
VERB3 log("curl_easy_perform: error_msg: %s", state->curl_error_msg);
}
goto ret;
}
// curl-7.20.1 doesn't do it, we get NULL body in the log message below
// unless we fflush the body memstream ourself
if (body_stream)
fflush(body_stream);
// Headers/body are already saved (if requested), extract more info
curl_err = curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response_code);
die_if_curl_error(curl_err);
state->http_resp_code = response_code;
VERB3 log("after curl_easy_perform: response_code:%ld body:'%s'", response_code, state->body);
ret:
curl_easy_cleanup(handle);
if (httpheader_list)
curl_slist_free_all(httpheader_list);
if (body_stream)
fclose(body_stream);
if (data_file)
fclose(data_file);
if (post)
curl_formfree(post);
return response_code;
}
int gretl_curl (const char *url, const char *header,
const char *postdata, int include,
char **output, char **errmsg)
{
CURL *curl;
struct curl_slist *hlist = NULL;
struct GetBuf getbuf = {
output, /* pointer to buffer */
0 /* bytes written */
};
CURLcode res;
int err = 0;
err = gretl_curl_toggle(1);
if (err) {
return err;
}
curl = curl_easy_init();
if (curl == NULL) {
gretl_errmsg_set("curl_easy_init failed");
return 1;
}
if (header != NULL) {
hlist = curl_slist_append(hlist, header);
}
if (getenv("GRETL_WWW_VERBOSE") != NULL) {
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &getbuf);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_bufwrite);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
if (include) {
curl_easy_setopt(curl, CURLOPT_HEADER, 1);
}
if (hlist != NULL) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hlist);
}
if (postdata != NULL) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (void *) postdata);
}
if (wproxy && *proxyhost != '\0') {
curl_easy_setopt(curl, CURLOPT_PROXY, proxyhost);
}
res = curl_easy_perform(curl);
if (res != CURLE_OK) {
const char *cmsg = curl_easy_strerror(res);
gretl_errmsg_sprintf("cURL error %d (%s)", res, cmsg);
if (*output != NULL) {
free(*output);
*output = NULL;
}
if (errmsg != NULL) {
*errmsg = gretl_strdup(cmsg);
}
err = E_DATA;
}
if (hlist != NULL) {
curl_slist_free_all(hlist);
}
curl_easy_cleanup(curl);
return err;
}
int main(int argc, char *argv[])
{
CURL *curl;
CURLcode res;
struct curl_httppost *formpost=NULL;
struct curl_httppost *lastptr=NULL;
struct curl_slist *headerlist=NULL;
static const char buf[] = "Expect:";
curl_global_init(CURL_GLOBAL_ALL);
/* Fill in the file upload field */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "sendfile",
CURLFORM_FILE, "postit2.c",
CURLFORM_END);
/* Fill in the filename field */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "filename",
CURLFORM_COPYCONTENTS, "postit2.c",
CURLFORM_END);
/* Fill in the submit field too, even if this is rarely needed */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "submit",
CURLFORM_COPYCONTENTS, "send",
CURLFORM_END);
curl = curl_easy_init();
/* initalize custom header list (stating that Expect: 100-continue is not
wanted */
headerlist = curl_slist_append(headerlist, buf);
if(curl) {
/* what URL that receives this POST */
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/examplepost.cgi");
if ( (argc == 2) && (!strcmp(argv[1], "noexpectheader")) )
/* only disable 100-continue header if explicitly requested */
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
/* Check for errors */
if(res != CURLE_OK)
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
/* always cleanup */
curl_easy_cleanup(curl);
/* then cleanup the formpost chain */
curl_formfree(formpost);
/* free slist */
curl_slist_free_all (headerlist);
}
return 0;
}
int8_t
http_send_message(char *msg_out, char **msg_in)
{
CURLcode res;
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, msg_out);
http_c.header_list = NULL;
http_c.header_list = curl_slist_append(http_c.header_list, "Accept:");
if (!http_c.header_list) return -1;
http_c.header_list = curl_slist_append(http_c.header_list, "User-Agent: easycwmp");
if (!http_c.header_list) return -1;
http_c.header_list = curl_slist_append(http_c.header_list, "Content-Type: text/html; charset=utf-8");
if (!http_c.header_list) return -1;
if (config->acs->http100continue_disable) {
http_c.header_list = curl_slist_append(http_c.header_list, "Expect:");
if (!http_c.header_list) return -1;
}
if (msg_out) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) strlen(msg_out));
http_c.header_list = curl_slist_append(http_c.header_list, "SOAPAction;");
if (!http_c.header_list) return -1;
}
else {
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
}
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_c.header_list);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, msg_in);
*msg_in = (char *) calloc (1, sizeof(char));
res = curl_easy_perform(curl);
if (http_c.header_list) {
curl_slist_free_all(http_c.header_list);
http_c.header_list = NULL;
}
if (!strlen(*msg_in)) {
FREE(*msg_in);
}
long httpCode = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
if (res || (httpCode != 200 && httpCode != 204)) {
log_message(NAME, L_NOTICE, "sending http message failed\n");
return -1;
}
if (*msg_in) {
DDF("+++ RECEIVED HTTP RESPONSE +++\n");
DDF("%s", *msg_in);
DDF("--- RECEIVED HTTP RESPONSE ---\n");
} else {
DDF("+++ RECEIVED EMPTY HTTP RESPONSE +++\n");
}
return 0;
}
//Process POST Request
int processPostTask(CCHttpRequest *request, write_callback callback, void *stream, int32_t *responseCode)
{
CURLcode code = CURL_LAST;
CURL *curl = curl_easy_init();
do {
if (!configureCURL(curl)) {
break;
}
/* handle custom header data */
/* create curl linked list */
struct curl_slist *cHeaders=NULL;
/* get custom header data (if set) */
std::vector<std::string> headers=request->getHeaders();
if(!headers.empty())
{
for(std::vector<std::string>::iterator it=headers.begin();it!=headers.end();it++)
{
/* append custom headers one by one */
cHeaders=curl_slist_append(cHeaders,it->c_str());
}
/* set custom headers for curl */
code = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, cHeaders);
if (code != CURLE_OK) {
break;
}
}
code = curl_easy_setopt(curl, CURLOPT_URL, request->getUrl());
if (code != CURLE_OK) {
break;
}
code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, callback);
if (code != CURLE_OK) {
break;
}
code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, stream);
if (code != CURLE_OK) {
break;
}
code = curl_easy_setopt(curl, CURLOPT_POST, 1);
if (code != CURLE_OK) {
break;
}
code = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request->getRequestData());
if (code != CURLE_OK) {
break;
}
code = curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, request->getRequestDataSize());
if (code != CURLE_OK) {
break;
}
code = curl_easy_perform(curl);
if (code != CURLE_OK) {
break;
}
/* free the linked list for header data */
curl_slist_free_all(cHeaders);
code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, responseCode);
if (code != CURLE_OK || *responseCode != 200) {
code = CURLE_HTTP_RETURNED_ERROR;
}
} while (0);
if (curl) {
curl_easy_cleanup(curl);
}
return (code == CURLE_OK ? 0 : 1);
}
int Service::HttpRequest( const string http_method,
const string url,
const HTTPDATA* lpHttpData,
const vector<string> custom_headers,
Service* lpService )
{
// string resp_buffer; // body of the response from the server
char *memblock = NULL; // file size of POST body
// curl_global_init( CURL_GLOBAL_ALL ); //不可放线程内
CURL *curl = curl_easy_init();
this->Set_share_handle(curl);
char errorBuffer[CURL_ERROR_SIZE] = {0};
if ( curl )
{
if( !m_proxyIp.empty())
{
//curl_easy_setopt(curl,CURLOPT_HTTPPROXYTUNNEL, TRUE);
//curl_easy_setopt(curl, CURLOPT_PROXY, "https://183.141.72.153:3128");
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP); //使用http代理模式
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT,60);
curl_easy_setopt(curl, CURLOPT_PROXY, m_proxyIp.c_str() );
}
//curl_easy_setopt(curl, CURLOPT_PROXY, "localhost:8888");
//curl_easy_setopt(curl, CURLOPT_PROXY, "10.142.50.140:806");
//curl_easy_setopt(curl, CURLOPT_PROXY, "127.0.0.1:8888");
//curl_easy_setopt(curl, CURLOPT_PROXY, "202.138.240.159:8080");
//邮件账号密码
if ( !m_username.empty() && !m_password.empty() )
{
curl_easy_setopt( curl, CURLOPT_USERNAME, m_username.c_str() );
curl_easy_setopt( curl, CURLOPT_PASSWORD, m_password.c_str() );
}
//邮件账号面
//curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "UIDL");
//curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "TOP 1 0");
curl_easy_setopt( curl, CURLOPT_ERRORBUFFER, errorBuffer );
curl_easy_setopt( curl, CURLOPT_URL, url.c_str() );
//curl_easy_setopt( curl, CURLOPT_HEADER, 1 );
//curl_easy_setopt( curl, CURLOPT_FOLLOWLOCATION, 1 );
if (!m_cookie_file.empty())
{
curl_easy_setopt( curl, CURLOPT_COOKIEFILE, (char*)m_cookie_file.c_str());
curl_easy_setopt( curl, CURLOPT_COOKIEJAR, (char*)m_cookie_file.c_str());
}
// curl_easy_setopt( curl, CURLOPT_COOKIEFILE, "C:\\1.txt");
// curl_easy_setopt( curl, CURLOPT_COOKIEJAR, "C:\\1.txt");
curl_easy_setopt( curl, CURLOPT_WRITEFUNCTION, WriteCallback );
curl_easy_setopt( curl, CURLOPT_WRITEDATA, lpService );
curl_easy_setopt( curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback ); // our static function
curl_easy_setopt( curl, CURLOPT_WRITEHEADER, lpService ); //"headers" is a member variable referencing HttpHeaders
curl_easy_setopt( curl, CURLOPT_SSL_VERIFYPEER, 0L );
curl_easy_setopt( curl, CURLOPT_SSL_VERIFYHOST, 0L );
curl_easy_setopt( curl, CURLOPT_VERBOSE , 0 );
curl_easy_setopt( curl, CURLOPT_NOSIGNAL, 1L );
curl_easy_setopt( curl, CURLOPT_TIMEOUT,60 );
//下载进度条
curl_easy_setopt( curl, CURLOPT_NOPROGRESS, FALSE );
curl_easy_setopt( curl, CURLOPT_PROGRESSFUNCTION, ProgressCallback );
curl_easy_setopt( curl, CURLOPT_PROGRESSDATA, lpService );
//curl_easy_setopt(curl,CURLOPT_SSLVERSION,3);
struct curl_slist *headers = NULL;
// Add standard headers
for ( unsigned int i = 0; i < request_headers_.size(); ++i )
{
headers = curl_slist_append( headers, request_headers_[i].c_str() );
}
// Add any custom headers
for ( unsigned int i = 0; i < custom_headers.size(); ++i )
{
headers = curl_slist_append( headers, custom_headers[i].c_str() );
}
//int nranIndex = myRandom(0,m_header_user_agent.size()-1);
//headers = curl_slist_append( headers, m_header_user_agent[nranIndex].c_str() );
headers = curl_slist_append( headers, m_header_user_agent[0].c_str() );
if ( http_method == "GET" )
{
curl_easy_setopt( curl, CURLOPT_HTTPGET, 1L );
// headers =
// curl_slist_append(headers, "Content-Type: application/atom+xml");
}
else if ( http_method == "POST" )
{
curl_easy_setopt( curl, CURLOPT_POST, 1 );
if( lpHttpData != NULL && lpHttpData->data != NULL && lpHttpData->datalen >= 0 )
{
// curl_easy_setopt(curl, CURLOPT_BINARYTRANSFER, 1);
curl_easy_setopt( curl, CURLOPT_READFUNCTION, UploadCallback );
lpService->m_lpHttpData = lpHttpData;
curl_easy_setopt( curl, CURLOPT_READDATA, lpService );
curl_easy_setopt( curl, CURLOPT_INFILESIZE, lpService->m_lpHttpData->datalen );
// curl_easy_setopt( curl, CURLOPT_POSTFIELDS, lpHttpData->data );
curl_easy_setopt( curl, CURLOPT_POSTFIELDSIZE, lpHttpData->datalen );
}
}
else if ( http_method == "PUT" )
{
curl_easy_setopt( curl, CURLOPT_PUT, 1L );
if( lpHttpData != NULL && lpHttpData->data != NULL )
{
curl_easy_setopt( curl, CURLOPT_UPLOAD, 1L );
/* we want to use our own read function */
curl_easy_setopt( curl, CURLOPT_READFUNCTION, UploadCallback );
lpService->m_lpHttpData = lpHttpData;
/* now specify which file to upload */
/*curl_easy_setopt(curl, CURLOPT_READDATA, lpPutData);
curl_easy_setopt(curl, CURLOPT_INFILESIZE, lpPutData->datalen);*/
curl_easy_setopt( curl, CURLOPT_READDATA, lpService );
curl_easy_setopt( curl, CURLOPT_INFILESIZE, lpService->m_lpHttpData->datalen );
}
}
else if ( http_method == "DELETE" )
{
curl_easy_setopt( curl, CURLOPT_CUSTOMREQUEST, "DELETE" );
}
else
{
//cerr << "Error: Unknown http method - " << http_method << endl;
error_str = "Error: Unknown http method - " + http_method;
//return AVERR_HTTP_METHOD;
return CURLE_NOT_BUILT_IN;
}
// attach headers to this request
curl_easy_setopt( curl, CURLOPT_HTTPHEADER, headers );
CURLcode curl_code = curl_easy_perform( curl );
int http_code = 0;
curl_easy_getinfo( curl, CURLINFO_RESPONSE_CODE, &http_code );
// clean up
curl_easy_cleanup( curl );
curl_slist_free_all( headers );
// curl_global_cleanup(); //不可放线程内
if ( memblock != NULL )
{
delete[] memblock;
}
if ( curl_code != CURLE_OK )
{
//cout << "\nError: [" << curl_code << "] - " << errorBuffer;
//DebugPrintA(2, "\nError--%s\n",errorBuffer);
error_str = errorBuffer;
//linux modify callback error info????
//::MessageBoxA(NULL,error_str.c_str(),"HttpReq-ER",0);
return curl_code;
}
else if ( 400 <= http_code )
{
//DebugPrintA(3, "Http-code=%d",http_code);
return http_code;
}
else
error_str = "";
}
return CURLE_OK;
}
static ham_status_t
_perform_request(ham_env_t *env, CURL *handle, proto_wrapper_t *request,
proto_wrapper_t **reply)
{
CURLcode cc;
long response=0;
char header[128];
curl_buffer_t rbuf={0};
curl_buffer_t wbuf={0};
struct curl_slist *slist=0;
wbuf.alloc=env_get_allocator(env);
*reply=0;
if (!proto_pack(request, wbuf.alloc, &rbuf.packed_data, &rbuf.packed_size))
return (HAM_INTERNAL_ERROR);
sprintf(header, "Content-Length: %u", rbuf.packed_size);
slist=curl_slist_append(slist, header);
slist=curl_slist_append(slist, "Transfer-Encoding:");
slist=curl_slist_append(slist, "Expect:");
#ifdef HAM_DEBUG
SETOPT(handle, CURLOPT_VERBOSE, 1);
#endif
SETOPT(handle, CURLOPT_URL, env_get_filename(env));
SETOPT(handle, CURLOPT_READFUNCTION, __readfunc);
SETOPT(handle, CURLOPT_READDATA, &rbuf);
SETOPT(handle, CURLOPT_UPLOAD, 1);
SETOPT(handle, CURLOPT_PUT, 1);
SETOPT(handle, CURLOPT_WRITEFUNCTION, __writefunc);
SETOPT(handle, CURLOPT_WRITEDATA, &wbuf);
SETOPT(handle, CURLOPT_HTTPHEADER, slist);
cc=curl_easy_perform(handle);
if (rbuf.packed_data)
allocator_free(env_get_allocator(env), rbuf.packed_data);
curl_slist_free_all(slist);
if (cc) {
ham_trace(("network transmission failed: %s", curl_easy_strerror(cc)));
return (HAM_NETWORK_ERROR);
}
cc=curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response);
if (cc) {
ham_trace(("network transmission failed: %s", curl_easy_strerror(cc)));
return (HAM_NETWORK_ERROR);
}
if (response!=200) {
ham_trace(("server returned error %u", response));
return (HAM_NETWORK_ERROR);
}
*reply=wbuf.wrapper;
return (0);
}
int Service::HttpRequest( const string http_method,
const string url,
const vector<string>& custom_headers,
const PostData* lpPost_data,
const PutData* lpPutData,
Service* lpService)
{
// string resp_buffer; // body of the response from the server
char *memblock = NULL; // file size of POST body
CURL *curl = curl_easy_init();
int timeout=5;
//const char *progress_data = "* ";
if ( curl )
{
char errorBuffer[CURL_ERROR_SIZE]={0};
if(systemset.checkProxy)
curl_easy_setopt(curl, CURLOPT_PROXY, systemset.Proxy);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errorBuffer);
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_HEADER, 0);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, lpService);
//设置下载速度=0时 N次退出
// SD_curl_easy_setopt_EXT(curl, CURLOPT_TIMEOUT, timeout);绝对不能出现。不然只连接timeout秒
//设置URL地址错误 重连N次后推出
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, timeout);
//设置最低速度。为了中途拔网线
curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 32);
curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, timeout);
if ( http_method == "PUT" )
{
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION,WriteHeaderCallback); // our static function
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, lpService); //"headers" is a member variable referencing HttpHeaders
}
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
curl_easy_setopt(curl, CURLOPT_VERBOSE , 1);
//下载进度条
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, FALSE);
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, ProgressCallback);
curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, lpService);
//curl_easy_setopt(curl,CURLOPT_SSLVERSION,3);
struct curl_slist *headers = NULL;
unsigned int i=0;
// Add standard headers
for (i = 0; i < request_headers_.size(); ++i)
{
headers = curl_slist_append(headers, request_headers_[i].c_str());
}
// Add any custom headers
for (i = 0; i < custom_headers.size(); ++i)
{
headers = curl_slist_append(headers, custom_headers[i].c_str());
}
if ( http_method == "GET" )
{
curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
headers =
curl_slist_append(headers, "Content-Type: application/atom+xml");
}
else if ( http_method == "POST" )
{
curl_easy_setopt(curl, CURLOPT_POST, 1);
// Configure post for plain text or binary data
if( lpPost_data != NULL && lpPost_data->data != NULL )
{
// curl_easy_setopt(curl, CURLOPT_BINARYTRANSFER, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, lpPost_data->data);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, lpPost_data->datalen);
}
}
else if ( http_method == "PUT" )
{
curl_easy_setopt(curl, CURLOPT_PUT, 1L);
if( lpPutData != NULL && lpPutData->data != NULL )
{
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
/* we want to use our own read function */
curl_easy_setopt(curl, CURLOPT_READFUNCTION, UploadCallback);
lpService->m_lpPutData = lpPutData;
/* now specify which file to upload */
/*curl_easy_setopt(curl, CURLOPT_READDATA, lpPutData);
curl_easy_setopt(curl, CURLOPT_INFILESIZE, lpPutData->datalen);*/
curl_easy_setopt(curl, CURLOPT_READDATA, lpService);
curl_easy_setopt(curl, CURLOPT_INFILESIZE, lpService->m_lpPutData->datalen);
}
}
else if ( http_method == "DELETE" )
{
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
}
else
{
// cerr << "Error: Unknown http method - " << http_method << endl;
// error_str = "Error: Unknown http method - " + http_method;
//return AVERR_HTTP_METHOD;
return CURLE_NOT_BUILT_IN;
}
// attach headers to this request
//curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
/*
headers = curl_slist_append(headers, "Content-Type: text/xml; charset=utf-8");
curl_easy_setopt(curl, CURLOPT_HEADER, 1);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
*/
CURLcode curl_code = curl_easy_perform(curl);
int http_code = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
// clean up
curl_easy_cleanup(curl);
curl_slist_free_all(headers);
if ( memblock != NULL )
{
delete[] memblock;
}
if ( curl_code != CURLE_OK )
{
// cout << "\nError: [" << curl_code << "] - " << errorBuffer;
//DebugPrintA(2, "\nError--%s\n",errorBuffer);
error_str = errorBuffer;
//linux modify callback error info????
//::MessageBoxA(NULL,error_str.c_str(),"HttpReq-ER",0);
return curl_code;
}
else if ( 400 <= http_code )
{
//DebugPrintA(3, "Http-code=%d",http_code);
int start, end;
start = lpService->m_resp_buffer.find("<internalReason>");
end = lpService->m_resp_buffer.find("</internalReason>");
if( start>=0 && end>=0 && end>start )
{
start += 16;
error_str = lpService->m_resp_buffer.substr(start, end-start);
}
else
error_str = lpService->m_resp_buffer;
return http_code;
}
else
error_str = "";
}
return CURLE_OK;
}
GString* http_post(http* h, const gchar* url, const gchar* body, gssize body_len, GError** err)
{
struct curl_slist* headers = NULL;
glong http_status = 0;
GString* response;
CURLcode res;
g_return_val_if_fail(h != NULL, NULL);
g_return_val_if_fail(url != NULL, NULL);
g_return_val_if_fail(err == NULL || *err == NULL, NULL);
// setup post headers and url
curl_easy_setopt(h->curl, CURLOPT_POST, 1L);
curl_easy_setopt(h->curl, CURLOPT_URL, url);
g_hash_table_foreach(h->headers, (GHFunc)add_header, &headers);
curl_easy_setopt(h->curl, CURLOPT_HTTPHEADER, headers);
// pass request body
if (body)
{
curl_easy_setopt(h->curl, CURLOPT_NOBODY, 0L);
curl_easy_setopt(h->curl, CURLOPT_POSTFIELDS, body);
curl_easy_setopt(h->curl, CURLOPT_POSTFIELDSIZE, body_len);
}
else
{
curl_easy_setopt(h->curl, CURLOPT_NOBODY, 1L);
curl_easy_setopt(h->curl, CURLOPT_POSTFIELDS, NULL);
curl_easy_setopt(h->curl, CURLOPT_POSTFIELDSIZE, 0L);
}
// prepare buffer for the response body
response = g_string_sized_new(1024);
curl_easy_setopt(h->curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)append_gstring);
curl_easy_setopt(h->curl, CURLOPT_WRITEDATA, response);
// perform HTTP request
res = curl_easy_perform(h->curl);
// check the result
if (res == CURLE_OK)
{
if (curl_easy_getinfo(h->curl, CURLINFO_RESPONSE_CODE, &http_status) == CURLE_OK)
{
if (http_status == 200)
{
goto out;
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "Server returned %ld", http_status);
}
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "Can't get http status code");
}
}
else if (res == CURLE_GOT_NOTHING)
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_NO_RESPONSE, "CURL error: %s", curl_easy_strerror(res));
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "CURL error: %s", curl_easy_strerror(res));
}
g_string_free(response, TRUE);
response = NULL;
out:
curl_easy_setopt(h->curl, CURLOPT_HTTPHEADER, NULL);
curl_slist_free_all(headers);
if (response)
return response;
return NULL;
}
int main(int argc, char **argv)
{
CURL *curl;
CURLcode res;
FILE *ftpfile;
FILE * hd_src ;
int hd ;
struct stat file_info;
struct curl_slist *headerlist=NULL;
char buf_1 [] = "RNFR " UPLOAD_FILE_AS;
char buf_2 [] = "RNTO " RENAME_FILE_TO;
/* get the file size of the local file */
hd = open(LOCAL_FILE, O_RDONLY) ;
fstat(hd, &file_info);
close(hd) ;
/* get a FILE * of the same file, could also be made with
fdopen() from the previous descriptor, but hey this is just
an example! */
hd_src = fopen(LOCAL_FILE, "rb");
/* In windows, this will init the winsock stuff */
curl_global_init(CURL_GLOBAL_ALL);
/* get a curl handle */
curl = curl_easy_init();
if(curl) {
/* build a list of commands to pass to libcurl */
// headerlist = curl_slist_append(headerlist, buf_1);
// headerlist = curl_slist_append(headerlist, buf_2);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_UPLOAD, TRUE) ;
/* set user name and password */
curl_easy_setopt(curl, CURLOPT_USERPWD, "rutul:topspin");
/* specify target */
curl_easy_setopt(curl,CURLOPT_URL, REMOTE_URL);
/* pass in that last of FTP commands to run after the transfer */
// curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist);
/* now specify which file to upload */
curl_easy_setopt(curl, CURLOPT_INFILE, hd_src);
/* and give the size of the upload (optional) */
curl_easy_setopt(curl, CURLOPT_INFILESIZE, file_info.st_size);
/* Switch on full protocol/debug output */
curl_easy_setopt(curl, CURLOPT_VERBOSE, TRUE);
/* Now run off and do what you've been told! */
res = curl_easy_perform(curl);
/* clean up the FTP commands list */
curl_slist_free_all (headerlist);
/* always cleanup */
curl_easy_cleanup(curl);
}
fclose(hd_src); /* close the local file */
curl_global_cleanup();
return 0;
}
gboolean http_post_stream_download(http* h, const gchar* url, http_data_fn write_cb, gpointer user_data, GError** err)
{
struct curl_slist* headers = NULL;
glong http_status = 0;
CURLcode res;
struct _stream_data data;
gboolean status = FALSE;
g_return_val_if_fail(h != NULL, FALSE);
g_return_val_if_fail(url != NULL, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
http_no_expect(h);
// setup post headers and url
curl_easy_setopt(h->curl, CURLOPT_POST, 1L);
curl_easy_setopt(h->curl, CURLOPT_URL, url);
// request is empty
curl_easy_setopt(h->curl, CURLOPT_POSTFIELDSIZE, 0);
// setup response writer
data.cb = write_cb;
data.user_data = user_data;
curl_easy_setopt(h->curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)curl_write);
curl_easy_setopt(h->curl, CURLOPT_WRITEDATA, &data);
g_hash_table_foreach(h->headers, (GHFunc)add_header, &headers);
curl_easy_setopt(h->curl, CURLOPT_HTTPHEADER, headers);
// perform HTTP request
res = curl_easy_perform_retry_empty(h->curl);
// check the result
if (res == CURLE_OK)
{
if (curl_easy_getinfo(h->curl, CURLINFO_RESPONSE_CODE, &http_status) == CURLE_OK)
{
if (http_status == 200)
{
status = TRUE;
goto out;
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "Server returned %ld", http_status);
}
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "Can't get http status code");
}
}
else
{
g_set_error(err, HTTP_ERROR, HTTP_ERROR_OTHER, "CURL error: %s", curl_easy_strerror(res));
}
out:
curl_easy_setopt(h->curl, CURLOPT_HTTPHEADER, NULL);
curl_slist_free_all(headers);
return status;
}
/* ****************************************************************************
*
* httpRequestSend -
*/
std::string httpRequestSend
(
const std::string& _ip,
unsigned short port,
const std::string& protocol,
const std::string& verb,
const std::string& tenant,
const std::string& servicePath,
const std::string& xauthToken,
const std::string& resource,
const std::string& content_type,
const std::string& content,
bool useRush,
bool waitForResponse,
const std::string& acceptFormat,
long timeoutInMilliseconds
)
{
char portAsString[16];
static unsigned long long callNo = 0;
std::string result;
std::string ip = _ip;
struct curl_slist* headers = NULL;
MemoryStruct* httpResponse = NULL;
CURLcode res;
int outgoingMsgSize = 0;
CURL* curl;
++callNo;
if (timeoutInMilliseconds == -1)
{
timeoutInMilliseconds = defaultTimeout;
}
LM_TRANSACTION_START("to", ip.c_str(), port, resource.c_str());
// Preconditions check
if (port == 0)
{
LM_E(("Runtime Error (port is ZERO)"));
LM_TRANSACTION_END();
return "error";
}
if (ip.empty())
{
LM_E(("Runtime Error (ip is empty)"));
LM_TRANSACTION_END();
return "error";
}
if (verb.empty())
{
LM_E(("Runtime Error (verb is empty)"));
LM_TRANSACTION_END();
return "error";
}
if (resource.empty())
{
LM_E(("Runtime Error (resource is empty)"));
LM_TRANSACTION_END();
return "error";
}
if ((content_type.empty()) && (!content.empty()))
{
LM_E(("Runtime Error (Content-Type is empty but there is actual content)"));
LM_TRANSACTION_END();
return "error";
}
if ((!content_type.empty()) && (content.empty()))
{
LM_E(("Runtime Error (Content-Type non-empty but there is no content)"));
LM_TRANSACTION_END();
return "error";
}
if ((curl = curl_easy_init()) == NULL)
{
LM_E(("Runtime Error (could not init libcurl)"));
LM_TRANSACTION_END();
return "error";
}
// Allocate to hold HTTP response
httpResponse = new MemoryStruct;
httpResponse->memory = (char*) malloc(1); // will grow as needed
httpResponse->size = 0; // no data at this point
//
// Rush
// Every call to httpRequestSend specifies whether RUSH should be used or not.
// But, this depends also on how the broker was started, so here the 'useRush'
// parameter is cancelled in case the broker was started without rush.
//
// If rush is to be used, the IP/port is stored in rushHeaderIP/rushHeaderPort and
// after that, the host and port of rush is set as ip/port for the message, that is
// now sent to rush instead of to its final destination.
// Also, a few HTTP headers for rush must be setup.
//
if ((rushPort == 0) || (rushHost == ""))
useRush = false;
if (useRush)
{
char rushHeaderPortAsString[16];
uint16_t rushHeaderPort = 0;
std::string rushHeaderIP = "";
std::string headerRushHttp = "";
rushHeaderIP = ip;
rushHeaderPort = port;
ip = rushHost;
port = rushPort;
snprintf(rushHeaderPortAsString, sizeof(rushHeaderPortAsString), "%d", rushHeaderPort);
headerRushHttp = "X-relayer-host: " + rushHeaderIP + ":" + rushHeaderPortAsString;
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerRushHttp.c_str()));
headers = curl_slist_append(headers, headerRushHttp.c_str());
outgoingMsgSize += headerRushHttp.size();
if (protocol == "https:")
{
headerRushHttp = "X-relayer-protocol: https";
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerRushHttp.c_str()));
headers = curl_slist_append(headers, headerRushHttp.c_str());
outgoingMsgSize += headerRushHttp.size();
}
}
snprintf(portAsString, sizeof(portAsString), "%d", port);
// ----- User Agent
char cvBuf[CURL_VERSION_MAX_LENGTH];
char headerUserAgent[HTTP_HEADER_USER_AGENT_MAX_LENGTH];
snprintf(headerUserAgent, sizeof(headerUserAgent), "User-Agent: orion/%s libcurl/%s", versionGet(), curlVersionGet(cvBuf, sizeof(cvBuf)));
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerUserAgent));
headers = curl_slist_append(headers, headerUserAgent);
outgoingMsgSize += strlen(headerUserAgent) + 1;
// ----- Host
char headerHost[HTTP_HEADER_HOST_MAX_LENGTH];
snprintf(headerHost, sizeof(headerHost), "Host: %s:%d", ip.c_str(), (int) port);
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerHost));
headers = curl_slist_append(headers, headerHost);
outgoingMsgSize += strlen(headerHost) + 1;
// ----- Tenant
if (tenant != "")
{
headers = curl_slist_append(headers, ("fiware-service: " + tenant).c_str());
outgoingMsgSize += tenant.size() + 16; // "fiware-service: "
}
// ----- Service-Path
if (servicePath != "")
{
headers = curl_slist_append(headers, ("Fiware-ServicePath: " + servicePath).c_str());
outgoingMsgSize += servicePath.size() + strlen("Fiware-ServicePath: ");
}
// ----- X-Auth-Token
if (xauthToken != "")
{
headers = curl_slist_append(headers, ("X-Auth-Token: " + xauthToken).c_str());
outgoingMsgSize += xauthToken.size() + strlen("X-Auth-Token: ");
}
// ----- Accept
std::string acceptedFormats = "application/xml, application/json";
if (acceptFormat != "")
{
acceptedFormats = acceptFormat;
}
std::string acceptString = "Accept: " + acceptedFormats;
headers = curl_slist_append(headers, acceptString.c_str());
outgoingMsgSize += acceptString.size();
// ----- Expect
headers = curl_slist_append(headers, "Expect: ");
outgoingMsgSize += 8; // from "Expect: "
// ----- Content-length
std::stringstream contentLengthStringStream;
contentLengthStringStream << content.size();
std::string headerContentLength = "Content-length: " + contentLengthStringStream.str();
LM_T(LmtHttpHeaders, ("HTTP-HEADERS: '%s'", headerContentLength.c_str()));
headers = curl_slist_append(headers, headerContentLength.c_str());
outgoingMsgSize += contentLengthStringStream.str().size() + 16; // from "Content-length: "
outgoingMsgSize += content.size();
// ----- Content-type
headers = curl_slist_append(headers, ("Content-type: " + content_type).c_str());
outgoingMsgSize += content_type.size() + 14; // from "Content-type: "
// Check if total outgoing message size is too big
if (outgoingMsgSize > MAX_DYN_MSG_SIZE)
{
LM_E(("Runtime Error (HTTP request to send is too large: %d bytes)", outgoingMsgSize));
// Cleanup curl environment
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
free(httpResponse->memory);
delete httpResponse;
LM_TRANSACTION_END();
return "error";
}
// Contents
const char* payload = content.c_str();
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (u_int8_t*) payload);
// Set up URL
std::string url;
if (isIPv6(ip))
url = "[" + ip + "]";
else
url = ip;
url = url + ":" + portAsString + (resource.at(0) == '/'? "" : "/") + resource;
// Prepare CURL handle with obtained options
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb.c_str()); // Set HTTP verb
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // Allow redirection (?)
curl_easy_setopt(curl, CURLOPT_HEADER, 1); // Activate include the header in the body output
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); // Put headers in place
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &writeMemoryCallback); // Send data here
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*) httpResponse); // Custom data for response handling
//
// Timeout
//
// The parameter timeoutInMilliseconds holds the timeout time in milliseconds.
// If the timeout time requested is 0, then no timeuot is used.
//
if (timeoutInMilliseconds != 0)
{
curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeoutInMilliseconds);
}
// Synchronous HTTP request
LM_T(LmtClientOutputPayload, ("Sending message %lu to HTTP server: sending message of %d bytes to HTTP server", callNo, outgoingMsgSize));
res = curl_easy_perform(curl);
if (res != CURLE_OK)
{
//
// NOTE: This log line is used by the functional tests in cases/880_timeout_for_forward_and_notifications/
// So, this line should not be removed/altered, at least not without also modifying the functests.
//
LM_W(("Notification failure for %s:%s (curl_easy_perform failed: %s)", ip.c_str(), portAsString, curl_easy_strerror(res)));
result = "";
}
else
{
// The Response is here
LM_I(("Notification Successfully Sent to %s", url.c_str()));
result.assign(httpResponse->memory, httpResponse->size);
}
// Cleanup curl environment
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
free(httpResponse->memory);
delete httpResponse;
LM_TRANSACTION_END();
return result;
}
/* perform a HTTP GET request via SSL/TLS */
static int
do_get (const char *url)
{
CURL *c;
struct CBC cbc;
CURLcode errornum;
size_t len;
struct curl_slist *dns_info;
len = strlen (test_data);
if (NULL == (cbc.buf = malloc (sizeof (char) * len)))
{
fprintf (stderr, MHD_E_MEM);
return -1;
}
cbc.size = len;
cbc.pos = 0;
c = curl_easy_init ();
#if DEBUG_HTTPS_TEST
curl_easy_setopt (c, CURLOPT_VERBOSE, 1);
#endif
curl_easy_setopt (c, CURLOPT_URL, url);
curl_easy_setopt (c, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
curl_easy_setopt (c, CURLOPT_TIMEOUT, 10L);
curl_easy_setopt (c, CURLOPT_CONNECTTIMEOUT, 10L);
curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, ©Buffer);
curl_easy_setopt (c, CURLOPT_FILE, &cbc);
/* perform peer authentication */
/* TODO merge into send_curl_req */
curl_easy_setopt (c, CURLOPT_SSL_VERIFYPEER, 0);
curl_easy_setopt (c, CURLOPT_SSL_VERIFYHOST, 2);
dns_info = curl_slist_append (NULL, "host1:4233:127.0.0.1");
dns_info = curl_slist_append (dns_info, "host2:4233:127.0.0.1");
curl_easy_setopt (c, CURLOPT_RESOLVE, dns_info);
curl_easy_setopt (c, CURLOPT_FAILONERROR, 1);
/* NOTE: use of CONNECTTIMEOUT without also
setting NOSIGNAL results in really weird
crashes on my system! */
curl_easy_setopt (c, CURLOPT_NOSIGNAL, 1);
if (CURLE_OK != (errornum = curl_easy_perform (c)))
{
fprintf (stderr, "curl_easy_perform failed: `%s'\n",
curl_easy_strerror (errornum));
curl_easy_cleanup (c);
free (cbc.buf);
curl_slist_free_all (dns_info);
return errornum;
}
curl_easy_cleanup (c);
curl_slist_free_all (dns_info);
if (memcmp (cbc.buf, test_data, len) != 0)
{
fprintf (stderr, "Error: local file & received file differ.\n");
free (cbc.buf);
return -1;
}
free (cbc.buf);
return 0;
}
std::string request(http::client &client, http::method method, const std::string &userPath)
{
CURLcode code;
char buf[http::MAX_URL_LEN + 1] = {0};
struct curl_slist *headers = NULL;
CURL *curl = NULL;
std::string path = userPath;
net::uri uri = client.uri();
std::string content = client.content();
std::string response;
curl = curl_easy_init();
if (curl == NULL) {
throw socket_exception("unable to initialize curl request");
}
// check if a path was specified
if (path.empty()) {
path = uri.full_path();
}
if (path.empty()) {
snprintf(buf, http::MAX_URL_LEN, "%s://%s", uri.scheme().c_str(), uri.host_with_port().c_str());
} else if (path[0] == '/') {
snprintf(buf, http::MAX_URL_LEN, "%s://%s%s", uri.scheme().c_str(),
uri.host_with_port().c_str(), path.c_str());
} else {
snprintf(buf, http::MAX_URL_LEN, "%s://%s/%s", uri.scheme().c_str(),
uri.host_with_port().c_str(), path.c_str());
}
helper::curl_set_opt(curl, CURLOPT_URL, buf);
helper::curl_set_opt_fun(curl, CURLOPT_WRITEFUNCTION, helper::curl_append_response_callback);
helper::curl_set_opt_num(curl, CURLOPT_HEADER, 1L);
#ifdef DEBUG
helper::curl_set_opt_num(curl, CURLOPT_VERBOSE, 1L);
#endif
switch (method) {
case http::GET:
helper::curl_set_opt_num(curl, CURLOPT_HTTPGET, 1L);
break;
case http::POST:
helper::curl_set_opt_num(curl, CURLOPT_POST, 1L);
if (!content.empty()) {
helper::curl_set_opt(curl, CURLOPT_POSTFIELDS, content.c_str());
helper::curl_set_opt_num(curl, CURLOPT_POSTFIELDSIZE, content.size());
}
break;
case http::PUT:
helper::curl_set_opt_num(curl, CURLOPT_PUT, 1L);
if (!content.empty()) {
helper::curl_set_opt(curl, CURLOPT_POSTFIELDS, content.c_str());
helper::curl_set_opt_num(curl, CURLOPT_POSTFIELDSIZE, content.size());
}
break;
default:
helper::curl_set_opt(curl, CURLOPT_CUSTOMREQUEST, http::method_names[method]);
break;
}
for (auto &h : client.headers()) {
snprintf(buf, http::MAX_URL_LEN, "%s: %s", h.first.c_str(), h.second.c_str());
headers = curl_slist_append(headers, buf);
}
helper::curl_set_opt(curl, CURLOPT_HTTPHEADER, headers);
helper::curl_set_opt_num(curl, CURLOPT_TIMEOUT, client.timeout());
helper::curl_set_opt(curl, CURLOPT_WRITEDATA, &response);
CURLcode res = curl_easy_perform(curl);
curl_slist_free_all(headers);
if (res != CURLE_OK && res != CURLE_PARTIAL_FILE) {
curl_easy_cleanup(curl);
throw socket_exception(curl_easy_strerror(res));
}
curl_easy_cleanup(curl);
return response;
}
/**
* Uploads the save file to CloudyWeb.
*
* @param Filename Filename of the save game file.
* @param PlayerControllerId PlayerControllerId of the player who is saving the game.
*
* @return Returns true if the file upload was successful. Else, returns false.
*
*/
bool CloudyWebConnectorImpl::UploadFile(FString Filename, int32 PlayerControllerId)
{
bool RequestSuccess = false;
CURL *curl;
CURLcode res;
std::string readBuffer;
FString Url = BaseUrl + SaveDataUrl;
std::string UrlCString(TCHAR_TO_UTF8(*Url));
// Filepath of .sav file
FString Filepath = FPaths::GameDir();
Filepath += "Saved/SaveGames/" + Filename + ".sav";
std::string filePath(TCHAR_TO_UTF8(*Filepath));
// Get game name
FString GameName = FApp::GetGameName();
std::string gameName(TCHAR_TO_UTF8(*GameName));
// Get game ID
FString GameID = FString::FromInt(GetGameId());
std::string GameIDCString(TCHAR_TO_UTF8(*GameID));
// Get username
FString Username = GetUsername(PlayerControllerId);
std::string UsernameCString(TCHAR_TO_UTF8(*Username));
// Convert PlayerControllerId
FString playerControllerIdFString = FString::FromInt(PlayerControllerId);
std::string playerControllerId(TCHAR_TO_UTF8(*playerControllerIdFString));
if (GetGameId() == -1 || Username.Equals("") || PlayerControllerId < 0)
{
UE_LOG(CloudyWebConnectorLog, Error, TEXT("The game ID, username, or player controller ID is invalid"));
return false;
}
struct curl_httppost *formpost = NULL;
struct curl_httppost *lastptr = NULL;
struct curl_slist *headerlist = NULL;
FString AuthHeader = "Authorization: Token " + Token;
std::string AuthHeaderCString(TCHAR_TO_UTF8(*AuthHeader));
curl_global_init(CURL_GLOBAL_ALL);
/* Fill in the file upload field */
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "saved_file",
CURLFORM_FILE, filePath.c_str(),
CURLFORM_END);
/* Fill in the player controller ID field */
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "user",
CURLFORM_COPYCONTENTS, UsernameCString.c_str(),
CURLFORM_END);
/* Fill in the game name field */
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "game",
CURLFORM_COPYCONTENTS, GameIDCString.c_str(),
CURLFORM_END);
curl = curl_easy_init();
/* initialize custom header list (stating that Expect: 100-continue is not
wanted */
headerlist = curl_slist_append(headerlist, AuthHeaderCString.c_str());
if (curl) {
/* what URL that receives this POST */
curl_easy_setopt(curl, CURLOPT_URL, UrlCString.c_str());
/* only disable 100-continue header if explicitly requested */
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
/* What form to send */
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
/* Set up string to write response into */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
/* Check if the request was successful */
if (res == CURLE_OK)
{
RequestSuccess = true;
}
/* always cleanup */
curl_easy_cleanup(curl);
/* then cleanup the formpost chain */
curl_formfree(formpost);
/* free slist */
curl_slist_free_all(headerlist);
UE_LOG(CloudyWebConnectorLog, Warning, TEXT("Response data: %s"), UTF8_TO_TCHAR(readBuffer.c_str()));
ReadAndStoreSaveFileURL(readBuffer.c_str(), PlayerControllerId);
}
return RequestSuccess;
}
void* pull_one_url(void *arg_cbget)
{
if (!arg_cbget)
return NULL;
cbget *arg = static_cast<cbget*>(arg_cbget);
CURL *curl = NULL;
if (!arg->_handler)
{
curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_MAXREDIRS,5);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0); // do not check on SSL certificate.
}
else curl = arg->_handler;
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, arg->_connect_timeout_sec);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, arg->_transfer_timeout_sec);
curl_easy_setopt(curl, CURLOPT_URL, arg->_url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, arg);
if (!arg->_cookies.empty())
curl_easy_setopt(curl, CURLOPT_COOKIE, arg->_cookies.c_str());
if (!arg->_proxy_addr.empty())
{
std::string proxy_str = arg->_proxy_addr + ":" + miscutil::to_string(arg->_proxy_port);
curl_easy_setopt(curl, CURLOPT_PROXY, proxy_str.c_str());
}
if (arg->_http_method == "POST") // POST request.
{
if (arg->_content)
{
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, (void*)arg->_content->c_str());
if (arg->_content_size >= 0)
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, arg->_content_size);
/*std::cerr << "curl_mget POST size: " << arg->_content_size << std::endl
<< "content: " << *arg->_content << std::endl;*/
}
else curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
}
else if (arg->_http_method == "PUT" || arg->_http_method == "DELETE")
{
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, arg->_http_method.c_str());
}
struct curl_slist *slist=NULL;
// useful headers.
if (arg->_headers)
{
std::list<const char*>::const_iterator sit = arg->_headers->begin();
while (sit!=arg->_headers->end())
{
slist = curl_slist_append(slist,(*sit));
++sit;
}
if (arg->_content)
{
slist = curl_slist_append(slist,strdup(arg->_content_type.c_str()));
slist = curl_slist_append(slist,strdup("Expect:"));
}
}
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
char errorbuffer[CURL_ERROR_SIZE];
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &errorbuffer);
try
{
int status = curl_easy_perform(curl);
if (status != 0) // an error occurred.
{
arg->_status = status;
errlog::log_error(LOG_LEVEL_ERROR, "curl error on url %s: %s",arg->_url,errorbuffer);
if (arg->_output)
{
delete arg->_output;
arg->_output = NULL;
}
}
}
catch (std::exception &e)
{
arg->_status = -1;
errlog::log_error(LOG_LEVEL_ERROR, "Error %s in fetching remote data with curl.", e.what());
if (arg->_output)
{
delete arg->_output;
arg->_output = NULL;
}
}
catch (...)
{
arg->_status = -2;
if (arg->_output)
{
delete arg->_output;
arg->_output = NULL;
}
}
if (!arg->_handler)
curl_easy_cleanup(curl);
if (slist)
curl_slist_free_all(slist);
return NULL;
}
void download_elevation_data(TTBIN_FILE *ttbin)
{
CURL *curl;
struct curl_slist *headers;
char *post_data;
char *response_data;
char *str;
uint32_t i;
ELEV_DATA_INFO info = {0};
int result;
/* only download elevation data if we have GPS records */
if (!ttbin || !ttbin->gps_record_count || !ttbin->gps_records)
return;
curl = curl_easy_init();
if (!curl)
{
fprintf(stderr, "Unable to initialise libcurl\n");
return;
}
/* create the post string to send to the server */
post_data = malloc(ttbin->gps_record_count * 52 + 10);
str = post_data;
str += sprintf(str, "[\n");
for (i = 0; i < ttbin->gps_record_count; ++i)
{
if (i != (ttbin->gps_record_count - 1))
{
str += sprintf(str, " [ %f, %f ],\n",
ttbin->gps_records[i].latitude,
ttbin->gps_records[i].longitude);
}
else
{
str += sprintf(str, " [ %f, %f ]\n",
ttbin->gps_records[i].latitude,
ttbin->gps_records[i].longitude);
}
}
str += sprintf(str, "]\n");
headers = curl_slist_append(NULL, "Content-Type:text/plain");
/* setup the callback function data structure */
info.mult = 1.0;
info.elev = 0.0;
info.data = ttbin->gps_records;
info.max_count = ttbin->gps_record_count;
info.current_count = 0;
/* setup the transaction */
curl_easy_setopt(curl, CURLOPT_URL, "https://mysports.tomtom.com/tyne/dem/fixmodel");
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post_data);
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, str - post_data);
curl_easy_setopt(curl, CURLOPT_POST, 1);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
curl_easy_setopt(curl, CURLOPT_USERAGENT, "TomTom");
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50);
curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &info);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_data);
/* perform the transaction */
result = curl_easy_perform(curl);
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
if (result != CURLE_OK)
fprintf(stderr, "Unable to download elevation data: %d\n", result);
}
int main(void)
{
CURL *curl;
CURLM *multi_handle;
int still_running;
struct curl_httppost *formpost=NULL;
struct curl_httppost *lastptr=NULL;
struct curl_slist *headerlist=NULL;
static const char buf[] = "Expect:";
/* Fill in the file upload field. This makes libcurl load data from
the given file name when curl_easy_perform() is called. */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "sendfile",
CURLFORM_FILE, "postit2.c",
CURLFORM_END);
/* Fill in the filename field */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "filename",
CURLFORM_COPYCONTENTS, "postit2.c",
CURLFORM_END);
/* Fill in the submit field too, even if this is rarely needed */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "submit",
CURLFORM_COPYCONTENTS, "send",
CURLFORM_END);
curl = curl_easy_init();
multi_handle = curl_multi_init();
/* initialize custom header list (stating that Expect: 100-continue is not
wanted */
headerlist = curl_slist_append(headerlist, buf);
if(curl && multi_handle) {
/* what URL that receives this POST */
curl_easy_setopt(curl, CURLOPT_URL, "http://www.example.com/upload.cgi");
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
curl_multi_add_handle(multi_handle, curl);
curl_multi_perform(multi_handle, &still_running);
do {
struct timeval timeout;
int rc; /* select() return code */
CURLMcode mc; /* curl_multi_fdset() return code */
fd_set fdread;
fd_set fdwrite;
fd_set fdexcep;
int maxfd = -1;
long curl_timeo = -1;
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
FD_ZERO(&fdexcep);
/* set a suitable timeout to play around with */
timeout.tv_sec = 1;
timeout.tv_usec = 0;
curl_multi_timeout(multi_handle, &curl_timeo);
if(curl_timeo >= 0) {
timeout.tv_sec = curl_timeo / 1000;
if(timeout.tv_sec > 1)
timeout.tv_sec = 1;
else
timeout.tv_usec = (curl_timeo % 1000) * 1000;
}
/* get file descriptors from the transfers */
mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
if(mc != CURLM_OK)
{
fprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
break;
}
/* On success the value of maxfd is guaranteed to be >= -1. We call
select(maxfd + 1, ...); specially in case of (maxfd == -1) there are
no fds ready yet so we call select(0, ...) --or Sleep() on Windows--
to sleep 100ms, which is the minimum suggested value in the
curl_multi_fdset() doc. */
if(maxfd == -1) {
#ifdef _WIN32
Sleep(100);
rc = 0;
#else
/* Portable sleep for platforms other than Windows. */
struct timeval wait = { 0, 100 * 1000 }; /* 100ms */
rc = select(0, NULL, NULL, NULL, &wait);
#endif
}
else {
/* Note that on some platforms 'timeout' may be modified by select().
If you need access to the original value save a copy beforehand. */
rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
}
switch(rc) {
case -1:
/* select error */
break;
case 0:
default:
/* timeout or readable/writable sockets */
printf("perform!\n");
curl_multi_perform(multi_handle, &still_running);
printf("running: %d!\n", still_running);
break;
}
} while(still_running);
curl_multi_cleanup(multi_handle);
/* always cleanup */
curl_easy_cleanup(curl);
/* then cleanup the formpost chain */
curl_formfree(formpost);
/* free slist */
curl_slist_free_all (headerlist);
}
return 0;
}
static char *__curl_do_operation(curl_context *cc, struct curl_slist* headers, int curl_opt,
char *url, char *fields, char *data, curl_response **ret_data) {
CURL *curl = NULL;
CURLcode res;
char *endpoint;
char *tmpptr;
long tmplong;
long send_len;
*ret_data = init_curl_response();
if (!(*ret_data)) {
goto error_exit;
}
if (data) {
send_len = strlen(data);
} else {
send_len = 0;
}
if (url) {
endpoint = url;
} else {
endpoint = cc->url;
}
struct curl_http_data send_data = {
.ptr = data,
.len = send_len
};
struct curl_http_data recv_data = {
.ptr = NULL,
.len = 0
};
if (cc->curl_persist) {
curl = cc->curl;
} else {
curl = curl_easy_init();
if (!curl) {
dbg_info(ERROR, "Could not initialize CURL\n");
goto error_exit;
}
if (cc->use_ssl) {
__init_curl_ssl(curl, 0);
__set_curl_ssl_certificates(curl, cc->cacerts, cc->certfile, cc->keypass, cc->keyfile);
}
}
//curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_URL, endpoint);
curl_easy_setopt(curl, curl_opt, 1L);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_cb);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
curl_easy_setopt(curl, CURLOPT_READDATA, &send_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &recv_data);
if (cc->follow_redirect) {
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
}
if (cc->use_cookies) {
curl_easy_setopt(curl, CURLOPT_COOKIEJAR, cc->cookiejar);
curl_easy_setopt(curl, CURLOPT_COOKIEFILE, cc->cookiejar);
}
if (headers) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
}
if (fields && (curl_opt & CURLOPT_HTTPPOST)) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, fields);
}
else if (curl_opt & CURLOPT_HTTPPOST) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, send_len);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
}
res = curl_easy_perform(curl);
if (res != CURLE_OK) {
dbg_info(ERROR, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
goto error_exit;
}
if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &tmplong) == CURLE_OK)
(*ret_data)->status = tmplong;
if (curl_easy_getinfo(curl, CURLINFO_REDIRECT_URL, &tmpptr) == CURLE_OK){
if(tmpptr != NULL){
asprintf(&((*ret_data)->redirect_url), "%s", tmpptr);
}
}
if (curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &tmpptr) == CURLE_OK){
if(tmpptr != NULL){
(*ret_data)->content_type = malloc(strlen(tmpptr) + 1);
strncpy((*ret_data)->content_type, tmpptr, strlen(tmpptr) + 1);
//asprintf(&((*ret_data)->content_type), "%s", tmpptr);
}
}
if (recv_data.len) {
(*ret_data)->data = malloc(recv_data.len+1 * sizeof(char));
memcpy((*ret_data)->data, recv_data.ptr, recv_data.len);
(*ret_data)->data[recv_data.len] = '\0';
}
if (headers) {
curl_slist_free_all(headers);
}
if (!(cc->curl_persist)) {
curl_easy_cleanup(curl);
}
return (*ret_data)->data;
error_exit:
if (headers)
curl_slist_free_all(headers);
if (!(cc->curl_persist))
curl_easy_cleanup(curl);
free_curl_response(*ret_data);
*ret_data = NULL;
return NULL;
}
static size_t read_cb(void *ptr, size_t size, size_t nmemb, void *userp) {
struct curl_http_data *data = (struct curl_http_data *) userp;
if (size * nmemb < 1) {
return 0;
}
if (data->len) {
*(char *) ptr = data->ptr[0];
data->ptr++;
data->len--;
return 1;
}
return 0;
}
static size_t write_cb(void *ptr, size_t size, size_t nmemb, void *userp) {
struct curl_http_data *s = (struct curl_http_data *) userp;
size_t new_len = s->len + size*nmemb;
s->ptr = realloc(s->ptr, new_len+1);
if (s->ptr == NULL) {
fprintf(stderr, "realloc() failed\n");
exit(EXIT_FAILURE);
}
memcpy(s->ptr+s->len, ptr, size*nmemb);
s->ptr[new_len] = '\0';
s->len = new_len;
return size*nmemb;
}
ResourceHandleInternal::~ResourceHandleInternal()
{
fastFree(m_url);
if (m_customHeaders)
curl_slist_free_all(m_customHeaders);
}
static void moloch_http_curlm_check_multi_info(MolochHttpServer_t *server)
{
char *eff_url;
CURLMsg *msg;
int msgs_left;
MolochHttpRequest_t *request;
CURL *easy;
while ((msg = curl_multi_info_read(server->multi, &msgs_left))) {
if (msg->msg == CURLMSG_DONE) {
easy = msg->easy_handle;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, (void*)&request);
curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url);
long responseCode;
curl_easy_getinfo(easy, CURLINFO_RESPONSE_CODE, &responseCode);
if (config.logESRequests) {
double totalTime;
double connectTime;
double uploadSize;
double downloadSize;
curl_easy_getinfo(easy, CURLINFO_TOTAL_TIME, &totalTime);
curl_easy_getinfo(easy, CURLINFO_CONNECT_TIME, &connectTime);
curl_easy_getinfo(easy, CURLINFO_SIZE_UPLOAD, &uploadSize);
curl_easy_getinfo(easy, CURLINFO_SIZE_DOWNLOAD, &downloadSize);
LOG("%d/%d ASYNC %ld %s %.0lf/%.0lf %.0lfms %.0lfms",
request->server->outstanding,
request->server->connections,
responseCode,
request->url,
uploadSize,
downloadSize,
connectTime*1000,
totalTime*1000);
}
#ifdef MOLOCH_HTTP_DEBUG
LOG("HTTPDEBUG DECR %s %p %d %s", server->names[0], request, server->outstanding, request->url);
#endif
if (request->func) {
if (request->dataIn)
request->dataIn[request->used] = 0;
request->func(responseCode, request->dataIn, request->used, request->uw);
}
if (request->dataIn) {
free(request->dataIn);
request->dataIn = 0;
}
if (request->dataOut) {
MOLOCH_SIZE_FREE(buffer, request->dataOut);
}
if (request->headerList) {
curl_slist_free_all(request->headerList);
}
MOLOCH_TYPE_FREE(MolochHttpRequest_t, request);
curl_multi_remove_handle(server->multi, easy);
curl_easy_cleanup(easy);
MOLOCH_LOCK(requests);
server->outstanding--;
MOLOCH_UNLOCK(requests);
}
}
}
long aur_upload(const char *taurball) {
char *ptr, *fullpath;
char missing_var[10], category[3];
long httpcode, ret = 0;
CURLcode status;
struct curl_httppost *post, *last;
struct curl_slist *headers;
static struct write_result response;
fullpath = realpath(taurball, NULL);
if (fullpath == NULL) {
fprintf(stderr, "Error uploading file '%s': ", taurball);
perror("");
return(1L);
}
post = last = NULL;
headers = NULL;
response.memory = NULL;
response.size = 0;
snprintf(category, 3, "%d", config->catnum);
curl_formadd(&post, &last,
CURLFORM_COPYNAME, "pkgsubmit",
CURLFORM_COPYCONTENTS, "1", CURLFORM_END);
curl_formadd(&post, &last,
CURLFORM_COPYNAME, "category",
CURLFORM_COPYCONTENTS, category, CURLFORM_END);
curl_formadd(&post, &last,
CURLFORM_COPYNAME, "pfile",
CURLFORM_FILE, fullpath, CURLFORM_END);
headers = curl_slist_append(headers, "Expect:");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_response);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
curl_easy_setopt(curl, CURLOPT_URL, AUR_SUBMIT_URL);
if (config->verbose > 0) {
printf("Uploading taurball: %s\n", config->verbose > 1 ? fullpath : taurball);
}
status = curl_easy_perform(curl);
if (status != CURLE_OK) {
fprintf(stderr, "curl error: unable to send data to %s\n", AUR_SUBMIT_URL);
fprintf(stderr, "%s\n", curl_easy_strerror(status));
ret = status;
goto cleanup;
}
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpcode);
if(httpcode != 200) {
fprintf(stderr, "curl error: server responded with code %ld\n", httpcode);
ret = httpcode;
goto cleanup;
}
if (config->verbose > 1) {
printf("%s\n", response.memory);
}
if (strstr(response.memory, AUR_NO_LOGIN)) {
fprintf(stderr, "Error: Authentication failed on upload.\n");
ret = 1;
} else if (strstr(response.memory, AUR_NO_OVERWRITE)) {
fprintf(stderr, "Error: You don't have permission to overwrite this file.\n");
ret = 1;
} else if (strstr(response.memory, AUR_UNKNOWN_FORMAT)) {
fprintf(stderr, "Error: Incorrect file format. Upload must conform to AUR "
"packaging guidelines.\n");
ret = 1;
} else if (strstr(response.memory, AUR_INVALID_NAME)) {
fprintf(stderr, "Error: Invalid package name. Only lowercase letters are "
"allowed. Make sure this isn't a split package.\n");
ret = 1;
} else if (strstr(response.memory, AUR_NO_PKGBUILD)) {
fprintf(stderr, "Error: PKGBUILD does not exist in uploaded source.\n");
ret = 1;
} else if (strstr(response.memory, AUR_NO_BUILD_FUNC)) {
fprintf(stderr, "Error: PKGBUILD is missing build function.\n");
ret = 1;
} else if (strstr(response.memory, AUR_MISSING_PROTO)) {
fprintf(stderr, "Error: Package URL is missing a protocol\n");
ret = 1;
} else if ((ptr = strstr(response.memory, "Missing")) &&
sscanf(ptr, AUR_MISSING_VAR, missing_var)) {
fprintf(stderr, "Error: Package is missing %s variable\n", missing_var);
ret = 1;
} else {
printf("%s has been uploaded successfully.\n", basename(taurball));
}
cleanup:
free(fullpath);
free(response.memory);
curl_slist_free_all(headers);
curl_formfree(post);
return(ret);
}
