curl_easy_perform buffer overflow - c++

Question

My problem is that in one part of my program a double variable gets incorrectly set to 2.71179e-308 on one specific (virtual) computer (not any other). No crashes or anything like that. After much work I narrowed the problem down to a call to curl_easy_perform (the call has no other connection with said variable). If I fake the curl_easy_perform call and return before it executes the variable is not modified.
My first thought was that there was some problem with the callback write function, but having looked long and hard at it I can't find anything wrong, and replacing it with an empty function still didn't help the error.
My second thought was that perhaps my curl settings strings went out of scope before being used, but in my version of curl (7.43.0) they should be copied and stored by curl itself.
Now I'm at wits end and so turn to SO for some sort of hint at what could be wrong. This is the code for the class I use for all communication;
Header:
#include <string>
class HTTPClient
{
public:
enum Verb
{
V_GET,
V_POST,
V_PUT,
V_DELETE,
};
// Constructor is not thread safe. Make sure to initialize in main thread.
HTTPClient(const std::string& userAgent, const std::string& certPath, const std::string& cookieFile, const std::string& proxy = "");
~HTTPClient(void);
int MakeRequest(Verb verb, const std::string& url, int& responseCode, std::string& response);
private:
static size_t WriteFunction(void *ptr, size_t size, size_t nmemb, void *custom);
void* m_curl;
};
Source:
#include "HTTPClient.h"
#include <curl/curl.h>
HTTPClient::HTTPClient(const std::string& userAgent, const std::string& certPath, const std::string& cookieFile, const std::string& proxy)
{
curl_global_init(CURL_GLOBAL_DEFAULT);
m_curl = curl_easy_init();
if (m_curl)
{
// Indicate where the certificate is located
curl_easy_setopt(m_curl, CURLOPT_CAINFO, certPath.c_str());
// Indicate where the cookie file is located
curl_easy_setopt(m_curl, CURLOPT_COOKIEFILE, cookieFile.c_str());
curl_easy_setopt(m_curl, CURLOPT_COOKIEJAR, cookieFile.c_str());
// Set user agent
curl_easy_setopt(m_curl, CURLOPT_USERAGENT, userAgent.c_str());
// Set the response function
curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, &HTTPClient::WriteFunction);
// Set proxy if specified
if (!proxy.empty())
curl_easy_setopt(m_curl, CURLOPT_PROXY, proxy.c_str());
}
}
HTTPClient::~HTTPClient(void)
{
if (m_curl)
curl_easy_cleanup(m_curl);
curl_global_cleanup();
}
int HTTPClient::MakeRequest(Verb verb, const std::string& url, int& responseCode, std::string& response)
{
std::string protocol, server, path, parameters;
if (!m_curl)
return CURLE_FAILED_INIT;
// Set response data
response.clear();
curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, &response);
switch (verb)
{
case V_GET:
curl_easy_setopt(m_curl, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(m_curl, CURLOPT_URL, url.c_str());
break;
// Other cases removed for brevity
}
// Execute command
CURLcode res = curl_easy_perform(m_curl); // <-- When this executes the variable gets damaged
// Get response code
long code;
curl_easy_getinfo(m_curl, CURLINFO_RESPONSE_CODE, &code);
responseCode = code;
return res;
}
size_t HTTPClient::WriteFunction(void *ptr, size_t size, size_t nmemb, void *custom)
{
size_t full_size = size * nmemb;
std::string* p_response = reinterpret_cast<std::string*>(custom);
p_response->reserve(full_size);
for (size_t i=0; i<full_size; ++i)
{
char c = reinterpret_cast<char*>(ptr)[i];
p_response->push_back(c);
}
return full_size;
}
Edit:
I have now run tests with WinDbg and have found out pretty much what happens (but not how to solve the problem).
The double that is trashed is in the release build put in the mmx7 register. It then sits there without being changed until curl_easy_perform is called but before the WriteFunction is called by curl_easy_perform.
Other than compiling my own version of curl so I can debug deeper I don't know how to get past this problem.