Reduce indentation of HTTPFetchOngoing

Also clean up some related things.

diff --git a/src/clientmedia.cpp b/src/clientmedia.cpp
index c1043c76915533be036f119612a74bf5d5219866..e2679ed46301e4902d36b997a7274d5f15750a7c 100644 (file)
--- a/src/clientmedia.cpp
+++ b/src/clientmedia.cpp
@@ -140,17 +140,17 @@ void ClientMediaDownloader::step(Client *client)
        // Remote media: check for completion of fetches
        if (m_httpfetch_active) {
                bool fetched_something = false;
-               HTTPFetchResult fetchresult;
+               HTTPFetchResult fetch_result;
 
-               while (httpfetch_async_get(m_httpfetch_caller, fetchresult)) {
+               while (httpfetch_async_get(m_httpfetch_caller, fetch_result)) {
                        m_httpfetch_active--;
                        fetched_something = true;
 
                        // Is this a hashset (index.mth) or a media file?
-                       if (fetchresult.request_id < m_remotes.size())
-                               remoteHashSetReceived(fetchresult);
+                       if (fetch_result.request_id < m_remotes.size())
+                               remoteHashSetReceived(fetch_result);
                        else
-                               remoteMediaReceived(fetchresult, client);
+                               remoteMediaReceived(fetch_result, client);
                }
 
                if (fetched_something)
@@ -259,17 +259,17 @@ void ClientMediaDownloader::initialStep(Client *client)
                        actionstream << "Client: Contacting remote server \""
                                << remote->baseurl << "\"" << std::endl;
 
-                       HTTPFetchRequest fetchrequest;
-                       fetchrequest.url =
+                       HTTPFetchRequest fetch_request;
+                       fetch_request.url =
                                remote->baseurl + MTHASHSET_FILE_NAME;
-                       fetchrequest.caller = m_httpfetch_caller;
-                       fetchrequest.request_id = m_httpfetch_next_id; // == i
-                       fetchrequest.timeout = m_httpfetch_timeout;
-                       fetchrequest.connect_timeout = m_httpfetch_timeout;
-                       fetchrequest.post_data = required_hash_set;
-                       fetchrequest.extra_headers.push_back(
+                       fetch_request.caller = m_httpfetch_caller;
+                       fetch_request.request_id = m_httpfetch_next_id; // == i
+                       fetch_request.timeout = m_httpfetch_timeout;
+                       fetch_request.connect_timeout = m_httpfetch_timeout;
+                       fetch_request.post_data = required_hash_set;
+                       fetch_request.extra_headers.push_back(
                                "Content-Type: application/octet-stream");
-                       httpfetch_async(fetchrequest);
+                       httpfetch_async(fetch_request);
 
                        m_httpfetch_active++;
                        m_httpfetch_next_id++;
@@ -279,21 +279,21 @@ void ClientMediaDownloader::initialStep(Client *client)
 }
 
 void ClientMediaDownloader::remoteHashSetReceived(
-               const HTTPFetchResult &fetchresult)
+               const HTTPFetchResult &fetch_result)
 {
-       u32 remote_id = fetchresult.request_id;
+       u32 remote_id = fetch_result.request_id;
        assert(remote_id < m_remotes.size());
        RemoteServerStatus *remote = m_remotes[remote_id];
 
        m_outstanding_hash_sets--;
 
-       if (fetchresult.succeeded) {
+       if (fetch_result.succeeded) {
                try {
                        // Server sent a list of file hashes that are
                        // available on it, try to parse the list
 
                        std::set<std::string> sha1_set;
-                       deSerializeHashSet(fetchresult.data, sha1_set);
+                       deSerializeHashSet(fetch_result.data, sha1_set);
 
                        // Parsing succeeded: For every file that is
                        // available on this server, add this server
@@ -320,7 +320,7 @@ void ClientMediaDownloader::remoteHashSetReceived(
        // Do NOT check for any particular response code (e.g. 404) here,
        // because different servers respond differently
 
-       if (!fetchresult.succeeded && !fetchresult.timeout) {
+       if (!fetch_result.succeeded && !fetch_result.timeout) {
                infostream << "Client: Enabling compatibility mode for remote "
                        << "server \"" << remote->baseurl << "\"" << std::endl;
                remote->request_by_filename = true;
@@ -338,7 +338,7 @@ void ClientMediaDownloader::remoteHashSetReceived(
 }
 
 void ClientMediaDownloader::remoteMediaReceived(
-               const HTTPFetchResult &fetchresult,
+               const HTTPFetchResult &fetch_result,
                Client *client)
 {
        // Some remote server sent us a file.
@@ -349,7 +349,7 @@ void ClientMediaDownloader::remoteMediaReceived(
        std::string name;
        {
                std::map<unsigned long, std::string>::iterator it =
-                       m_remote_file_transfers.find(fetchresult.request_id);
+                       m_remote_file_transfers.find(fetch_result.request_id);
                assert(it != m_remote_file_transfers.end());
                name = it->second;
                m_remote_file_transfers.erase(it);
@@ -368,9 +368,9 @@ void ClientMediaDownloader::remoteMediaReceived(
 
        // If fetch succeeded, try to load media file
 
-       if (fetchresult.succeeded) {
+       if (fetch_result.succeeded) {
                bool success = checkAndLoad(name, filestatus->sha1,
-                               fetchresult.data, false, client);
+                               fetch_result.data, false, client);
                if (success) {
                        filestatus->received = true;
                        assert(m_uncached_received_count < m_uncached_count);
@@ -445,14 +445,14 @@ void ClientMediaDownloader::startRemoteMediaTransfers()
                                        << "\"" << name << "\" "
                                        << "\"" << url << "\"" << std::endl;
 
-                               HTTPFetchRequest fetchrequest;
-                               fetchrequest.url = url;
-                               fetchrequest.caller = m_httpfetch_caller;
-                               fetchrequest.request_id = m_httpfetch_next_id;
-                               fetchrequest.timeout = 0; // no data timeout!
-                               fetchrequest.connect_timeout =
+                               HTTPFetchRequest fetch_request;
+                               fetch_request.url = url;
+                               fetch_request.caller = m_httpfetch_caller;
+                               fetch_request.request_id = m_httpfetch_next_id;
+                               fetch_request.timeout = 0; // no data timeout!
+                               fetch_request.connect_timeout =
                                        m_httpfetch_timeout;
-                               httpfetch_async(fetchrequest);
+                               httpfetch_async(fetch_request);
 
                                m_remote_file_transfers.insert(std::make_pair(
                                                        m_httpfetch_next_id,

diff --git a/src/clientmedia.h b/src/clientmedia.h
index 5400442394a18fcd6173e963dd0c03fe7f06251f..1f0da70d9de456ecc6ad62297a2eabb06cd7f5e5 100644 (file)
--- a/src/clientmedia.h
+++ b/src/clientmedia.h
@@ -96,8 +96,8 @@ private:
        };
 
        void initialStep(Client *client);
-       void remoteHashSetReceived(const HTTPFetchResult &fetchresult);
-       void remoteMediaReceived(const HTTPFetchResult &fetchresult,
+       void remoteHashSetReceived(const HTTPFetchResult &fetch_result);
+       void remoteMediaReceived(const HTTPFetchResult &fetch_result,
                        Client *client);
        s32 selectRemoteServer(FileStatus *filestatus);
        void startRemoteMediaTransfers();

diff --git a/src/convert_json.cpp b/src/convert_json.cpp
index c5c69d93c32979d364b709f61df28c61908c5e58..cea0896239d7b1ed9322abeeedb8252d0f52c003 100644 (file)
--- a/src/convert_json.cpp
+++ b/src/convert_json.cpp
@@ -30,45 +30,34 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "httpfetch.h"
 #include "porting.h"
 
-Json::Value                 fetchJsonValue(const std::string &url,
-               std::vector<std::string> *extra_headers) {
-
-       HTTPFetchRequest fetchrequest;
-       HTTPFetchResult fetchresult;
-       fetchrequest.url = url;
-       fetchrequest.caller = HTTPFETCH_SYNC;
+Json::Value fetchJsonValue(const std::string &url,
+               std::vector<std::string> *extra_headers)
+{
+       HTTPFetchRequest fetch_request;
+       HTTPFetchResult fetch_result;
+       fetch_request.url = url;
+       fetch_request.caller = HTTPFETCH_SYNC;
 
        if (extra_headers != NULL)
-               fetchrequest.extra_headers = *extra_headers;
+               fetch_request.extra_headers = *extra_headers;
 
-       httpfetch_sync(fetchrequest,fetchresult);
+       httpfetch_sync(fetch_request, fetch_result);
 
-       if (!fetchresult.succeeded) {
+       if (!fetch_result.succeeded) {
                return Json::Value();
        }
        Json::Value root;
        Json::Reader reader;
-       std::istringstream stream(fetchresult.data);
+       std::istringstream stream(fetch_result.data);
 
-       if (!reader.parse( stream, root ) )
-       {
+       if (!reader.parse(stream, root)) {
                errorstream << "URL: " << url << std::endl;
                errorstream << "Failed to parse json data " << reader.getFormattedErrorMessages();
-               errorstream << "data: \"" << fetchresult.data << "\"" << std::endl;
+               errorstream << "data: \"" << fetch_result.data << "\"" << std::endl;
                return Json::Value();
        }
 
-       if (root.isArray()) {
-               return root;
-       }
-       if ((root["list"].isArray())) {
-               return root["list"];
-       }
-       else {
-               return root;
-       }
-
-       return Json::Value();
+       return root;
 }
 
 std::vector<ModStoreMod>    readModStoreList(Json::Value& modlist) {

diff --git a/src/guiEngine.cpp b/src/guiEngine.cpp
index 0a1d722069ebd6c573bf5381b9839e14a0693057..03b2766d86ab4148fc04aab81a5ad2644fa72de1 100644 (file)
--- a/src/guiEngine.cpp
+++ b/src/guiEngine.cpp
@@ -528,27 +528,26 @@ bool GUIEngine::setTexture(texture_layer layer, std::string texturepath,
 }
 
 /******************************************************************************/
-bool GUIEngine::downloadFile(std::string url,std::string target)
+bool GUIEngine::downloadFile(std::string url, std::string target)
 {
 #if USE_CURL
-       std::ofstream targetfile(target.c_str(), std::ios::out | std::ios::binary);
+       std::ofstream target_file(target.c_str(), std::ios::out | std::ios::binary);
 
-       if (!targetfile.good()) {
+       if (!target_file.good()) {
                return false;
        }
 
-       HTTPFetchRequest fetchrequest;
-       HTTPFetchResult fetchresult;
-       fetchrequest.url = url;
-       fetchrequest.caller = HTTPFETCH_SYNC;
-       fetchrequest.timeout = g_settings->getS32("curl_file_download_timeout");
-       httpfetch_sync(fetchrequest, fetchresult);
+       HTTPFetchRequest fetch_request;
+       HTTPFetchResult fetch_result;
+       fetch_request.url = url;
+       fetch_request.caller = HTTPFETCH_SYNC;
+       fetch_request.timeout = g_settings->getS32("curl_file_download_timeout");
+       httpfetch_sync(fetch_request, fetch_result);
 
-       if (fetchresult.succeeded) {
-               targetfile << fetchresult.data;
-       } else {
+       if (!fetch_result.succeeded) {
                return false;
        }
+       target_file << fetch_result.data;
 
        return true;
 #else

diff --git a/src/httpfetch.cpp b/src/httpfetch.cpp
index c651055bca5364c969352f10ea139836c7f03c11..f61dbbf71a1d473ba4f6ea3294b4405511b06ab9 100644 (file)
--- a/src/httpfetch.cpp
+++ b/src/httpfetch.cpp
@@ -52,12 +52,12 @@ HTTPFetchRequest::HTTPFetchRequest()
 }
 
 
-static void httpfetch_deliver_result(const HTTPFetchResult &fetchresult)
+static void httpfetch_deliver_result(const HTTPFetchResult &fetch_result)
 {
-       unsigned long caller = fetchresult.caller;
+       unsigned long caller = fetch_result.caller;
        if (caller != HTTPFETCH_DISCARD) {
                JMutexAutoLock lock(g_httpfetch_mutex);
-               g_httpfetch_results[caller].push_back(fetchresult);
+               g_httpfetch_results[caller].push_back(fetch_result);
        }
 }
 
@@ -97,7 +97,7 @@ void httpfetch_caller_free(unsigned long caller)
        }
 }
 
-bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetchresult)
+bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetch_result)
 {
        JMutexAutoLock lock(g_httpfetch_mutex);
 
@@ -108,13 +108,13 @@ bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetchresult)
                return false;
 
        // Check that result queue is nonempty
-       std::list<HTTPFetchResult> &callerresults = it->second;
-       if (callerresults.empty())
+       std::list<HTTPFetchResult> &caller_results = it->second;
+       if (caller_results.empty())
                return false;
 
        // Pop first result
-       fetchresult = callerresults.front();
-       callerresults.pop_front();
+       fetch_result = caller_results.front();
+       caller_results.pop_front();
        return true;
 }
 
@@ -175,8 +175,19 @@ public:
        }
 };
 
-struct HTTPFetchOngoing
+class HTTPFetchOngoing
 {
+public:
+       HTTPFetchOngoing(HTTPFetchRequest request, CurlHandlePool *pool);
+       ~HTTPFetchOngoing();
+
+       CURLcode start(CURLM *multi);
+       const HTTPFetchResult * complete(CURLcode res);
+
+       const HTTPFetchRequest &getRequest()    const { return request; };
+       const CURL             *getEasyHandle() const { return curl; };
+
+private:
        CurlHandlePool *pool;
        CURL *curl;
        CURLM *multi;
@@ -184,201 +195,200 @@ struct HTTPFetchOngoing
        HTTPFetchResult result;
        std::ostringstream oss;
        char *post_fields;
-       struct curl_slist *httpheader;
+       struct curl_slist *http_header;
        curl_httppost *post;
+};
 
-       HTTPFetchOngoing(HTTPFetchRequest request_, CurlHandlePool *pool_):
-               pool(pool_),
-               curl(NULL),
-               multi(NULL),
-               request(request_),
-               result(request_),
-               oss(std::ios::binary),
-               httpheader(NULL),
-               post(NULL)
-       {
-               curl = pool->alloc();
-               if (curl != NULL) {
-                       // Set static cURL options
-                       curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
-                       curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
-                       curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
-                       curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 1);
 
-#if LIBCURL_VERSION_NUM >= 0x071304
-                       // Restrict protocols so that curl vulnerabilities in
-                       // other protocols don't affect us.
-                       // These settings were introduced in curl 7.19.4.
-                       long protocols =
-                               CURLPROTO_HTTP |
-                               CURLPROTO_HTTPS |
-                               CURLPROTO_FTP |
-                               CURLPROTO_FTPS;
-                       curl_easy_setopt(curl, CURLOPT_PROTOCOLS, protocols);
-                       curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, protocols);
-#endif
+HTTPFetchOngoing::HTTPFetchOngoing(HTTPFetchRequest request_, CurlHandlePool *pool_):
+       pool(pool_),
+       curl(NULL),
+       multi(NULL),
+       request(request_),
+       result(request_),
+       oss(std::ios::binary),
+       http_header(NULL),
+       post(NULL)
+{
+       curl = pool->alloc();
+       if (curl == NULL) {
+               return;
+       }
 
-                       // Set cURL options based on HTTPFetchRequest
-                       curl_easy_setopt(curl, CURLOPT_URL,
-                                       request.url.c_str());
-                       curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS,
-                                       request.timeout);
-                       curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS,
-                                       request.connect_timeout);
-
-                       if (request.useragent != "")
-                               curl_easy_setopt(curl, CURLOPT_USERAGENT, request.useragent.c_str());
-
-                       // Set up a write callback that writes to the
-                       // ostringstream ongoing->oss, unless the data
-                       // is to be discarded
-                       if (request.caller == HTTPFETCH_DISCARD) {
-                               curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                                               httpfetch_discardfunction);
-                               curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);
-                       }
-                       else {
-                               curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                                               httpfetch_writefunction);
-                               curl_easy_setopt(curl, CURLOPT_WRITEDATA, &oss);
-                       }
+       // Set static cURL options
+       curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
+       curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
+       curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+       curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 1);
 
-                       // Set POST (or GET) data
-                       if (request.post_fields.empty()) {
-                               curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
-                       } else if (request.multipart) {
-                               curl_httppost *last = NULL;
-                               for (std::map<std::string, std::string>::iterator it =
-                                                       request.post_fields.begin();
-                                               it != request.post_fields.end();
-                                               ++it) {
-                                       curl_formadd(&post, &last,
-                                                       CURLFORM_NAMELENGTH, it->first.size(),
-                                                       CURLFORM_PTRNAME, it->first.c_str(),
-                                                       CURLFORM_CONTENTSLENGTH, it->second.size(),
-                                                       CURLFORM_PTRCONTENTS, it->second.c_str(),
-                                                       CURLFORM_END);
-                               }
-                               curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
-                               // request.post_fields must now *never* be
-                               // modified until CURLOPT_HTTPPOST is cleared
-                       } else {
-                               curl_easy_setopt(curl, CURLOPT_POST, 1);
-                               if (request.post_data.empty()) {
-                                       std::string str;
-                                       for (std::map<std::string, std::string>::iterator it =
-                                                               request.post_fields.begin();
-                                                       it != request.post_fields.end();
-                                                       ++it) {
-                                               if (str != "")
-                                                       str += "&";
-                                               str += urlencode(it->first);
-                                               str += "=";
-                                               str += urlencode(it->second);
-                                       }
-                                       curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE,
-                                                       str.size());
-                                       curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS,
-                                                       str.c_str());
-                               } else {
-                                       curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE,
-                                                       request.post_data.size());
-                                       curl_easy_setopt(curl, CURLOPT_POSTFIELDS,
-                                                       request.post_data.c_str());
-                                       // request.post_data must now *never* be
-                                       // modified until CURLOPT_POSTFIELDS is cleared
-                               }
-                       }
-                       // Set additional HTTP headers
-                       for (size_t i = 0; i < request.extra_headers.size(); ++i) {
-                               httpheader = curl_slist_append(
-                                       httpheader,
-                                       request.extra_headers[i].c_str());
-                       }
-                       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, httpheader);
+#if LIBCURL_VERSION_NUM >= 0x071304
+       // Restrict protocols so that curl vulnerabilities in
+       // other protocols don't affect us.
+       // These settings were introduced in curl 7.19.4.
+       long protocols =
+               CURLPROTO_HTTP |
+               CURLPROTO_HTTPS |
+               CURLPROTO_FTP |
+               CURLPROTO_FTPS;
+       curl_easy_setopt(curl, CURLOPT_PROTOCOLS, protocols);
+       curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, protocols);
+#endif
 
-                       if (!g_settings->getBool("curl_verify_cert")) {
-                               curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
-                       }
-               }
+       // Set cURL options based on HTTPFetchRequest
+       curl_easy_setopt(curl, CURLOPT_URL,
+                       request.url.c_str());
+       curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS,
+                       request.timeout);
+       curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS,
+                       request.connect_timeout);
+
+       if (request.useragent != "")
+               curl_easy_setopt(curl, CURLOPT_USERAGENT, request.useragent.c_str());
+
+       // Set up a write callback that writes to the
+       // ostringstream ongoing->oss, unless the data
+       // is to be discarded
+       if (request.caller == HTTPFETCH_DISCARD) {
+               curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                               httpfetch_discardfunction);
+               curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);
+       } else {
+               curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                               httpfetch_writefunction);
+               curl_easy_setopt(curl, CURLOPT_WRITEDATA, &oss);
        }
 
