curl_easy_perform segmentation fault on Linux

Question

I am working on a c++ app which uses curl in order to an HTTP GET request. It works perfectly fine on Windows but on Linux (CentOS 7) I get a segmentation fault when curl_easy_cleanup is used.

Below is my code

CURL* curl = NULL;
    curl = curl_easy_init();

    if (curl == NULL)
    {

        this->getBitsLibrary()->writeToLog("Failed to init curl");
        this->getBitsLibrary()->setAlarm("CrashInfo", Alarms::AlarmLevel::Critical, "Failed to init curl for IP lookup");
        return;
    }

    stringstream urlstream;
    string iplookupURL;
    //curlResponse = "";
    urlstream << StaticSettings::IP_Lookup::ipLookupURL << "/" << clientIP << "?access_key="<<StaticSettings::IP_Lookup::api_key;
    iplookupURL = urlstream.str();
    logstream << "Using URL " << iplookupURL << " for IP lookup";
    this->getBitsLibrary()->writeToLog(logstream.str(), "CrashInfo", "performIPLookup");
    logstream.clear();
    logstream.str(string());
    //string response = "";
    this->curlResponse = new string();
    curl_easy_setopt(curl, CURLOPT_URL, iplookupURL.c_str());
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)this);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curlStaticCallback);



    CURLcode res = curl_easy_perform(curl);
if (res != CURLE_OK)
    {
        logstream << "Failed to perform IP lookup using curl";
        this->getBitsLibrary()->writeToLog(logstream.str(), "CrashInfo", "performIPLookup");
        this->getBitsLibrary()->setAlarm("CrashInfo", Alarms::AlarmLevel::Warning, "Failed to perform IP Lookup. Curl error");
        curl_easy_cleanup(curl);
        return;
    }

    int httpResponseCode = 0;
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpResponseCode);
    if (httpResponseCode == 200)
    {

        if (!this->curlResponse->empty())
        {
            this->getBitsLibrary()->writeToLog("Processing response for IP lookup");
            rapidjson::Document jsonObject;
            jsonObject.Parse(this->curlResponse->c_str());

            const rapidjson::Value& countryValue = jsonObject["country_name"];
            if (!countryValue.IsNull())
            {
                string country = string(jsonObject["country_name"].GetString());
                this->setCountry(!country.empty() ? country : "N/A");
            }
            else
            {
                this->setCountry("N/A");
            }

            const rapidjson::Value& cityValue = jsonObject["city"];
            if (!cityValue.IsNull())
            {
                string city = string(jsonObject["city"].GetString());
                this->setCity(!city.empty() ? city : "N/A");
            }
            else
            {
                this->setCity("N/A");
            }

            this->getBitsLibrary()->writeToLog("IPLookup performed successfully", "CrashInfo", "performIPLookup");
        }
delete this->curlResponse;
    this->curlResponse = NULL;
    curl_easy_cleanup(curl);

Due the curl being a C library, I've created a static function (outside of the C++ class) as follows:

size_t curlStaticCallback(void *contents, size_t size, size_t nmemb, void * userp)
{
    CrashInfo *crashInfo = (CrashInfo*)userp;
    crashInfo->curlResponseWriteCallback(contents, size, nmemb, userp);
    return size * nmemb;
}

The above static function called by the WRITEFUNCTION in curl. I get the class object and then call the C++ function which is as follows:

size_t CrashInfo::curlResponseWriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
    curlResponse->append((char*)contents, size * nmemb);
    return size * nmemb;
}

As mentioned above, this works perfectly fine on Windows but on Linux it works fine where I get the expected response the URL, but when curl_easy_cleanup is called I then get a segmentation fault which contains the following stack:

#0  0x00007fe7f45ff2ad in ?? () from /lib64/libstdc++.so.6
#1  0x00007fe7f4661c03 in std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string() () from /lib64/libstdc++.so.6
#2  0x000000000043f773 in WebManager::CrashInfo::performIPLookup (this=0x7fe7d00020d0, clientIP="192.168.1.96") at CrashInfo.cpp:732
#3  0x000000000043aeb0 in WebManager::CrashInfo::processCrashInfo (this=0x7fe7d00020d0, httpRequest=0x7fe7d00008f0) at CrashInfo.cpp:308
#4  0x00000000004396ee in WebManager::CrashInfo::CrashInfo (this=0x7fe7d00020d0, httpRequest=0x7fe7d00008f0) at CrashInfo.cpp:50
#5  0x000000000046ce23 in WebManager::WebProcessor::processWebSocketData (this=0x7fe7ed841a60, clientpointer=0x7fe7e40008c0, ipAddress=0x7fe7ed8426b8 "192.168.1.96") at WebProcessor.cpp:71
#6  0x0000000000473bd6 in std::_Mem_fn<void (WebManager::WebProcessor::*)(void*, char*)>::operator()<int*, char*, void>(WebManager::WebProcessor*, int*&&, char*&&) const (this=0x7fe7e4000948, __object=0x7fe7ed841a60)
    at /usr/include/c++/4.8.2/functional:601
#7  0x00000000004739fd in std::_Bind_simple<std::_Mem_fn<void (WebManager::WebProcessor::*)(void*, char*)> (WebManager::WebProcessor*, int*, char*)>::_M_invoke<0ul, 1ul, 2ul>(std::_Index_tuple<0ul, 1ul, 2ul>) (this=0x7fe7e4000930)
    at /usr/include/c++/4.8.2/functional:1732
#8  0x00000000004737fd in std::_Bind_simple<std::_Mem_fn<void (WebManager::WebProcessor::*)(void*, char*)> (WebManager::WebProcessor*, int*, char*)>::operator()() (this=0x7fe7e4000930) at /usr/include/c++/4.8.2/functional:1720
#9  0x000000000047372e in std::thread::_Impl<std::_Bind_simple<std::_Mem_fn<void (WebManager::WebProcessor::*)(void*, char*)> (WebManager::WebProcessor*, int*, char*)> >::_M_run() (this=0x7fe7e4000918)
    at /usr/include/c++/4.8.2/thread:115
#10 0x00007fe7f4659070 in ?? () from /lib64/libstdc++.so.6
#11 0x00007fe7f3aaae25 in start_thread () from /lib64/libpthread.so.0
#12 0x00007fe7f3dbdbad in clone () from /lib64/libc.so.6

I've stepped through in GDB watching the memory location for Curl to see if something unexpectedly rights/corrupts to it but it doesn't look like there's any issues.

Answer 1

I've figured the issues, it was rather odd one. As Michael Doubez said in the comments it wasn't directly curl. I thought it was curl because the 2nd line in the stack track was pointing to the curl_easy_cleanup and then the top line was the string destructor so thought it was curl.

I put a log line after the curl_easy_cleanup and it logged successfully and then crashed. The curl_easy_cleanup was the last call in the method and it was when the function finished the crash happened.

I ended up commenting out the entire function and then slowly re-add chunks of it to nail down at what point it caused it to crash.

It ended up being the line curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpResponseCode); . I was passing in a pointer to an int when the function wants a pointer to a long.

I corrected the above and now everything works as expected, not entirely sure why though this didn't 1, raise a compiler warning that was I passing in the wrong type, and 2, why the stack trace was showing a string being destructed.