libcurl can't get CURLINFO_EFFECTIVE_URL - c++

Question

I use curl_easy_getinfo to get url, but sometimes it points to private memory, how can I solve it?
102 bool bb_curl::check_result(CURLcode code, CURL *handle, bool check_url) {
103 if (code == CURLE_OK) {
104 char *url = nullptr;
105 auto rc = curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url);
106 if (rc == CURLE_OK && url && check_url) {
107 int http_code;
108 curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &http_code);
109 if (http_code == 200)
110 BB_VERBOSE("[OK] %s\n", url);
111 else
112 BB_Warn("[ERROR] http code:%d, url: %s\n", http_code, url);
113 }
Use gdb:
Program received signal SIGSEGV, Segmentation fault.
(gdb) f 5
#5 0x00002aaaac7b79a3 in bb_curl::check_result (this=0x6572f0, code=CURLE_OK, handle=0x6f4ab0,
check_url=true) at /wsp/bb_curl.cpp:110
110 BB_VERBOSE("[OK] %s\n", url);
(gdb) p url
$1 = 0x2aaa00000000 <error: Cannot access memory at address 0x2aaa00000000>
I also set CURLOPT_FOLLOWLOCATION, 1,, can't fix it.
UPDATE
platform:
gcc (GCC) 4.9.3
curl 7.46.0 (x86_64-pc-linux-gnu) libcurl/7.46.0 OpenSSL/1.0.2e zlib/1.2.3 libidn/1.10 libssh2/0.19.0-20080814
SUSE Linux Enterprise Server 11 (x86_64)
I update the complete source code.
#include <curl/curl.h>
#include <cstdlib>
#include <string>
#include <vector>
#include <future>
/* reserved vector */
template <class T>
inline std::vector<T> bb_reserved_vector(size_t n) {
std::vector<T> vec;
vec.reserve(n);
return vec;
}
size_t write_cb(char *ptr, size_t size, size_t nmemb, void *userdata) {
return size * nmemb;
}
bool check_result(CURLcode code, CURL *handle, bool check_url) {
if (code == CURLE_OK && handle != nullptr) {
char *url = nullptr;
auto rc = curl_easy_getinfo(handle, CURLINFO_EFFECTIVE_URL, &url);
if (rc == CURLE_OK && url && check_url) {
int http_code;
curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &http_code);
if (http_code == 200)
printf("[OK] %s\n", url);
else
printf("[ERROR] http code:%d, url: %s\n", http_code, url);
}
return true;
} else {
printf("[ERROR] curl code %d\n", code);
return false;
}
}
int main() {
size_t sz = 1000;
auto futures = bb_reserved_vector<std::future<CURLcode>>(sz);
auto handles = bb_reserved_vector<CURL *>(sz);
auto results = std::vector<std::string>(sz);
curl_global_init(CURL_GLOBAL_ALL);
for (size_t i = 0; i < sz; ++i) {
handles.push_back(curl_easy_init());
int curl_code = curl_easy_setopt(handles[i], CURLOPT_WRITEDATA, (void *) &results[i]);
curl_code += curl_easy_setopt(handles[i], CURLOPT_URL, "www.example.com");
curl_code += curl_easy_setopt(handles[i], CURLOPT_WRITEFUNCTION, write_cb);
curl_code += curl_easy_setopt(handles[i], CURLOPT_FOLLOWLOCATION, 1);
curl_code += curl_easy_setopt(handles[i], CURLOPT_NOSIGNAL, 1);
if (curl_code != 0)
printf("Set option error\n");
auto fut = std::async(std::launch::async, curl_easy_perform, handles[i]);
futures.push_back(std::move(fut));
}
// synchronize
for (size_t i = 0; i < futures.size(); ++i) {
futures[i].wait();
check_result(futures[i].get(), handles[i], true);
}
// cleanup
for (auto &item : handles)
curl_easy_cleanup(item);
curl_global_cleanup();
return 0;
}

Answer 1

It seems you made a small but fatal error. The type of http_code should be long instead of int. Apparently, the call to curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &http_code) overwrote the memory used by url on CentOS. Making this change fixed the crash on CentOS for me. Please be aware that long on 64-bit Linux is 8 bytes, longer than int.

Answer 2

Probably the bug is not in the code you posted. It might be that you sometimes pass an invalid CURL* handle.
I checked this and indeed, if you pass an invalid handle, the function curl_easy_getinfo still returns CURLE_OK. A segmentation fault occurs later if you try to access the char* url variable. The propgram (compile with g++ main.cpp -lcurl)
#include <iostream>
#include <curl/curl.h>
using namespace std;
int main(void){
char* url;
CURL *handle;
handle=curl_easy_init();
curl_easy_setopt(handle, CURLOPT_URL, "http://www.example.com");
CURL *bug=(CURL*)((long)(handle)+1);
CURLcode code= curl_easy_getinfo(bug, CURLINFO_EFFECTIVE_URL, &url);
cout<<"CURLE_OK="<<CURLE_OK<< " and code="<<code<<endl;
cout <<"URL: "<<url; //This line causes segmentation fault;
curl_easy_cleanup(handle);
return EXIT_SUCCESS;
}
produces something like:
CURLE_OK=0 and code=0
Program received signal SIGSEGV, Segmentation fault.