-       CURLcode start(CURLM *multi_)
-       {
-               if (curl == NULL)
-                       return CURLE_FAILED_INIT;
-
-               if (multi_) {
-                       // Multi interface (async)
-                       CURLMcode mres = curl_multi_add_handle(multi_, curl);
-                       if (mres != CURLM_OK) {
-                               errorstream<<"curl_multi_add_handle"
-                                       <<" returned error code "<<mres
-                                       <<std::endl;
-                               return CURLE_FAILED_INIT;
-                       }
-                       multi = multi_; // store for curl_multi_remove_handle
-                       return CURLE_OK;
+       // Set POST (or GET) data
+       if (request.post_fields.empty()) {
+               curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
+       } else if (request.multipart) {
+               curl_httppost *last = NULL;
+               for (std::map<std::string, std::string>::iterator it =
+                                       request.post_fields.begin();
+                               it != request.post_fields.end(); ++it) {
+                       curl_formadd(&post, &last,
+                                       CURLFORM_NAMELENGTH, it->first.size(),
+                                       CURLFORM_PTRNAME, it->first.c_str(),
+                                       CURLFORM_CONTENTSLENGTH, it->second.size(),
+                                       CURLFORM_PTRCONTENTS, it->second.c_str(),
+                                       CURLFORM_END);
                }
-               else {
-                       // Easy interface (sync)
-                       return curl_easy_perform(curl);
+               curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
+               // request.post_fields must now *never* be
+               // modified until CURLOPT_HTTPPOST is cleared
+       } else if (request.post_data.empty()) {
+               curl_easy_setopt(curl, CURLOPT_POST, 1);
+               std::string str;
+               for (std::map<std::string, std::string>::iterator it =
+                                       request.post_fields.begin();
+                               it != request.post_fields.end();
+                               ++it) {
+                       if (str != "")
+                               str += "&";
+                       str += urlencode(it->first);
+                       str += "=";
+                       str += urlencode(it->second);
                }
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE,
+                               str.size());
+               curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS,
+                               str.c_str());
+       } else {
+               curl_easy_setopt(curl, CURLOPT_POST, 1);
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE,
+                               request.post_data.size());
+               curl_easy_setopt(curl, CURLOPT_POSTFIELDS,
+                               request.post_data.c_str());
+               // request.post_data must now *never* be
+               // modified until CURLOPT_POSTFIELDS is cleared
+       }
+       // Set additional HTTP headers
+       for (std::vector<std::string>::iterator it = request.extra_headers.begin();
+                       it != request.extra_headers.end(); ++it) {
+               http_header = curl_slist_append(http_header, it->c_str());
        }
