X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fclientmedia.cpp;h=14a38ca66439dbacfe065b3da3d274251a50b9dd;hb=f151b2322003bbc89c2cd3c603ef1e1ab9d46439;hp=dcae440239572f1856e9600f89532ae7b429d2ff;hpb=e258675eabc874d31bc9c6cf49e4bbc1f7f3f417;p=dragonfireclient.git diff --git a/src/clientmedia.cpp b/src/clientmedia.cpp index dcae44023..14a38ca66 100644 --- a/src/clientmedia.cpp +++ b/src/clientmedia.cpp @@ -20,21 +20,21 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "clientmedia.h" #include "httpfetch.h" #include "client.h" -#include "clientserver.h" #include "filecache.h" -#include "hex.h" -#include "sha1.h" +#include "filesys.h" #include "debug.h" #include "log.h" #include "porting.h" #include "settings.h" -#include "main.h" +#include "network/networkprotocol.h" +#include "util/hex.h" #include "util/serialize.h" +#include "util/sha1.h" #include "util/string.h" static std::string getMediaCacheDir() { - return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "media"; + return porting::path_cache + DIR_DELIM + "media"; } /* @@ -42,12 +42,12 @@ static std::string getMediaCacheDir() */ ClientMediaDownloader::ClientMediaDownloader(): - m_media_cache(getMediaCacheDir()) + m_media_cache(getMediaCacheDir()), + m_initial_step_done(false), + m_uncached_count(0), + m_uncached_received_count(0), + m_name_bound("") { - m_initial_step_done = false; - m_name_bound = ""; // works because "" is an invalid file name - m_uncached_count = 0; - m_uncached_received_count = 0; m_httpfetch_caller = HTTPFETCH_DISCARD; m_httpfetch_active = 0; m_httpfetch_active_limit = 0; @@ -69,9 +69,9 @@ ClientMediaDownloader::~ClientMediaDownloader() delete m_remotes[i]; } -void ClientMediaDownloader::addFile(std::string name, std::string sha1) +void ClientMediaDownloader::addFile(const std::string &name, const std::string &sha1) { - assert(!m_initial_step_done); + assert(!m_initial_step_done); // pre-condition // if name was already announced, ignore the new announcement if (m_files.count(name) != 0) { @@ -104,20 +104,22 @@ void ClientMediaDownloader::addFile(std::string name, std::string sha1) m_files.insert(std::make_pair(name, filestatus)); } -void ClientMediaDownloader::addRemoteServer(std::string baseurl) +void ClientMediaDownloader::addRemoteServer(const std::string &baseurl) { - assert(!m_initial_step_done); + assert(!m_initial_step_done); // pre-condition #ifdef USE_CURL - infostream << "Client: Adding remote server \"" - << baseurl << "\" for media download" << std::endl; + if (g_settings->getBool("enable_remote_media_server")) { + infostream << "Client: Adding remote server \"" + << baseurl << "\" for media download" << std::endl; - RemoteServerStatus *remote = new RemoteServerStatus; - remote->baseurl = baseurl; - remote->active_count = 0; - remote->request_by_filename = false; - m_remotes.push_back(remote); + RemoteServerStatus *remote = new RemoteServerStatus; + remote->baseurl = baseurl; + remote->active_count = 0; + remote->request_by_filename = false; + m_remotes.push_back(remote); + } #else @@ -138,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) @@ -257,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_fields = 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++; @@ -277,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 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 @@ -315,8 +317,10 @@ void ClientMediaDownloader::remoteHashSetReceived( // For compatibility: If index.mth is not found, assume that the // server contains files named like the original files (not their sha1) - if (!fetchresult.succeeded && !fetchresult.timeout && - fetchresult.response_code == 404) { + // Do NOT check for any particular response code (e.g. 404) here, + // because different servers respond differently + + if (!fetch_result.succeeded && !fetch_result.timeout) { infostream << "Client: Enabling compatibility mode for remote " << "server \"" << remote->baseurl << "\"" << std::endl; remote->request_by_filename = true; @@ -334,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. @@ -345,17 +349,17 @@ void ClientMediaDownloader::remoteMediaReceived( std::string name; { std::map::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); } - assert(m_files.count(name) != 0); + sanity_check(m_files.count(name) != 0); FileStatus *filestatus = m_files[name]; - assert(!filestatus->received); - assert(filestatus->current_remote >= 0); + sanity_check(!filestatus->received); + sanity_check(filestatus->current_remote >= 0); RemoteServerStatus *remote = m_remotes[filestatus->current_remote]; @@ -364,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); @@ -377,6 +381,7 @@ void ClientMediaDownloader::remoteMediaReceived( s32 ClientMediaDownloader::selectRemoteServer(FileStatus *filestatus) { + // Pre-conditions assert(filestatus != NULL); assert(!filestatus->received); assert(filestatus->current_remote < 0); @@ -441,14 +446,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, @@ -478,12 +483,12 @@ void ClientMediaDownloader::startRemoteMediaTransfers() void ClientMediaDownloader::startConventionalTransfers(Client *client) { - assert(m_httpfetch_active == 0); + assert(m_httpfetch_active == 0); // pre-condition if (m_uncached_received_count != m_uncached_count) { // Some media files have not been received yet, use the // conventional slow method (minetest protocol) to get them - std::list file_requests; + std::vector file_requests; for (std::map::iterator it = m_files.begin(); it != m_files.end(); ++it) { @@ -611,7 +616,7 @@ std::string ClientMediaDownloader::serializeRequiredHashSet() it = m_files.begin(); it != m_files.end(); ++it) { if (!it->second->received) { - assert(it->second->sha1.size() == 20); + FATAL_ERROR_IF(it->second->sha1.size() != 20, "Invalid SHA1 size"); os << it->second->sha1; } }