+       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
 
-       void complete(CURLcode res)
-       {
-               result.succeeded = (res == CURLE_OK);
-               result.timeout = (res == CURLE_OPERATION_TIMEDOUT);
-               result.data = oss.str();
+       if (!g_settings->getBool("curl_verify_cert")) {
+               curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
+       }
+}
+
+CURLcode HTTPFetchOngoing::start(CURLM *multi_)
+{
+       if (!curl)
+               return CURLE_FAILED_INIT;
+
+       if (!multi_) {
+               // Easy interface (sync)
+               return curl_easy_perform(curl);
+       }
 
-               // Get HTTP/FTP response code
+       // Multi interface (async)
+       CURLMcode mres = curl_multi_add_handle(multi_, curl);
+       if (mres != CURLM_OK) {
+               errorstream << "curl_multi_add_handle"
+                       << " returned error code " << mres
+                       << std::endl;
+               return CURLE_FAILED_INIT;
+       }
+       multi = multi_; // store for curl_multi_remove_handle
+       return CURLE_OK;
+}
+
+const HTTPFetchResult * HTTPFetchOngoing::complete(CURLcode res)
+{
+       result.succeeded = (res == CURLE_OK);
+       result.timeout = (res == CURLE_OPERATION_TIMEDOUT);
+       result.data = oss.str();
+
+       // Get HTTP/FTP response code
+       result.response_code = 0;
+       if (curl && (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE,
+                               &result.response_code) != CURLE_OK)) {
+               // We failed to get a return code, make sure it is still 0
                result.response_code = 0;
-               if (curl != NULL) {
-                       if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE,
-                                       &result.response_code) != CURLE_OK) {
-                               //we failed to get a return code make sure it is still 0
-                               result.response_code = 0;
-                       }
-               }
+       }
 
-               if (res != CURLE_OK) {
-                       errorstream<<request.url<<" not found ("
-                               <<curl_easy_strerror(res)<<")"
-                               <<" (response code "<<result.response_code<<")"
-                               <<std::endl;
-               }
+       if (res != CURLE_OK) {
+               errorstream << request.url << " not found ("
+                       << curl_easy_strerror(res) << ")"
+                       << " (response code " << result.response_code << ")"
+                       << std::endl;
        }
 
-       ~HTTPFetchOngoing()
-       {
-               if (multi != NULL) {
-                       CURLMcode mres = curl_multi_remove_handle(multi, curl);
-                       if (mres != CURLM_OK) {
-                               errorstream<<"curl_multi_remove_handle"
-                                       <<" returned error code "<<mres
-                                       <<std::endl;
-                       }
-               }
+       return &result;
+}
 
-               // Set safe options for the reusable cURL handle
-               curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                               httpfetch_discardfunction);
-               curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);
-               curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
-               if (httpheader != NULL) {
-                       curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);
-                       curl_slist_free_all(httpheader);
-               }
-               if (post != NULL) {
-                       curl_easy_setopt(curl, CURLOPT_HTTPPOST, NULL);
-                       curl_formfree(post);
+HTTPFetchOngoing::~HTTPFetchOngoing()
+{
+       if (multi) {
+               CURLMcode mres = curl_multi_remove_handle(multi, curl);
+               if (mres != CURLM_OK) {
+                       errorstream << "curl_multi_remove_handle"
+                               << " returned error code " << mres
+                               << std::endl;
                }
+       }
 
-               // Store the cURL handle for reuse
-               pool->free(curl);
+       // Set safe options for the reusable cURL handle
+       curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                       httpfetch_discardfunction);
+       curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);
+       curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
+       if (http_header) {
+               curl_easy_setopt(curl, CURLOPT_HTTPHEADER, NULL);
+               curl_slist_free_all(http_header);
        }
-};
+       if (post) {
+               curl_easy_setopt(curl, CURLOPT_HTTPPOST, NULL);
+               curl_formfree(post);
+       }
+
+       // Store the cURL handle for reuse
+       pool->free(curl);
+}
+
 
 class CurlFetchThread : public JThread
 {
@@ -391,7 +401,7 @@ protected:
 
        struct Request {
                RequestType type;
-               HTTPFetchRequest fetchrequest;
+               HTTPFetchRequest fetch_request;
                Event *event;
        };
 
@@ -412,11 +422,11 @@ public:
                        m_parallel_limit = 1;
        }
 
-       void requestFetch(const HTTPFetchRequest &fetchrequest)
+       void requestFetch(const HTTPFetchRequest &fetch_request)
        {
                Request req;
                req.type = RT_FETCH;
-               req.fetchrequest = fetchrequest;
+               req.fetch_request = fetch_request;
                req.event = NULL;
                m_requests.push_back(req);
        }
@@ -425,7 +435,7 @@ public:
        {
                Request req;
                req.type = RT_CLEAR;
-               req.fetchrequest.caller = caller;
+               req.fetch_request.caller = caller;
                req.event = event;
                m_requests.push_back(req);
        }
@@ -446,24 +456,24 @@ protected:
                if (req.type == RT_FETCH) {
                        // New fetch, queue until there are less
                        // than m_parallel_limit ongoing fetches
-                       m_queued_fetches.push_back(req.fetchrequest);
+                       m_queued_fetches.push_back(req.fetch_request);
 
                        // see processQueued() for what happens next
 
                }
                else if (req.type == RT_CLEAR) {
-                       unsigned long caller = req.fetchrequest.caller;
+                       unsigned long caller = req.fetch_request.caller;
 
                        // Abort all ongoing fetches for the caller
                        for (std::vector<HTTPFetchOngoing*>::iterator
                                        it = m_all_ongoing.begin();
                                        it != m_all_ongoing.end();) {
-                               if ((*it)->request.caller == caller) {
+                               if ((*it)->getRequest().caller == caller) {
                                        delete (*it);
                                        it = m_all_ongoing.erase(it);
-                               }
-                               else
+                               } else {
                                        ++it;
+                               }
                        }
 
                        // Also abort all queued fetches for the caller
@@ -503,8 +513,7 @@ protected:
                                m_all_ongoing.push_back(ongoing);
                        }
                        else {
-                               ongoing->complete(res);
-                               httpfetch_deliver_result(ongoing->result);
+                               httpfetch_deliver_result(*ongoing->complete(res));
                                delete ongoing;
                        }
                }
@@ -517,7 +526,7 @@ protected:
                size_t i = 0;
                bool found = false;
                for (i = 0; i < m_all_ongoing.size(); ++i) {
-                       if (m_all_ongoing[i]->curl == msg->easy_handle) {
+                       if (m_all_ongoing[i]->getEasyHandle() == msg->easy_handle) {
                                found = true;
                                break;
                        }
@@ -525,8 +534,7 @@ protected:
                if (msg->msg == CURLMSG_DONE && found) {
                        // m_all_ongoing[i] succeeded or failed.
                        HTTPFetchOngoing *ongoing = m_all_ongoing[i];
-                       ongoing->complete(msg->data.result);
-                       httpfetch_deliver_result(ongoing->result);
+                       httpfetch_deliver_result(*ongoing->complete(msg->data.result));
                        delete ongoing;
                        m_all_ongoing.erase(m_all_ongoing.begin() + i);
                }
@@ -719,9 +727,9 @@ void httpfetch_cleanup()
        curl_global_cleanup();
 }
 
-void httpfetch_async(const HTTPFetchRequest &fetchrequest)
+void httpfetch_async(const HTTPFetchRequest &fetch_request)
 {
-       g_httpfetch_thread->requestFetch(fetchrequest);
+       g_httpfetch_thread->requestFetch(fetch_request);
        if (!g_httpfetch_thread->IsRunning())
                g_httpfetch_thread->Start();
 }
@@ -738,18 +746,17 @@ static void httpfetch_request_clear(unsigned long caller)
        }
 }
 
-void httpfetch_sync(const HTTPFetchRequest &fetchrequest,
-               HTTPFetchResult &fetchresult)
+void httpfetch_sync(const HTTPFetchRequest &fetch_request,
+               HTTPFetchResult &fetch_result)
 {
        // Create ongoing fetch data and make a cURL handle
        // Set cURL options based on HTTPFetchRequest
        CurlHandlePool pool;
-       HTTPFetchOngoing ongoing(fetchrequest, &pool);
+       HTTPFetchOngoing ongoing(fetch_request, &pool);
        // Do the fetch (curl_easy_perform)
        CURLcode res = ongoing.start(NULL);
-       // Update fetchresult
-       ongoing.complete(res);
-       fetchresult = ongoing.result;
+       // Update fetch result
+       fetch_result = *ongoing.complete(res);
 }
 
 #else  // USE_CURL
@@ -768,26 +775,26 @@ void httpfetch_cleanup()
 {
 }
 
-void httpfetch_async(const HTTPFetchRequest &fetchrequest)
+void httpfetch_async(const HTTPFetchRequest &fetch_request)
 {
-       errorstream<<"httpfetch_async: unable to fetch "<<fetchrequest.url
-                       <<" because USE_CURL=0"<<std::endl;
+       errorstream << "httpfetch_async: unable to fetch " << fetch_request.url
+                       << " because USE_CURL=0" << std::endl;
 
-       HTTPFetchResult fetchresult(fetchrequest); // sets succeeded = false etc.
-       httpfetch_deliver_result(fetchresult);
+       HTTPFetchResult fetch_result(fetch_request); // sets succeeded = false etc.
+       httpfetch_deliver_result(fetch_result);
 }
 
 static void httpfetch_request_clear(unsigned long caller)
 {
 }
 
-void httpfetch_sync(const HTTPFetchRequest &fetchrequest,
-               HTTPFetchResult &fetchresult)
+void httpfetch_sync(const HTTPFetchRequest &fetch_request,
+               HTTPFetchResult &fetch_result)
 {
-       errorstream<<"httpfetch_sync: unable to fetch "<<fetchrequest.url
-                       <<" because USE_CURL=0"<<std::endl;
+       errorstream << "httpfetch_sync: unable to fetch " << fetch_request.url
+                       << " because USE_CURL=0" << std::endl;
 
-       fetchresult = HTTPFetchResult(fetchrequest); // sets succeeded = false etc.
+       fetch_result = HTTPFetchResult(fetch_request); // sets succeeded = false etc.
 }
 
 #endif  // USE_CURL

diff --git a/src/httpfetch.h b/src/httpfetch.h
index aba7482c2686339fc523976ec085f7cabfd13bcd..50a4c93d81cf3079be8f69d95f16c10264ba59ec 100644 (file)
--- a/src/httpfetch.h
+++ b/src/httpfetch.h
@@ -88,14 +88,14 @@ struct HTTPFetchResult
                request_id = 0;
        }
 
-       HTTPFetchResult(const HTTPFetchRequest &fetchrequest)
+       HTTPFetchResult(const HTTPFetchRequest &fetch_request)
        {
                succeeded = false;
                timeout = false;
                response_code = 0;
                data = "";
-               caller = fetchrequest.caller;
-               request_id = fetchrequest.request_id;
+               caller = fetch_request.caller;
+               request_id = fetch_request.request_id;
        }
 
 };
@@ -107,11 +107,11 @@ void httpfetch_init(int parallel_limit);
 void httpfetch_cleanup();
 
 // Starts an asynchronous HTTP fetch request
-void httpfetch_async(const HTTPFetchRequest &fetchrequest);
+void httpfetch_async(const HTTPFetchRequest &fetch_request);
 
 // If any fetch for the given caller ID is complete, removes it from the
-// result queue, sets fetchresult and returns true. Otherwise returns false.
-bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetchresult);
+// result queue, sets the fetch result and returns true. Otherwise returns false.
+bool httpfetch_async_get(unsigned long caller, HTTPFetchResult &fetch_result);
 
 // Allocates a caller ID for httpfetch_async
 // Not required if you want to set caller = HTTPFETCH_DISCARD
@@ -124,8 +124,8 @@ void httpfetch_caller_free(unsigned long caller);
 
 // Performs a synchronous HTTP request. This blocks and therefore should
 // only be used from background threads.
-void httpfetch_sync(const HTTPFetchRequest &fetchrequest,
-               HTTPFetchResult &fetchresult);
+void httpfetch_sync(const HTTPFetchRequest &fetch_request,
+               HTTPFetchResult &fetch_result);
 
 
 #endif // !HTTPFETCH_HEADER

diff --git a/src/mods.cpp b/src/mods.cpp
index b4e075b1eae52b8d5202e1369ba7c274eb6c342e..7d6b4f5f7686f64389e7d2c49f216e3d9329afc2 100644 (file)
--- a/src/mods.cpp
+++ b/src/mods.cpp
@@ -339,19 +339,14 @@ Json::Value getModstoreUrl(std::string url)
 
        bool special_http_header = true;
 
-       try{
+       try {
                special_http_header = g_settings->getBool("modstore_disable_special_http_header");
-       }
-       catch(SettingNotFoundException &e) {
-       }
+       } catch (SettingNotFoundException) {}
 
        if (special_http_header) {
                extra_headers.push_back("Accept: application/vnd.minetest.mmdb-v1+json");
-               return fetchJsonValue(url, &extra_headers);
-       }
-       else {
-               return fetchJsonValue(url, NULL);
        }
+       return fetchJsonValue(url, special_http_header ? &extra_headers : NULL);
 }
 
 #endif

diff --git a/src/serverlist.cpp b/src/serverlist.cpp
index cc41216ff5a7f8c512588130c665f6853abf15b8..245a8b8006b439182665fc86b09b7400380b97ee 100644 (file)
--- a/src/serverlist.cpp
+++ b/src/serverlist.cpp
@@ -70,17 +70,24 @@ std::vector<ServerListSpec> getOnline()
        Json::Value root = fetchJsonValue(
                        (g_settings->get("serverlist_url") + "/list").c_str(), NULL);
 
-       std::vector<ServerListSpec> serverlist;
+       std::vector<ServerListSpec> server_list;
+
+       if (!root.isObject()) {
+               return server_list;
+       }
 
-       if (root.isArray()) {
-               for (unsigned int i = 0; i < root.size(); i++) {
-                       if (root[i].isObject()) {
-                               serverlist.push_back(root[i]);
-                       }
+       root = root["list"];
+       if (!root.isArray()) {
+               return server_list;
+       }
+
+       for (unsigned int i = 0; i < root.size(); i++) {
+               if (root[i].isObject()) {
+                       server_list.push_back(root[i]);
                }
        }
 
-       return serverlist;
+       return server_list;
 }
 
 
@@ -236,11 +243,11 @@ void sendAnnounce(const std::string &action,
        }
 
        Json::FastWriter writer;
-       HTTPFetchRequest fetchrequest;
-       fetchrequest.url = g_settings->get("serverlist_url") + std::string("/announce");
-       fetchrequest.post_fields["json"] = writer.write(server);
-       fetchrequest.multipart = true;
-       httpfetch_async(fetchrequest);
+       HTTPFetchRequest fetch_request;
+       fetch_request.url = g_settings->get("serverlist_url") + std::string("/announce");
+       fetch_request.post_fields["json"] = writer.write(server);
+       fetch_request.multipart = true;
+       httpfetch_async(fetch_request);
 }
 #endif