pax_global_header00006660000000000000000000000064130361770260014517gustar00rootroot0000000000000052 comment=1d1855049c9003ba4df3b4f5b7d9db3a64dbe394 lgogdownloader-3.1/000077500000000000000000000000001303617702600143715ustar00rootroot00000000000000lgogdownloader-3.1/.gitignore000066400000000000000000000001551303617702600163620ustar00rootroot00000000000000*.layout *~ *.[oa] bin/* obj/* *.1 *.gz Makefile CMakeCache.txt CMakeFiles/ cmake_install.cmake build/ *.cbp lgogdownloader-3.1/CMakeLists.txt000066400000000000000000000102511303617702600171300ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR) project (lgogdownloader LANGUAGES C CXX VERSION 3.1) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG=1") set(LINK_LIBCRYPTO 0) find_program(READELF readelf DOC "Location of the readelf program") find_program(GREP grep DOC "Location of the grep program") find_package(Boost REQUIRED system filesystem regex program_options date_time ) find_package(CURL 7.32.0 REQUIRED) if(CURL_FOUND) execute_process( COMMAND ${READELF} -d ${CURL_LIBRARIES} COMMAND ${GREP} -q "libssl\\|libcrypto" RESULT_VARIABLE READELF_RESULT_VAR ) if(READELF_RESULT_VAR EQUAL 0) add_definitions(-DSSL_THREAD_SETUP_OPENSSL=1) find_package(Libcrypto REQUIRED) set(LINK_LIBCRYPTO 1) endif(READELF_RESULT_VAR EQUAL 0) endif(CURL_FOUND) find_package(OAuth REQUIRED) find_package(Jsoncpp REQUIRED) find_package(Htmlcxx REQUIRED) find_package(Tinyxml2 REQUIRED) find_package(Rhash REQUIRED) find_package(Threads REQUIRED) file(GLOB SRC_FILES main.cpp src/api.cpp src/website.cpp src/downloader.cpp src/progressbar.cpp src/util.cpp src/blacklist.cpp src/gamefile.cpp src/gamedetails.cpp ) set(GIT_CHECKOUT FALSE) if(EXISTS ${PROJECT_SOURCE_DIR}/.git) if(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/shallow) find_package(Git) if(GIT_FOUND) set(GIT_CHECKOUT TRUE) else(GIT_FOUND) message(WARNING "Git executable not found") endif(GIT_FOUND) else(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/shallow) message(STATUS "Shallow Git clone detected, not attempting to retrieve version info") endif(NOT EXISTS ${PROJECT_SOURCE_DIR}/.git/shallow) endif(EXISTS ${PROJECT_SOURCE_DIR}/.git) if(GIT_CHECKOUT) execute_process(COMMAND ${GIT_EXECUTABLE} diff --shortstat WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE GIT_SHORTSTAT OUTPUT_STRIP_TRAILING_WHITESPACE ) execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} OUTPUT_VARIABLE GIT_REV_PARSE OUTPUT_STRIP_TRAILING_WHITESPACE ) if(GIT_SHORTSTAT) set(GIT_DIRTY ON) endif(GIT_SHORTSTAT) if(GIT_DIRTY) set(PROJECT_VERSION_MINOR ${PROJECT_VERSION_MINOR}M) endif(GIT_DIRTY) set(PROJECT_VERSION_PATCH ${GIT_REV_PARSE}) set(PROJECT_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}) endif(GIT_CHECKOUT) set(VERSION_NUMBER ${PROJECT_VERSION}) set(VERSION_STRING "LGOGDownloader ${VERSION_NUMBER}") add_definitions(-D_FILE_OFFSET_BITS=64 -DVERSION_NUMBER="${VERSION_NUMBER}" -DVERSION_STRING="${VERSION_STRING}") add_executable (${PROJECT_NAME} ${SRC_FILES}) target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include PRIVATE ${Boost_INCLUDE_DIRS} PRIVATE ${CURL_INCLUDE_DIRS} PRIVATE ${OAuth_INCLUDE_DIRS} PRIVATE ${Jsoncpp_INCLUDE_DIRS} PRIVATE ${Htmlcxx_INCLUDE_DIRS} PRIVATE ${Tinyxml2_INCLUDE_DIRS} PRIVATE ${Rhash_INCLUDE_DIRS} ) target_link_libraries(${PROJECT_NAME} PRIVATE ${Boost_LIBRARIES} PRIVATE ${CURL_LIBRARIES} PRIVATE ${OAuth_LIBRARIES} PRIVATE ${Jsoncpp_LIBRARIES} PRIVATE ${Htmlcxx_LIBRARIES} PRIVATE ${Tinyxml2_LIBRARIES} PRIVATE ${Rhash_LIBRARIES} PRIVATE ${CMAKE_THREAD_LIBS_INIT} ) if(LINK_LIBCRYPTO EQUAL 1) target_link_libraries(${PROJECT_NAME} PRIVATE ${Libcrypto_LIBRARIES} ) endif(LINK_LIBCRYPTO EQUAL 1) if(MSVC) # Force to always compile with W4 if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]") string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") else() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") endif() elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") # Update if necessary set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wextra -Wno-long-long -fexceptions") endif() set(INSTALL_BIN_DIR bin CACHE PATH "Installation directory for executables") set(INSTALL_SHARE_DIR share CACHE PATH "Installation directory for resource files") install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX} DESTINATION ${INSTALL_BIN_DIR}) add_subdirectory(man) lgogdownloader-3.1/COPYING000066400000000000000000000007441303617702600154310ustar00rootroot00000000000000 DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE Version 2, December 2004 Copyright (C) 2004 Sam Hocevar Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed. DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. You just DO WHAT THE FUCK YOU WANT TO. lgogdownloader-3.1/README.md000066400000000000000000000035261303617702600156560ustar00rootroot00000000000000# GOG Downloader This repository contains the code of unofficial [GOG](http://www.gog.com/) downloader. ## Dependencies * [libcurl](https://curl.haxx.se/libcurl/) >= 7.32.0 * [liboauth](https://sourceforge.net/projects/liboauth/) * [librhash](https://github.com/rhash/RHash) * [jsoncpp](https://github.com/open-source-parsers/jsoncpp) * [htmlcxx](http://htmlcxx.sourceforge.net/) * [tinyxml2](https://github.com/leethomason/tinyxml2) * [boost](http://www.boost.org/) (regex, date-time, system, filesystem, program-options) * [libcrypto](https://www.openssl.org/) if libcurl is built with OpenSSL ## Make dependencies * [cmake](https://cmake.org/) >= 3.0.0 * [help2man](https://www.gnu.org/software/help2man/help2man.html) (optional, man page generation) * [grep](https://www.gnu.org/software/grep/) * [binutils](https://www.gnu.org/software/binutils/) (readelf) ### Debian/Ubuntu # apt install build-essential libcurl4-openssl-dev libboost-regex-dev \ libjsoncpp-dev liboauth-dev librhash-dev libtinyxml2-dev libhtmlcxx-dev \ libboost-system-dev libboost-filesystem-dev libboost-program-options-dev \ libboost-date-time-dev help2man cmake libssl-dev pkg-config ## Build and install $ mkdir build $ cd build $ cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release $ make # sudo make install ## Use man lgogdownloader ## Links - [LGOGDownloader website](https://sites.google.com/site/gogdownloader/) - [GOG forum thread](https://www.gog.com/forum/general/lgogdownloader_gogdownloader_for_linux) - [LGOGDownloader @ AUR](https://aur.archlinux.org/packages/lgogdownloader/) - [LGOGDownloader @ AUR (git version)](https://aur.archlinux.org/packages/lgogdownloader-git/) - [LGOGDownloader @ Debian](https://tracker.debian.org/lgogdownloader) - [LGOGDownloader @ Ubuntu](https://launchpad.net/ubuntu/+source/lgogdownloader) lgogdownloader-3.1/cmake/000077500000000000000000000000001303617702600154515ustar00rootroot00000000000000lgogdownloader-3.1/cmake/FindHtmlcxx.cmake000066400000000000000000000024561303617702600207120ustar00rootroot00000000000000# - Try to find htmlcxx # # Once done this will define # Htmlcxx_FOUND - System has htmlcxx # Htmlcxx_INCLUDE_DIRS - The htmlcxx include directories # Htmlcxx_LIBRARIES - The libraries needed to use htmlcxx find_package(PkgConfig) pkg_check_modules(PC_HTMLCXX REQUIRED htmlcxx) find_path(HTMLCXX_INCLUDE_DIR NAMES css/parser.h html/tree.h HINTS ${PC_HTMLCXX_INCLUDEDIR} ${PC_HTMLCXX_INCLUDE_DIRS} PATH_SUFFIXES htmlcxx PATHS ${PC_HTMLCXX_INCLUDE_DIRS} ) find_library(HTMLCXX_LIBRARY_HTMLCXX htmlcxx HINTS ${PC_HTMLCXX_LIBDIR} ${PC_HTMLCXX_LIBRARY_DIRS} PATHS ${PC_HTMLCXX_LIBRARY_DIRS} ) find_library(HTMLCXX_LIBRARY_CSS_PARSER css_parser HINTS ${PC_HTMLCXX_LIBDIR} ${PC_HTMLCXX_LIBRARY_DIRS} PATHS ${PC_HTMLCXX_LIBRARY_DIRS} ) find_library(HTMLCXX_LIBRARY_CSS_PARSER_PP css_parser_pp HINTS ${PC_HTMLCXX_LIBDIR} ${PC_HTMLCXX_LIBRARY_DIRS} PATHS ${PC_HTMLCXX_LIBRARY_DIRS} ) mark_as_advanced(HTMLCXX_INCLUDE_DIR HTMLCXX_LIBRARY_HTMLCXX HTMLCXX_LIBRARY_CSS_PARSER HTMLCXX_LIBRARY_CSS_PARSER_PP) if(PC_HTMLCXX_FOUND) set(Htmlcxx_FOUND ON) set(Htmlcxx_INCLUDE_DIRS ${HTMLCXX_INCLUDE_DIR}) set(Htmlcxx_LIBRARIES ${HTMLCXX_LIBRARY_HTMLCXX} ${HTMLCXX_LIBRARY_CSS_PARSER} ${HTMLCXX_LIBRARY_CSS_PARSER_PP}) endif(PC_HTMLCXX_FOUND) lgogdownloader-3.1/cmake/FindJsoncpp.cmake000066400000000000000000000014031303617702600206660ustar00rootroot00000000000000# - Try to find Jsoncpp # # Once done, this will define # Jsoncpp_FOUND - system has Jsoncpp # Jsoncpp_INCLUDE_DIRS - the Jsoncpp include directories # Jsoncpp_LIBRARIES - link these to use Jsoncpp find_package(PkgConfig) pkg_check_modules(PC_JSONCPP REQUIRED jsoncpp) find_path(JSONCPP_INCLUDE_DIR NAMES json/features.h HINTS ${PC_JSONCPP_INCLUDEDIR} ${PC_JSONCPP_INCLUDEDIRS} PATH_SUFFIXES jsoncpp PATHS ${PC_JSONCPP_INCLUDE_DIRS} ) find_library(JSONCPP_LIBRARY jsoncpp PATHS ${PC_JSONCPP_LIBRARY_DIRS} ) mark_as_advanced(JSONCPP_INCLUDE_DIR JSONCPP_LIBRARY) if(PC_JSONCPP_FOUND) set(Jsoncpp_FOUND ON) set(Jsoncpp_INCLUDE_DIRS ${JSONCPP_INCLUDE_DIR}) set(Jsoncpp_LIBRARIES ${JSONCPP_LIBRARY}) endif(PC_JSONCPP_FOUND) lgogdownloader-3.1/cmake/FindLibcrypto.cmake000066400000000000000000000014011303617702600212170ustar00rootroot00000000000000# - Try to find libcrypto # # Once done this will define # Libcrypto_FOUND - System has libcrypto # Libcrypto_INCLUDE_DIRS - The libcrypto include directories # Libcrypto_LIBRARIES - The libraries needed to use libcrypto find_package(PkgConfig) pkg_check_modules(PC_LIBCRYPTO REQUIRED libcrypto) find_path(LIBCRYPTO_INCLUDE_DIR openssl/crypto.h HINTS ${PC_LIBCRYPTO_INCLUDEDIR} ${PC_LIBCRYPTO_INCLUDE_DIRS} ) find_library(LIBCRYPTO_LIBRARY NAMES crypto HINTS ${PC_LIBCRYPTO_LIBDIR} ${PC_LIBCRYPTO_LIBRARY_DIRS} ) mark_as_advanced(LIBCRYPTO_INCLUDE_DIR LIBCRYPTO_LIBRARY) if(PC_LIBCRYPTO_FOUND) set(Libcrypto_FOUND ON) set(Libcrypto_INCLUDE_DIRS ${LIBCRYPTO_INCLUDE_DIR}) set(Libcrypto_LIBRARIES ${LIBCRYPTO_LIBRARY}) endif(PC_LIBCRYPTO_FOUND) lgogdownloader-3.1/cmake/FindOAuth.cmake000066400000000000000000000012551303617702600202770ustar00rootroot00000000000000# - Try to find oauth # # Once done this will define # OAuth_FOUND - System has oauth # OAuth_INCLUDE_DIRS - The oauth include directories # OAuth_LIBRARIES - The libraries needed to use oauth find_package(PkgConfig) pkg_check_modules(PC_OAUTH REQUIRED oauth) find_path(OAUTH_INCLUDE_DIR oauth.h HINTS ${PC_OAUTH_INCLUDEDIR} ${PC_OAUTH_INCLUDE_DIRS} PATH_SUFFIXES oauth ) find_library(OAUTH_LIBRARY NAMES oauth HINTS ${PC_OAUTH_LIBDIR} ${PC_OAUTH_LIBRARY_DIRS} ) mark_as_advanced(OAUTH_INCLUDE_DIR OAUTH_LIBRARY) if(PC_OAUTH_FOUND) set(OAuth_FOUND ON) set(OAuth_INCLUDE_DIRS ${OAUTH_INCLUDE_DIR}) set(OAuth_LIBRARIES ${OAUTH_LIBRARY}) endif(PC_OAUTH_FOUND) lgogdownloader-3.1/cmake/FindRhash.cmake000066400000000000000000000012051303617702600203170ustar00rootroot00000000000000# - Try to find rhash # # Once done this will define # Rhash_FOUND - System has rhash # Rhash_INCLUDE_DIRS - The rhash include directories # Rhash_LIBRARIES - The libraries needed to use rhash find_path(RHASH_INCLUDE_DIR rhash.h) find_library(RHASH_LIBRARY rhash) mark_as_advanced(RHASH_INCLUDE_DIR RHASH_LIBRARY) if(RHASH_LIBRARY AND RHASH_INCLUDE_DIR) set(Rhash_FOUND ON) set(Rhash_LIBRARIES ${RHASH_LIBRARY}) set(Rhash_INCLUDE_DIRS ${RHASH_INCLUDE_DIR}) else() set(Rhash_FOUND OFF) if(Rhash_FIND_REQUIRED) message(FATAL_ERROR "Could not find rhash") endif(Rhash_FIND_REQUIRED) endif(RHASH_LIBRARY AND RHASH_INCLUDE_DIR) lgogdownloader-3.1/cmake/FindTinyxml2.cmake000066400000000000000000000014671303617702600210120ustar00rootroot00000000000000# - Try to find tinyxml2 # # Once done this will define # Tinyxml2_FOUND - System has tinyxml2 # Tinyxml2_INCLUDE_DIRS - The tinyxml2 include directories # Tinyxml2_LIBRARIES - The libraries needed to use tinyxml find_package(PkgConfig) pkg_check_modules(PC_TINYXML2 tinyxml2) find_path(TINYXML2_INCLUDE_DIR tinyxml2.h HINTS ${PC_TINYXML2_INCLUDEDIR} ${PC_TINYXML2_INCLUDE_DIRS} PATHS ${PC_TINYXML2_INCLUDE_DIRS} ) find_library(TINYXML2_LIBRARY tinyxml2 HINTS ${PC_TINYXML2_LIBDIR} ${PC_TINYXML2_LIBRARY_DIRS} PATHS ${PC_TINYXML2_LIBRARY_DIRS} ) mark_as_advanced(TINYXML2_INCLUDE_DIR TINYXML2_LIBRARY) if(TINYXML2_INCLUDE_DIR) set(Tinyxml2_FOUND ON) set(Tinyxml2_INCLUDE_DIRS ${TINYXML2_INCLUDE_DIR}) set(Tinyxml2_LIBRARIES ${TINYXML2_LIBRARY}) endif(TINYXML2_INCLUDE_DIR) lgogdownloader-3.1/include/000077500000000000000000000000001303617702600160145ustar00rootroot00000000000000lgogdownloader-3.1/include/api.h000066400000000000000000000066471303617702600167530ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef API_H #define API_H #include "globalconstants.h" #include "gamedetails.h" #include #include #include extern "C" { #include } #include #include class userDetails { public: std::string avatar_small; std::string avatar_big; std::string username; std::string email; unsigned long long id; int notifications_forum; int notifications_games; int notifications_messages; }; class apiConfig { public: std::string oauth_authorize_temp_token; std::string oauth_get_temp_token; std::string oauth_get_token; std::string get_user_games; std::string get_user_details; std::string get_installer_link; std::string get_game_details; std::string get_extra_link; std::string set_app_status; std::string oauth_token; std::string oauth_secret; }; size_t writeMemoryCallback(char *ptr, size_t size, size_t nmemb, void *userp); class API { public: userDetails user; API(const std::string& token,const std::string& secret); int init(); bool isLoggedIn(); int login(const std::string& email, const std::string& password); int getAPIConfig(); std::string getResponse(const std::string& url); std::string getResponseOAuth(const std::string& url); int getUserDetails(); int getGames(); gameDetails getGameDetails(const std::string& game_name, const unsigned int& platform = (GlobalConstants::PLATFORM_WINDOWS | GlobalConstants::PLATFORM_LINUX), const unsigned int& lang = GlobalConstants::LANGUAGE_EN, const bool& useDuplicateHandler = false); std::string getInstallerLink(const std::string& game_name, const std::string& id); std::string getExtraLink(const std::string& game_name, const std::string& id); std::string getPatchLink(const std::string& game_name, const std::string& id); std::string getLanguagePackLink(const std::string& game_name, const std::string& id); std::string getXML(const std::string& game_name, const std::string& id); void clearError(); bool getError() { return this->error; }; std::string getErrorMessage() { return this->error_message; }; std::string getToken() { return this->config.oauth_token; }; std::string getSecret() { return this->config.oauth_secret; }; template CURLcode curlSetOpt(CURLoption option, T value) { return curl_easy_setopt(this->curlhandle, option, value); } virtual ~API(); protected: private: apiConfig config; CURL* curlhandle; void setError(const std::string& err); bool error; std::string error_message; // API constants const std::string CONSUMER_KEY = "1f444d14ea8ec776585524a33f6ecc1c413ed4a5"; const std::string CONSUMER_SECRET = "20d175147f9db9a10fc0584aa128090217b9cf88"; const int OAUTH_VERIFIER_LENGTH = 14; const int OAUTH_TOKEN_LENGTH = 11; const int OAUTH_SECRET_LENGTH = 18; }; #endif // API_H lgogdownloader-3.1/include/blacklist.h000066400000000000000000000022771303617702600201450ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef BLACKLIST_H__ #define BLACKLIST_H__ #include #include #include class Config; class gameFile; class BlacklistItem { public: unsigned int linenr; // where the blacklist item is defined in blacklist.txt unsigned int flags; std::string source; // source representation of the item boost::regex regex; }; class Blacklist { public: Blacklist() {}; void initialize(const std::vector& lines); bool isBlacklisted(const std::string& path); bool isBlacklisted(const std::string& path, const std::string& gamename, std::string subdirectory = ""); std::vector::size_type size() const { return blacklist_.size(); } bool empty() { return blacklist_.empty(); } private: std::vector blacklist_; }; #endif // BLACKLIST_H_ lgogdownloader-3.1/include/config.h000066400000000000000000000056741303617702600174460ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef CONFIG_H__ #define CONFIG_H__ #include #include #include "blacklist.h" class Config { public: Config() {}; virtual ~Config() {}; bool bVerbose; bool bRemoteXML; bool bCover; bool bUpdateCheck; bool bDownload; bool bList; bool bListDetails; bool bLoginHTTP; bool bLoginAPI; bool bRepair; bool bInstallers; bool bExtras; bool bPatches; bool bLanguagePacks; bool bDLC; bool bUnicode; // use Unicode in console output bool bColor; // use colors bool bVerifyPeer; bool bCheckStatus; bool bDuplicateHandler; bool bSaveConfig; bool bResetConfig; bool bReport; bool bSubDirectories; bool bUseCache; bool bUpdateCache; bool bSaveSerials; bool bPlatformDetection; bool bShowWishlist; bool bAutomaticXMLCreation; bool bSaveChangelogs; bool bRespectUmask; std::string sGameRegex; std::string sDirectory; std::string sCacheDirectory; std::string sXMLFile; std::string sXMLDirectory; std::string sToken; std::string sSecret; std::string sVersionString; std::string sVersionNumber; std::string sConfigDirectory; std::string sCookiePath; std::string sConfigFilePath; std::string sBlacklistFilePath; std::string sIgnorelistFilePath; std::string sGameHasDLCListFilePath; std::string sOrphanRegex; std::string sCoverList; std::string sGameHasDLCList; std::string sReportFilePath; std::string sInstallersSubdir; std::string sExtrasSubdir; std::string sPatchesSubdir; std::string sLanguagePackSubdir; std::string sDLCSubdir; std::string sGameSubdir; std::string sFileIdString; std::string sOutputFilename; std::string sLanguagePriority; std::string sPlatformPriority; std::string sIgnoreDLCCountRegex; std::string sCACertPath; std::vector vLanguagePriority; std::vector vPlatformPriority; unsigned int iInstallerPlatform; unsigned int iInstallerLanguage; unsigned int iInclude; unsigned int iThreads; int iRetries; int iWait; int iCacheValid; size_t iChunkSize; curl_off_t iDownloadRate; long int iTimeout; Blacklist blacklist; Blacklist ignorelist; Blacklist gamehasdlc; }; #endif // CONFIG_H__ lgogdownloader-3.1/include/downloader.h000066400000000000000000000114041303617702600203230ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef DOWNLOADER_H #define DOWNLOADER_H #if __GNUC__ # if !(__x86_64__ || __ppc64__ || __LP64__) # ifndef _LARGEFILE_SOURCE # define _LARGEFILE_SOURCE # endif # ifndef _LARGEFILE64_SOURCE # define _LARGEFILE64_SOURCE # endif # if !defined(_FILE_OFFSET_BITS) || (_FILE_OFFSET_BITS == 32) # define _FILE_OFFSET_BITS 64 # endif # endif #endif #include "config.h" #include "api.h" #include "progressbar.h" #include "website.h" #include "threadsafequeue.h" #include #include #include #include #include class Timer { public: Timer() { this->reset(); }; void reset() { gettimeofday(&(this->last_update), NULL); }; double getTimeBetweenUpdates() { // Returns time elapsed between updates in milliseconds struct timeval time_now; gettimeofday(&time_now, NULL); double time_between = ( (time_now.tv_sec+(time_now.tv_usec/1000000.0))*1000.0 - (this->last_update.tv_sec+(this->last_update.tv_usec/1000000.0))*1000.0 ); return time_between; }; ~Timer() {}; private: struct timeval last_update; }; struct xferInfo { unsigned int tid; CURL* curlhandle; Timer timer; std::deque< std::pair > TimeAndSize; curl_off_t offset; }; class Downloader { public: Downloader(Config &conf); virtual ~Downloader(); bool isLoggedIn(); int init(); int login(); int listGames(); void updateCheck(); void repair(); void download(); void checkOrphans(); void checkStatus(); void updateCache(); int downloadFileWithId(const std::string& fileid_string, const std::string& output_filepath); void showWishlist(); CURL* curlhandle; Timer timer; Config config; ProgressBar* progressbar; std::deque< std::pair > TimeAndSize; protected: private: CURLcode downloadFile(const std::string& url, const std::string& filepath, const std::string& xml_data = std::string(), const std::string& gamename = std::string()); int repairFile(const std::string& url, const std::string& filepath, const std::string& xml_data = std::string(), const std::string& gamename = std::string()); int downloadCovers(const std::string& gamename, const std::string& directory, const std::string& cover_xml_data); int getGameDetails(); void getGameList(); uintmax_t getResumePosition(); CURLcode beginDownload(); std::string getResponse(const std::string& url); std::string getLocalFileHash(const std::string& filepath, const std::string& gamename = std::string()); std::string getRemoteFileHash(const std::string& gamename, const std::string& id); int loadGameDetailsCache(); int saveGameDetailsCache(); std::vector getGameDetailsFromJsonNode(Json::Value root, const int& recursion_level = 0); static std::vector getExtrasFromJSON(const Json::Value& json, const std::string& gamename, const Config& config); static std::string getSerialsFromJSON(const Json::Value& json); void saveSerials(const std::string& serials, const std::string& filepath); static std::string getChangelogFromJSON(const Json::Value& json); void saveChangelog(const std::string& changelog, const std::string& filepath); static void processDownloadQueue(Config conf, const unsigned int& tid); static int progressCallbackForThread(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow); void printProgress(); static void getGameDetailsThread(Config config, const unsigned int& tid); static int progressCallback(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow); static size_t writeMemoryCallback(char *ptr, size_t size, size_t nmemb, void *userp); static size_t writeData(void *ptr, size_t size, size_t nmemb, FILE *stream); static size_t readData(void *ptr, size_t size, size_t nmemb, FILE *stream); Website *gogWebsite; API *gogAPI; std::vector gameItems; std::vector games; std::string coverXML; off_t resume_position; int retries; std::ofstream report_ofs; }; #endif // DOWNLOADER_H lgogdownloader-3.1/include/downloadinfo.h000066400000000000000000000047461303617702600206630ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef DOWNLOADINFO_H #define DOWNLOADINFO_H #include #include const unsigned int DLSTATUS_NOTSTARTED = 0; const unsigned int DLSTATUS_STARTING = 1 << 0; const unsigned int DLSTATUS_RUNNING = 1 << 1; const unsigned int DLSTATUS_FINISHED = 1 << 2; struct progressInfo { curl_off_t dlnow; curl_off_t dltotal; double rate; double rate_avg; }; class DownloadInfo { public: void setFilename(const std::string& filename_) { std::unique_lock lock(m); filename = filename_; } std::string getFilename() { std::unique_lock lock(m); return filename; } void setStatus(const unsigned int& status_) { std::unique_lock lock(m); status = status_; } unsigned int getStatus() { std::unique_lock lock(m); return status; } void setProgressInfo(const progressInfo& info) { std::unique_lock lock(m); progress_info = info; } progressInfo getProgressInfo() { std::unique_lock lock(m); return progress_info; } DownloadInfo()=default; DownloadInfo(const DownloadInfo& other) { std::lock_guard guard(other.m); filename = other.filename; status = other.status; progress_info = other.progress_info; } DownloadInfo& operator= (DownloadInfo& other) { if(&other == this) return *this; std::unique_lock lock1(m, std::defer_lock); std::unique_lock lock2(other.m, std::defer_lock); std::lock(lock1, lock2); filename = other.filename; status = other.status; progress_info = other.progress_info; return *this; } private: std::string filename; unsigned int status; progressInfo progress_info; mutable std::mutex m; }; #endif // DOWNLOADINFO_H lgogdownloader-3.1/include/gamedetails.h000066400000000000000000000027321303617702600204500ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef GAMEDETAILS_H #define GAMEDETAILS_H #include "globalconstants.h" #include "gamefile.h" #include "config.h" #include "util.h" #include #include #include class gameDetails { public: gameDetails(); std::vector extras; std::vector installers; std::vector patches; std::vector languagepacks; std::vector dlcs; std::string gamename; std::string title; std::string icon; std::string serials; std::string changelog; void filterWithPriorities(const gameSpecificConfig& config); void makeFilepaths(const gameSpecificDirectoryConfig& config); std::string getSerialsFilepath(); std::string getChangelogFilepath(); Json::Value getDetailsAsJson(); std::vector getGameFileVector(); virtual ~gameDetails(); protected: void filterListWithPriorities(std::vector& list, const gameSpecificConfig& config); private: std::string serialsFilepath; std::string changelogFilepath; }; #endif // GAMEDETAILS_H lgogdownloader-3.1/include/gamefile.h000066400000000000000000000023531303617702600177410ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef GAMEFILE_H #define GAMEFILE_H #include "globalconstants.h" #include #include #include // Game file types const unsigned int GFTYPE_INSTALLER = 1 << 0; const unsigned int GFTYPE_EXTRA = 1 << 1; const unsigned int GFTYPE_PATCH = 1 << 2; const unsigned int GFTYPE_LANGPACK = 1 << 3; const unsigned int GFTYPE_DLC = 1 << 4; class gameFile { public: gameFile(); int updated; std::string gamename; std::string id; std::string name; std::string path; std::string size; unsigned int platform; unsigned int language; unsigned int type; int score; int silent; void setFilepath(const std::string& path); std::string getFilepath(); Json::Value getAsJson(); virtual ~gameFile(); protected: private: std::string filepath; }; #endif // GAMEFILE_H lgogdownloader-3.1/include/globalconstants.h000066400000000000000000000073721303617702600213730ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef GLOBALCONSTANTS_H_INCLUDED #define GLOBALCONSTANTS_H_INCLUDED #include #include namespace GlobalConstants { const int GAMEDETAILS_CACHE_VERSION = 1; struct optionsStruct {const unsigned int id; const std::string code; const std::string str; const std::string regexp;}; const std::string PROTOCOL_PREFIX = "gogdownloader://"; // Language constants const unsigned int LANGUAGE_EN = 1 << 0; const unsigned int LANGUAGE_DE = 1 << 1; const unsigned int LANGUAGE_FR = 1 << 2; const unsigned int LANGUAGE_PL = 1 << 3; const unsigned int LANGUAGE_RU = 1 << 4; const unsigned int LANGUAGE_CN = 1 << 5; const unsigned int LANGUAGE_CZ = 1 << 6; const unsigned int LANGUAGE_ES = 1 << 7; const unsigned int LANGUAGE_HU = 1 << 8; const unsigned int LANGUAGE_IT = 1 << 9; const unsigned int LANGUAGE_JP = 1 << 10; const unsigned int LANGUAGE_TR = 1 << 11; const unsigned int LANGUAGE_PT = 1 << 12; const unsigned int LANGUAGE_KO = 1 << 13; const unsigned int LANGUAGE_NL = 1 << 14; const unsigned int LANGUAGE_SV = 1 << 15; const unsigned int LANGUAGE_NO = 1 << 16; const unsigned int LANGUAGE_DA = 1 << 17; const unsigned int LANGUAGE_FI = 1 << 18; const unsigned int LANGUAGE_PT_BR = 1 << 19; const unsigned int LANGUAGE_SK = 1 << 20; const unsigned int LANGUAGE_BL = 1 << 21; const std::vector LANGUAGES = { { LANGUAGE_EN, "en", "English" , "en|eng|english" }, { LANGUAGE_DE, "de", "German" , "de|deu|ger|german" }, { LANGUAGE_FR, "fr", "French" , "fr|fra|fre|french" }, { LANGUAGE_PL, "pl", "Polish" , "pl|pol|polish" }, { LANGUAGE_RU, "ru", "Russian" , "ru|rus|russian" }, { LANGUAGE_CN, "cn", "Chinese" , "cn|zh|zho|chi|chinese" }, { LANGUAGE_CZ, "cz", "Czech" , "cz|cs|ces|cze|czech" }, { LANGUAGE_ES, "es", "Spanish" , "es|spa|spanish" }, { LANGUAGE_HU, "hu", "Hungarian" , "hu|hun|hungarian" }, { LANGUAGE_IT, "it", "Italian" , "it|ita|italian" }, { LANGUAGE_JP, "jp", "Japanese" , "jp|ja|jpn|japanese" }, { LANGUAGE_TR, "tr", "Turkish" , "tr|tur|turkish" }, { LANGUAGE_PT, "pt", "Portuguese", "pt|por|portuguese" }, { LANGUAGE_KO, "ko", "Korean" , "ko|kor|korean" }, { LANGUAGE_NL, "nl", "Dutch" , "nl|nld|dut|dutch" }, { LANGUAGE_SV, "sv", "Swedish" , "sv|swe|swedish" }, { LANGUAGE_NO, "no", "Norwegian" , "no|nor|norwegian" }, { LANGUAGE_DA, "da", "Danish" , "da|dan|danish" }, { LANGUAGE_FI, "fi", "Finnish" , "fi|fin|finnish" }, { LANGUAGE_PT_BR, "br", "Brazilian Portuguese", "br|pt_br|pt-br|ptbr|brazilian_portuguese" }, { LANGUAGE_SK, "sk", "Slovak" , "sk|slk|slo|slovak" }, { LANGUAGE_BL, "bl", "Bulgarian" , "bl|bg|bul|bulgarian" } }; // Platform constants const unsigned int PLATFORM_WINDOWS = 1 << 0; const unsigned int PLATFORM_MAC = 1 << 1; const unsigned int PLATFORM_LINUX = 1 << 2; const std::vector PLATFORMS = { { PLATFORM_WINDOWS, "win", "Windows" , "w|win|windows" }, { PLATFORM_MAC, "mac", "Mac" , "m|mac|osx" }, { PLATFORM_LINUX, "linux", "Linux" , "l|lin|linux" } }; } #endif // GLOBALCONSTANTS_H_INCLUDED lgogdownloader-3.1/include/message.h000066400000000000000000000055561303617702600176240ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef MESSAGE_H #define MESSAGE_H #include const unsigned int MSGTYPE_INFO = 1 << 0; const unsigned int MSGTYPE_WARNING = 1 << 1; const unsigned int MSGTYPE_ERROR = 1 << 2; const unsigned int MSGTYPE_SUCCESS = 1 << 3; class Message { public: Message() = default; Message(std::string msg, const unsigned int& type = MSGTYPE_INFO, const std::string& prefix = std::string()) { prefix_ = prefix; msg_ = msg; type_ = type; timestamp_ = boost::posix_time::second_clock::local_time(); } void setMessage(const std::string& msg) { msg_ = msg; } void setType(const unsigned int& type) { type_ = type; } void setTimestamp(const boost::posix_time::ptime& timestamp) { timestamp_ = timestamp; } void setPrefix(const std::string& prefix) { prefix_ = prefix; } std::string getMessage() { return msg_; } unsigned int getType() { return type_; } boost::posix_time::ptime getTimestamp() { return timestamp_; } std::string getTimestampString() { return boost::posix_time::to_simple_string(timestamp_); } std::string getPrefix() { return prefix_; } std::string getFormattedString(const bool& bColor = true, const bool& bPrefix = true) { std::string str; std::string color_value = "\033[39m"; // Default foreground color std::string color_reset = "\033[0m"; if (type_ == MSGTYPE_INFO) color_value = "\033[39m"; // Default foreground color else if (type_ == MSGTYPE_WARNING) color_value = "\033[33m"; // Yellow else if (type_ == MSGTYPE_ERROR) color_value = "\033[31m"; // Red else if (type_ == MSGTYPE_SUCCESS) color_value = "\033[32m"; // Green str = msg_; if (!prefix_.empty() && bPrefix) str = prefix_ + " " + str; str = getTimestampString() + " " + str; if (bColor) str = color_value + str + color_reset; return str; } private: std::string msg_; boost::posix_time::ptime timestamp_; unsigned int type_; std::string prefix_; }; #endif // MESSAGE_H lgogdownloader-3.1/include/progressbar.h000066400000000000000000000022601303617702600205160ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef PROGRESSBAR_H #define PROGRESSBAR_H #include #include class ProgressBar { public: ProgressBar(bool bUnicode, bool bColor); virtual ~ProgressBar(); void draw(unsigned int length, double fraction); std::string createBarString(unsigned int length, double fraction); protected: private: std::vector const m_bar_chars; std::string const m_left_border; std::string const m_right_border; std::string const m_simple_left_border; std::string const m_simple_right_border; std::string const m_simple_empty_fill; std::string const m_simple_bar_char; std::string const m_bar_color; std::string const m_border_color; std::string const COLOR_RESET; bool m_use_unicode; bool m_use_color; }; #endif // PROGRESSBAR_H lgogdownloader-3.1/include/ssl_thread_setup.h000066400000000000000000000030331303617702600215340ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef SSL_THREAD_SETUP_H #define SSL_THREAD_SETUP_H #include #include #if SSL_THREAD_SETUP_OPENSSL == 1 #include static std::mutex* ssl_mutex_array; void thread_locking_callback(int mode, int n, const char* file, int line) { if(mode & CRYPTO_LOCK) ssl_mutex_array[n].lock(); else ssl_mutex_array[n].unlock(); } unsigned long thread_id_callback() { return (unsigned long)std::hash() (std::this_thread::get_id()); } int ssl_thread_setup() { ssl_mutex_array = new std::mutex[CRYPTO_num_locks()]; if(!ssl_mutex_array) return 0; else { CRYPTO_set_id_callback(thread_id_callback); CRYPTO_set_locking_callback(thread_locking_callback); } return 1; } int ssl_thread_cleanup() { if(!ssl_mutex_array) return 0; CRYPTO_set_id_callback(NULL); CRYPTO_set_locking_callback(NULL); delete[] ssl_mutex_array; ssl_mutex_array = NULL; return 1; } #else #define ssl_thread_setup() #define ssl_thread_cleanup() #endif #endif // SSL_THREAD_SETUP_H lgogdownloader-3.1/include/threadsafequeue.h000066400000000000000000000041111303617702600213350ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef THREADSAFEQUEUE_H #define THREADSAFEQUEUE_H #include #include #include template class ThreadSafeQueue { public: void push(const T& item) { std::unique_lock lock(m); q.push(item); lock.unlock(); cvar.notify_one(); } bool empty() const { std::unique_lock lock(m); return q.empty(); } typename std::queue::size_type size() const { std::unique_lock lock(m); return q.size(); } bool try_pop(T& item) { std::unique_lock lock(m); if(q.empty()) return false; item = q.front(); q.pop(); return true; } void wait_and_pop(T& item) { std::unique_lock lock(m); while(q.empty()) cvar.wait(lock); item = q.front(); q.pop(); } ThreadSafeQueue() = default; ThreadSafeQueue(const ThreadSafeQueue& other) { std::lock_guard guard(other.m); q = other.q; } ThreadSafeQueue& operator= (ThreadSafeQueue& other) { if(&other == this) return *this; std::unique_lock lock1(m, std::defer_lock); std::unique_lock lock2(other.m, std::defer_lock); std::lock(lock1, lock2); q = other.q; return *this; } private: std::queue q; mutable std::mutex m; std::condition_variable cvar; }; #endif // THREADSAFEQUEUE_H lgogdownloader-3.1/include/util.h000066400000000000000000000102751303617702600171470ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef UTIL_H #define UTIL_H #include "globalconstants.h" #include #include #include #include #include #include #include #include #include #include #include struct gameSpecificDirectoryConfig { bool bSubDirectories; std::string sDirectory; std::string sGameSubdir; std::string sInstallersSubdir; std::string sExtrasSubdir; std::string sPatchesSubdir; std::string sLanguagePackSubdir; std::string sDLCSubdir; }; struct gameSpecificConfig { unsigned int iInstallerPlatform; unsigned int iInstallerLanguage; bool bDLC; bool bIgnoreDLCCount; gameSpecificDirectoryConfig dirConf; std::vector vLanguagePriority; std::vector vPlatformPriority; }; struct gameItem { std::string name; std::string id; std::vector dlcnames; Json::Value gamedetailsjson; int updates = 0; }; struct wishlistItem { std::string title; unsigned int platform; std::vector tags; time_t release_date_time; std::string currency; std::string price; std::string discount_percent; std::string discount; std::string store_credit; std::string url; bool bIsBonusStoreCreditIncluded; bool bIsDiscounted; }; namespace Util { std::string makeFilepath(const std::string& directory, const std::string& path, const std::string& gamename, std::string subdirectory = "", const unsigned int& platformId = 0, const std::string& dlcname = ""); std::string makeRelativeFilepath(const std::string& path, const std::string& gamename, std::string subdirectory = ""); std::string getFileHash(const std::string& filename, unsigned hash_id); std::string getChunkHash(unsigned char* chunk, uintmax_t chunk_size, unsigned hash_id); int createXML(std::string filepath, uintmax_t chunk_size, std::string xml_dir = std::string()); int getGameSpecificConfig(std::string gamename, gameSpecificConfig* conf, std::string directory = std::string()); int replaceString(std::string& str, const std::string& to_replace, const std::string& replace_with); void filepathReplaceReservedStrings(std::string& str, const std::string& gamename, const unsigned int& platformId = 0, const std::string& dlcname = ""); void setFilePermissions(const boost::filesystem::path& path, const boost::filesystem::perms& permissions); int getTerminalWidth(); void getDownloaderUrlsFromJSON(const Json::Value &root, std::vector &urls); std::vector getDLCNamesFromJSON(const Json::Value &root); std::string getHomeDir(); std::string getConfigHome(); std::string getCacheHome(); std::vector tokenize(const std::string& str, const std::string& separator = ","); unsigned int getOptionValue(const std::string& str, const std::vector& options); std::string getOptionNameString(const unsigned int& value, const std::vector& options); void parseOptionString(const std::string &option_string, std::vector &priority, unsigned int &type, const std::vector& options); std::string getLocalFileHash(const std::string& xml_dir, const std::string& filepath, const std::string& gamename = std::string()); void shortenStringToTerminalWidth(std::string& str); template std::string formattedString(const std::string& format, Args ... args) { std::size_t sz = std::snprintf(nullptr, 0, format.c_str(), args ...) + 1; // +1 for null terminator std::unique_ptr buf(new char[sz]); std::snprintf(buf.get(), sz, format.c_str(), args ...); return std::string(buf.get(), buf.get() + sz - 1); // -1 because we don't want the null terminator } } #endif // UTIL_H lgogdownloader-3.1/include/website.h000066400000000000000000000023511303617702600176300ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #ifndef WEBSITE_H #define WEBSITE_H #include "config.h" #include "util.h" #include #include #include class Website { public: Website(Config &conf); int Login(const std::string& email, const std::string& password); std::string getResponse(const std::string& url); Json::Value getGameDetailsJSON(const std::string& gameid); std::vector getGames(); std::vector getFreeGames(); std::vector getWishlistItems(); bool IsLoggedIn(); void setConfig(Config &conf); virtual ~Website(); protected: private: static size_t writeMemoryCallback(char *ptr, size_t size, size_t nmemb, void *userp); CURL* curlhandle; Config config; bool IsloggedInSimple(); bool IsLoggedInComplex(const std::string& email); int retries; }; #endif // WEBSITE_H lgogdownloader-3.1/main.cpp000066400000000000000000001014511303617702600160230ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "downloader.h" #include "config.h" #include "util.h" #include "globalconstants.h" #include "ssl_thread_setup.h" #include #include #include namespace bpo = boost::program_options; template void set_vm_value(std::map& vm, const std::string& option, const T& value) { vm[option].value() = boost::any(value); } int main(int argc, char *argv[]) { // Constants for option selection with include/exclude /* TODO: Add options to give better control for user For example: option to select base game and DLC installers separately, this requires some changes to Downloader class to implement */ const unsigned int OPTION_INSTALLERS = 1 << 0; const unsigned int OPTION_EXTRAS = 1 << 1; const unsigned int OPTION_PATCHES = 1 << 2; const unsigned int OPTION_LANGPACKS = 1 << 3; const unsigned int OPTION_COVERS = 1 << 4; const unsigned int OPTION_DLCS = 1 << 5; const std::vector INCLUDE_OPTIONS = { { OPTION_INSTALLERS, "i", "Installers", "i|installers" }, { OPTION_EXTRAS, "e", "Extras", "e|extras" }, { OPTION_PATCHES, "p", "Patches", "p|patches" }, { OPTION_LANGPACKS, "l", "Language packs", "l|languagepacks|langpacks" }, { OPTION_COVERS, "c", "Covers", "c|cover|covers" }, { OPTION_DLCS, "d", "DLCs", "d|dlc|dlcs" } }; Config config; config.sVersionString = VERSION_STRING; config.sVersionNumber = VERSION_NUMBER; config.sCacheDirectory = Util::getCacheHome() + "/lgogdownloader"; config.sXMLDirectory = config.sCacheDirectory + "/xml"; config.sConfigDirectory = Util::getConfigHome() + "/lgogdownloader"; config.sCookiePath = config.sConfigDirectory + "/cookies.txt"; config.sConfigFilePath = config.sConfigDirectory + "/config.cfg"; config.sBlacklistFilePath = config.sConfigDirectory + "/blacklist.txt"; config.sIgnorelistFilePath = config.sConfigDirectory + "/ignorelist.txt"; config.sGameHasDLCListFilePath = config.sConfigDirectory + "/game_has_dlc.txt"; std::string priority_help_text = "Set priority by separating values with \",\"\nCombine values by separating with \"+\""; // Create help text for --platform option std::string platform_text = "Select which installers are downloaded\n"; unsigned int platform_all = Util::getOptionValue("all", GlobalConstants::PLATFORMS); for (unsigned int i = 0; i < GlobalConstants::PLATFORMS.size(); ++i) { platform_text += GlobalConstants::PLATFORMS[i].str + " = " + GlobalConstants::PLATFORMS[i].regexp + "|" + std::to_string(GlobalConstants::PLATFORMS[i].id) + "\n"; } platform_text += "All = all|" + std::to_string(platform_all); platform_text += "\n\n" + priority_help_text; platform_text += "\nExample: Linux if available otherwise Windows and Mac: l,w+m"; // Create help text for --language option std::string language_text = "Select which language installers are downloaded\n"; unsigned int language_all = Util::getOptionValue("all", GlobalConstants::LANGUAGES); for (unsigned int i = 0; i < GlobalConstants::LANGUAGES.size(); ++i) { language_text += GlobalConstants::LANGUAGES[i].str + " = " + GlobalConstants::LANGUAGES[i].regexp + "|" + std::to_string(GlobalConstants::LANGUAGES[i].id) + "\n"; } language_text += "Add the values to download multiple languages\nAll = all|" + std::to_string(language_all) + "\n" + "French + Polish = \"fr+pl\"|" + std::to_string(GlobalConstants::LANGUAGE_FR | GlobalConstants::LANGUAGE_PL) + " (" + std::to_string(GlobalConstants::LANGUAGE_FR) + "+" + std::to_string(GlobalConstants::LANGUAGE_PL) + "=" + std::to_string(GlobalConstants::LANGUAGE_FR | GlobalConstants::LANGUAGE_PL) + ")"; language_text += "\n\n" + priority_help_text; language_text += "\nExample: German if available otherwise English and French: de,en+fr"; // Create help text for --check-orphans std::string orphans_regex_default = ".*\\.(zip|exe|bin|dmg|old|deb|tar\\.gz|pkg|sh)$"; // Limit to files with these extensions (".old" is for renamed older version files) std::string check_orphans_text = "Check for orphaned files (files found on local filesystem that are not found on GOG servers). Sets regular expression filter (Perl syntax) for files to check. If no argument is given then the regex defaults to '" + orphans_regex_default + "'"; // Help text for subdir options std::string subdir_help_text = "\nTemplates:\n- %platform%\n- %gamename%\n- %dlcname%"; // Help text for include and exclude options std::string include_options_text; for (unsigned int i = 0; i < INCLUDE_OPTIONS.size(); ++i) { include_options_text += INCLUDE_OPTIONS[i].str + " = " + INCLUDE_OPTIONS[i].regexp + "|" + std::to_string(INCLUDE_OPTIONS[i].id) + "\n"; } include_options_text += "Separate with \",\" to use multiple values"; std::vector vFileIdStrings; std::vector unrecognized_options_cfg; std::vector unrecognized_options_cli; bpo::variables_map vm; bpo::options_description options_cli_all("Options"); bpo::options_description options_cli_no_cfg; bpo::options_description options_cli_cfg; bpo::options_description options_cfg_only; bpo::options_description options_cfg_all("Configuration"); try { bool bInsecure = false; bool bNoColor = false; bool bNoUnicode = false; bool bNoDuplicateHandler = false; bool bNoRemoteXML = false; bool bNoSubDirectories = false; bool bNoPlatformDetection = false; bool bLogin = false; std::string sInstallerPlatform; std::string sInstallerLanguage; std::string sIncludeOptions; std::string sExcludeOptions; config.bReport = false; // Commandline options (no config file) options_cli_no_cfg.add_options() ("help,h", "Print help message") ("version", "Print version information") ("login", bpo::value(&bLogin)->zero_tokens()->default_value(false), "Login") ("list", bpo::value(&config.bList)->zero_tokens()->default_value(false), "List games") ("list-details", bpo::value(&config.bListDetails)->zero_tokens()->default_value(false), "List games with detailed info") ("download", bpo::value(&config.bDownload)->zero_tokens()->default_value(false), "Download") ("repair", bpo::value(&config.bRepair)->zero_tokens()->default_value(false), "Repair downloaded files\nUse --repair --download to redownload files when filesizes don't match (possibly different version). Redownload will rename the old file (appends .old to filename)") ("game", bpo::value(&config.sGameRegex)->default_value(""), "Set regular expression filter\nfor download/list/repair (Perl syntax)\nAliases: \"all\", \"free\"\nAlias \"free\" doesn't work with cached details") ("create-xml", bpo::value(&config.sXMLFile)->implicit_value("automatic"), "Create GOG XML for file\n\"automatic\" to enable automatic XML creation") ("update-check", bpo::value(&config.bUpdateCheck)->zero_tokens()->default_value(false), "Check for update notifications") ("check-orphans", bpo::value(&config.sOrphanRegex)->implicit_value(""), check_orphans_text.c_str()) ("status", bpo::value(&config.bCheckStatus)->zero_tokens()->default_value(false), "Show status of files\n\nOutput format:\nstatuscode gamename filename filesize filehash\n\nStatus codes:\nOK - File is OK\nND - File is not downloaded\nMD5 - MD5 mismatch, different version\nFS - File size mismatch, incomplete download") ("save-config", bpo::value(&config.bSaveConfig)->zero_tokens()->default_value(false), "Create config file with current settings") ("reset-config", bpo::value(&config.bResetConfig)->zero_tokens()->default_value(false), "Reset config settings to default") ("report", bpo::value(&config.sReportFilePath)->implicit_value("lgogdownloader-report.log"), "Save report of downloaded/repaired files to specified file\nDefault filename: lgogdownloader-report.log") ("update-cache", bpo::value(&config.bUpdateCache)->zero_tokens()->default_value(false), "Update game details cache") ("no-platform-detection", bpo::value(&bNoPlatformDetection)->zero_tokens()->default_value(false), "Don't try to detect supported platforms from game shelf.\nSkips the initial fast platform detection and detects the supported platforms from game details which is slower but more accurate.\nUseful in case platform identifier is missing for some games in the game shelf.\nUsing --platform with --list doesn't work with this option.") ("download-file", bpo::value(&config.sFileIdString)->default_value(""), "Download files using fileid\n\nFormat:\n\"gamename/fileid\"\nor: \"gogdownloader://gamename/fileid\"\n\nMultiple files:\n\"gamename1/fileid1,gamename2/fileid2\"\nor: \"gogdownloader://gamename1/fileid1,gamename2/fileid2\"\n\nThis option ignores all subdir options. The files are downloaded to directory specified with --directory option.") ("output-file,o", bpo::value(&config.sOutputFilename)->default_value(""), "Set filename of file downloaded with --download-file.") ("wishlist", bpo::value(&config.bShowWishlist)->zero_tokens()->default_value(false), "Show wishlist") ("login-api", bpo::value(&config.bLoginAPI)->zero_tokens()->default_value(false), "Login (API only)") ("login-website", bpo::value(&config.bLoginHTTP)->zero_tokens()->default_value(false), "Login (website only)") ("cacert", bpo::value(&config.sCACertPath)->default_value(""), "Path to CA certificate bundle in PEM format") ("respect-umask", bpo::value(&config.bRespectUmask)->zero_tokens()->default_value(false), "Do not adjust permissions of sensitive files") ; // Commandline options (config file) options_cli_cfg.add_options() ("directory", bpo::value(&config.sDirectory)->default_value("."), "Set download directory") ("limit-rate", bpo::value(&config.iDownloadRate)->default_value(0), "Limit download rate to value in kB\n0 = unlimited") ("xml-directory", bpo::value(&config.sXMLDirectory), "Set directory for GOG XML files") ("chunk-size", bpo::value(&config.iChunkSize)->default_value(10), "Chunk size (in MB) when creating XML") ("platform", bpo::value(&sInstallerPlatform)->default_value("w+l"), platform_text.c_str()) ("language", bpo::value(&sInstallerLanguage)->default_value("en"), language_text.c_str()) ("no-remote-xml", bpo::value(&bNoRemoteXML)->zero_tokens()->default_value(false), "Don't use remote XML for repair") ("no-unicode", bpo::value(&bNoUnicode)->zero_tokens()->default_value(false), "Don't use Unicode in the progress bar") ("no-color", bpo::value(&bNoColor)->zero_tokens()->default_value(false), "Don't use coloring in the progress bar or status messages") ("no-duplicate-handling", bpo::value(&bNoDuplicateHandler)->zero_tokens()->default_value(false), "Don't use duplicate handler for installers\nDuplicate installers from different languages are handled separately") ("no-subdirectories", bpo::value(&bNoSubDirectories)->zero_tokens()->default_value(false), "Don't create subdirectories for extras, patches and language packs") ("verbose", bpo::value(&config.bVerbose)->zero_tokens()->default_value(false), "Print lots of information") ("insecure", bpo::value(&bInsecure)->zero_tokens()->default_value(false), "Don't verify authenticity of SSL certificates") ("timeout", bpo::value(&config.iTimeout)->default_value(10), "Set timeout for connection\nMaximum time in seconds that connection phase is allowed to take") ("retries", bpo::value(&config.iRetries)->default_value(3), "Set maximum number of retries on failed download") ("wait", bpo::value(&config.iWait)->default_value(0), "Time to wait between requests (milliseconds)") ("cover-list", bpo::value(&config.sCoverList)->default_value("https://raw.githubusercontent.com/Sude-/lgogdownloader-lists/master/covers.xml"), "Set URL for cover list") ("subdir-installers", bpo::value(&config.sInstallersSubdir)->default_value(""), ("Set subdirectory for extras" + subdir_help_text).c_str()) ("subdir-extras", bpo::value(&config.sExtrasSubdir)->default_value("extras"), ("Set subdirectory for extras" + subdir_help_text).c_str()) ("subdir-patches", bpo::value(&config.sPatchesSubdir)->default_value("patches"), ("Set subdirectory for patches" + subdir_help_text).c_str()) ("subdir-language-packs", bpo::value(&config.sLanguagePackSubdir)->default_value("languagepacks"), ("Set subdirectory for language packs" + subdir_help_text).c_str()) ("subdir-dlc", bpo::value(&config.sDLCSubdir)->default_value("dlc/%dlcname%"), ("Set subdirectory for dlc" + subdir_help_text).c_str()) ("subdir-game", bpo::value(&config.sGameSubdir)->default_value("%gamename%"), ("Set subdirectory for game" + subdir_help_text).c_str()) ("use-cache", bpo::value(&config.bUseCache)->zero_tokens()->default_value(false), ("Use game details cache")) ("cache-valid", bpo::value(&config.iCacheValid)->default_value(2880), ("Set how long cached game details are valid (in minutes)\nDefault: 2880 minutes (48 hours)")) ("save-serials", bpo::value(&config.bSaveSerials)->zero_tokens()->default_value(false), "Save serial numbers when downloading") ("ignore-dlc-count", bpo::value(&config.sIgnoreDLCCountRegex)->implicit_value(".*"), "Set regular expression filter for games to ignore DLC count information\nIgnoring DLC count information helps in situations where the account page doesn't provide accurate information about DLCs") ("include", bpo::value(&sIncludeOptions)->default_value("all"), ("Select what to download/list/repair\n" + include_options_text).c_str()) ("exclude", bpo::value(&sExcludeOptions)->default_value("covers"), ("Select what not to download/list/repair\n" + include_options_text).c_str()) ("automatic-xml-creation", bpo::value(&config.bAutomaticXMLCreation)->zero_tokens()->default_value(false), "Automatically create XML data after download has completed") ("save-changelogs", bpo::value(&config.bSaveChangelogs)->zero_tokens()->default_value(false), "Save changelogs when downloading") ("threads", bpo::value(&config.iThreads)->default_value(4), "Number of download threads") ("dlc-list", bpo::value(&config.sGameHasDLCList)->default_value("https://raw.githubusercontent.com/Sude-/lgogdownloader-lists/master/game_has_dlc.txt"), "Set URL for list of games that have DLC") ; // Options read from config file options_cfg_only.add_options() ("token", bpo::value(&config.sToken)->default_value(""), "oauth token") ("secret", bpo::value(&config.sSecret)->default_value(""), "oauth secret") ; options_cli_all.add(options_cli_no_cfg).add(options_cli_cfg); options_cfg_all.add(options_cfg_only).add(options_cli_cfg); bpo::parsed_options parsed = bpo::parse_command_line(argc, argv, options_cli_all); bpo::store(parsed, vm); unrecognized_options_cli = bpo::collect_unrecognized(parsed.options, bpo::include_positional); bpo::notify(vm); if (vm.count("help")) { std::cout << config.sVersionString << std::endl << options_cli_all << std::endl; return 0; } if (vm.count("version")) { std::cout << VERSION_STRING << std::endl; return 0; } // Create lgogdownloader directories boost::filesystem::path path = config.sXMLDirectory; if (!boost::filesystem::exists(path)) { if (!boost::filesystem::create_directories(path)) { std::cerr << "Failed to create directory: " << path << std::endl; return 1; } } path = config.sConfigDirectory; if (!boost::filesystem::exists(path)) { if (!boost::filesystem::create_directories(path)) { std::cerr << "Failed to create directory: " << path << std::endl; return 1; } } path = config.sCacheDirectory; if (!boost::filesystem::exists(path)) { if (!boost::filesystem::create_directories(path)) { std::cerr << "Failed to create directory: " << path << std::endl; return 1; } } if (boost::filesystem::exists(config.sConfigFilePath)) { std::ifstream ifs(config.sConfigFilePath.c_str()); if (!ifs) { std::cerr << "Could not open config file: " << config.sConfigFilePath << std::endl; return 1; } else { bpo::parsed_options parsed = bpo::parse_config_file(ifs, options_cfg_all, true); bpo::store(parsed, vm); bpo::notify(vm); ifs.close(); unrecognized_options_cfg = bpo::collect_unrecognized(parsed.options, bpo::include_positional); } } if (boost::filesystem::exists(config.sBlacklistFilePath)) { std::ifstream ifs(config.sBlacklistFilePath.c_str()); if (!ifs) { std::cerr << "Could not open blacklist file: " << config.sBlacklistFilePath << std::endl; return 1; } else { std::string line; std::vector lines; while (!ifs.eof()) { std::getline(ifs, line); lines.push_back(std::move(line)); } config.blacklist.initialize(lines); } } if (boost::filesystem::exists(config.sIgnorelistFilePath)) { std::ifstream ifs(config.sIgnorelistFilePath.c_str()); if (!ifs) { std::cerr << "Could not open ignorelist file: " << config.sIgnorelistFilePath << std::endl; return 1; } else { std::string line; std::vector lines; while (!ifs.eof()) { std::getline(ifs, line); lines.push_back(std::move(line)); } config.ignorelist.initialize(lines); } } if (config.sIgnoreDLCCountRegex.empty()) { if (boost::filesystem::exists(config.sGameHasDLCListFilePath)) { std::ifstream ifs(config.sGameHasDLCListFilePath.c_str()); if (!ifs) { std::cerr << "Could not open list of games that have dlc: " << config.sGameHasDLCListFilePath << std::endl; return 1; } else { std::string line; std::vector lines; while (!ifs.eof()) { std::getline(ifs, line); lines.push_back(std::move(line)); } config.gamehasdlc.initialize(lines); } } } if (vm.count("chunk-size")) config.iChunkSize <<= 20; // Convert chunk size from bytes to megabytes if (vm.count("limit-rate")) config.iDownloadRate <<= 10; // Convert download rate from bytes to kilobytes if (vm.count("check-orphans")) if (config.sOrphanRegex.empty()) config.sOrphanRegex = orphans_regex_default; if (vm.count("report")) config.bReport = true; if (config.iWait > 0) config.iWait *= 1000; if (config.iThreads < 1) { config.iThreads = 1; set_vm_value(vm, "threads", config.iThreads); } config.bVerifyPeer = !bInsecure; config.bColor = !bNoColor; config.bUnicode = !bNoUnicode; config.bDuplicateHandler = !bNoDuplicateHandler; config.bRemoteXML = !bNoRemoteXML; config.bSubDirectories = !bNoSubDirectories; config.bPlatformDetection = !bNoPlatformDetection; for (auto i = unrecognized_options_cli.begin(); i != unrecognized_options_cli.end(); ++i) if (i->compare(0, GlobalConstants::PROTOCOL_PREFIX.length(), GlobalConstants::PROTOCOL_PREFIX) == 0) config.sFileIdString = *i; if (!config.sFileIdString.empty()) { if (config.sFileIdString.compare(0, GlobalConstants::PROTOCOL_PREFIX.length(), GlobalConstants::PROTOCOL_PREFIX) == 0) { config.sFileIdString.replace(0, GlobalConstants::PROTOCOL_PREFIX.length(), ""); } vFileIdStrings = Util::tokenize(config.sFileIdString, ","); } if (!config.sOutputFilename.empty() && vFileIdStrings.size() > 1) { std::cerr << "Cannot specify an output file name when downloading multiple files." << std::endl; return 1; } if (bLogin) { config.bLoginAPI = true; config.bLoginHTTP = true; } if (config.sXMLFile == "automatic") config.bAutomaticXMLCreation = true; Util::parseOptionString(sInstallerLanguage, config.vLanguagePriority, config.iInstallerLanguage, GlobalConstants::LANGUAGES); Util::parseOptionString(sInstallerPlatform, config.vPlatformPriority, config.iInstallerPlatform, GlobalConstants::PLATFORMS); unsigned int include_value = 0; unsigned int exclude_value = 0; std::vector vInclude = Util::tokenize(sIncludeOptions, ","); std::vector vExclude = Util::tokenize(sExcludeOptions, ","); for (std::vector::iterator it = vInclude.begin(); it != vInclude.end(); it++) { include_value |= Util::getOptionValue(*it, INCLUDE_OPTIONS); } for (std::vector::iterator it = vExclude.begin(); it != vExclude.end(); it++) { exclude_value |= Util::getOptionValue(*it, INCLUDE_OPTIONS); } config.iInclude = include_value & ~exclude_value; // Assign values // TODO: Use config.iInclude in Downloader class directly and get rid of this value assignment config.bCover = (config.iInclude & OPTION_COVERS); config.bInstallers = (config.iInclude & OPTION_INSTALLERS); config.bExtras = (config.iInclude & OPTION_EXTRAS); config.bPatches = (config.iInclude & OPTION_PATCHES); config.bLanguagePacks = (config.iInclude & OPTION_LANGPACKS); config.bDLC = (config.iInclude & OPTION_DLCS); } catch (std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; return 1; } catch (...) { std::cerr << "Exception of unknown type!" << std::endl; return 1; } if (config.iInstallerPlatform < GlobalConstants::PLATFORMS[0].id || config.iInstallerPlatform > platform_all) { std::cerr << "Invalid value for --platform" << std::endl; return 1; } if (config.iInstallerLanguage < GlobalConstants::LANGUAGES[0].id || config.iInstallerLanguage > language_all) { std::cerr << "Invalid value for --language" << std::endl; return 1; } if (!config.sXMLDirectory.empty()) { // Make sure that xml directory doesn't have trailing slash if (config.sXMLDirectory.at(config.sXMLDirectory.length()-1)=='/') config.sXMLDirectory.assign(config.sXMLDirectory.begin(),config.sXMLDirectory.end()-1); } // Create GOG XML for a file if (!config.sXMLFile.empty() && (config.sXMLFile != "automatic")) { Util::createXML(config.sXMLFile, config.iChunkSize, config.sXMLDirectory); return 0; } // Make sure that directory has trailing slash if (!config.sDirectory.empty()) { if (config.sDirectory.at(config.sDirectory.length()-1)!='/') config.sDirectory += "/"; } else { config.sDirectory = "./"; // Directory wasn't specified, use current directory } // CA certificate bundle if (config.sCACertPath.empty()) { // Use CURL_CA_BUNDLE environment variable for CA certificate path if it is set char *ca_bundle = getenv("CURL_CA_BUNDLE"); if (ca_bundle) config.sCACertPath = (std::string)ca_bundle; } if (!unrecognized_options_cfg.empty() && (!config.bSaveConfig || !config.bResetConfig)) { std::cerr << "Unrecognized options in " << config.sConfigFilePath << std::endl; for (unsigned int i = 0; i < unrecognized_options_cfg.size(); i+=2) { std::cerr << unrecognized_options_cfg[i] << " = " << unrecognized_options_cfg[i+1] << std::endl; } std::cerr << std::endl; } // Init curl globally ssl_thread_setup(); curl_global_init(CURL_GLOBAL_ALL); if (config.bLoginAPI) { config.sToken = ""; config.sSecret = ""; } Downloader downloader(config); int iLoginTries = 0; bool bLoginOK = false; // Login because --login, --login-api or --login-website was used if (config.bLoginAPI || config.bLoginHTTP) bLoginOK = downloader.login(); bool bIsLoggedin = downloader.isLoggedIn(); // Login because we are not logged in while (iLoginTries++ < config.iRetries && !bIsLoggedin) { bLoginOK = downloader.login(); if (bLoginOK) { bIsLoggedin = downloader.isLoggedIn(); } } // Login failed, cleanup if (!bLoginOK && !bIsLoggedin) { curl_global_cleanup(); ssl_thread_cleanup(); return 1; } // Make sure that config file and cookie file are only readable/writable by owner if (!config.bRespectUmask) { Util::setFilePermissions(config.sConfigFilePath, boost::filesystem::owner_read | boost::filesystem::owner_write); Util::setFilePermissions(config.sCookiePath, boost::filesystem::owner_read | boost::filesystem::owner_write); } if (config.bSaveConfig || bLoginOK) { if (bLoginOK) { set_vm_value(vm, "token", downloader.config.sToken); set_vm_value(vm, "secret", downloader.config.sSecret); } std::ofstream ofs(config.sConfigFilePath.c_str()); if (ofs) { std::cerr << "Saving config: " << config.sConfigFilePath << std::endl; for (bpo::variables_map::iterator it = vm.begin(); it != vm.end(); ++it) { std::string option = it->first; std::string option_value_string; const bpo::variable_value& option_value = it->second; try { if (options_cfg_all.find(option, false).long_name() == option) { if (!option_value.empty()) { const std::type_info& type = option_value.value().type() ; if ( type == typeid(std::string) ) option_value_string = option_value.as(); else if ( type == typeid(int) ) option_value_string = std::to_string(option_value.as()); else if ( type == typeid(size_t) ) option_value_string = std::to_string(option_value.as()); else if ( type == typeid(unsigned int) ) option_value_string = std::to_string(option_value.as()); else if ( type == typeid(long int) ) option_value_string = std::to_string(option_value.as()); else if ( type == typeid(bool) ) { if (option_value.as() == true) option_value_string = "true"; else option_value_string = "false"; } } } } catch (...) { continue; } if (!option_value_string.empty()) { ofs << option << " = " << option_value_string << std::endl; } } ofs.close(); if (!config.bRespectUmask) Util::setFilePermissions(config.sConfigFilePath, boost::filesystem::owner_read | boost::filesystem::owner_write); if (config.bSaveConfig) { curl_global_cleanup(); ssl_thread_cleanup(); return 0; } } else { std::cerr << "Failed to create config: " << config.sConfigFilePath << std::endl; curl_global_cleanup(); ssl_thread_cleanup(); return 1; } } else if (config.bResetConfig) { std::ofstream ofs(config.sConfigFilePath.c_str()); if (ofs) { if (!config.sToken.empty() && !config.sSecret.empty()) { ofs << "token = " << config.sToken << std::endl; ofs << "secret = " << config.sSecret << std::endl; } ofs.close(); if (!config.bRespectUmask) Util::setFilePermissions(config.sConfigFilePath, boost::filesystem::owner_read | boost::filesystem::owner_write); curl_global_cleanup(); ssl_thread_cleanup(); return 0; } else { std::cerr << "Failed to create config: " << config.sConfigFilePath << std::endl; curl_global_cleanup(); ssl_thread_cleanup(); return 1; } } bool bInitOK = downloader.init(); if (!bInitOK) { curl_global_cleanup(); ssl_thread_cleanup(); return 1; } int res = 0; if (config.bShowWishlist) downloader.showWishlist(); else if (config.bUpdateCache) downloader.updateCache(); else if (config.bUpdateCheck) // Update check has priority over download and list downloader.updateCheck(); else if (!vFileIdStrings.empty()) { for (std::vector::iterator it = vFileIdStrings.begin(); it != vFileIdStrings.end(); it++) { res |= downloader.downloadFileWithId(*it, config.sOutputFilename) ? 1 : 0; } } else if (config.bRepair) // Repair file downloader.repair(); else if (config.bDownload) // Download games downloader.download(); else if (config.bListDetails || config.bList) // Detailed list of games/extras res = downloader.listGames(); else if (!config.sOrphanRegex.empty()) // Check for orphaned files if regex for orphans is set downloader.checkOrphans(); else if (config.bCheckStatus) downloader.checkStatus(); else { if (!(config.bLoginAPI || config.bLoginHTTP)) { // Show help message std::cerr << config.sVersionString << std::endl << options_cli_all << std::endl; } } // Orphan check was called at the same time as download. Perform it after download has finished if (!config.sOrphanRegex.empty() && config.bDownload) downloader.checkOrphans(); curl_global_cleanup(); ssl_thread_cleanup(); return res; } lgogdownloader-3.1/man/000077500000000000000000000000001303617702600151445ustar00rootroot00000000000000lgogdownloader-3.1/man/CMakeLists.txt000066400000000000000000000017231303617702600177070ustar00rootroot00000000000000find_program(HELP2MAN help2man DOC "Location of the help2man program") find_program(GZIP gzip DOC "Location of the gzip program") mark_as_advanced(HELP2MAN) mark_as_advanced(GZIP) if(HELP2MAN AND GZIP) set(H2M_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.supplemental.groff) set(MAN_PAGE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.1) set(MAN_FILE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.1.gz) add_custom_command( OUTPUT ${MAN_FILE} COMMAND ${HELP2MAN} -N -i ${H2M_FILE} -o ${MAN_PAGE} ${PROJECT_BINARY_DIR}/${PROJECT_NAME}${CMAKE_EXECUTABLE_SUFFIX} COMMAND ${GZIP} -f -9 ${MAN_PAGE} MAIN_DEPENDENCY ${H2M_FILE} COMMENT "Building man page" VERBATIM ) add_custom_target(manpage ALL DEPENDS ${MAN_FILE} ${PROJECT_NAME}) install(FILES ${MAN_FILE} DESTINATION ${INSTALL_SHARE_DIR}/man/man1) else(HELP2MAN AND GZIP) message("WARNING: One of the following is missing: help2man, gzip; man page will not be generated") endif(HELP2MAN AND GZIP) lgogdownloader-3.1/man/lgogdownloader.supplemental.groff000066400000000000000000000115461303617702600237170ustar00rootroot00000000000000[synopsis] .B lgogdownloader [\fIOPTION\fP]... [description] An open-source GOG.com downloader for Linux users which uses the same API as the official GOGDownloader. .PP LGOGDownloader can download purchased games, query GOG.com to see if game files have changed, as well as downloading extras such as artwork and manuals. It is capable of downloading language-specific installers for games where they exist. .PP These games are currently offered only for the Microsoft Windows\[rg] and Apple OS X\[rg] operating systems. To play these games under GNU/Linux will require a compatibility layer such as Wine. Usage of such a program is outside the scope of this document. /--update-check/ .nf /--no-installers/ .fi /Status codes:/ .nf [blacklist] .fi Allows user to specify individual files that should not be downloaded or mentioned as orphans. .sp 1 Each line in the file specifies one blacklist expression, except for empty lines and lines starting with #. First few characters specify blacklist item type and flags. So far, only regular expression (perl variant) are supported, so each line must start with "Rp" characters. After a space comes the expression itself. Expressions are matched against file path relative to what was specified as \fI--directory\fP. \fIExample black list\fP .br # used to store manually downloaded mods/patches/maps/, don't mention it as orphans .br Rp ^[^/]*/manual/.* .br # included with every *divinity game, once is enough .br Rp beyond_divinity/extras/bd_ladymageknight\.zip .br Rp divinity_2_developers_cut/extras/divinity_2_ladymageknight\.zip .sp # extra 6GB is A LOT of space if you don't actually plan to mod your game .br Rp the_witcher_2/extras/the_witcher_2_redkit\.zip .br Rp the_witcher_2/extras/extras_pack_3_hu_pl_ru_tr_zh_\.zip .br Rp the_witcher_2/extras/extras_pack_2_fr_it_jp_\.zip [files] .fi .TP \fI$XDG_CONFIG_HOME/lgogdownloader/\fP Storage for configuration files and cookies .br If \fB$XDG_CONFIG_HOME\fP is not set, it will use \fI$HOME/.config/lgogdownloader/\fP. .TP \fI$XDG_CACHE_HOME/lgogdownloader/xml/\fP Storage for XML files .br If \fB$XDG_CACHE_HOME\fP is not set, it will use \fI$HOME/.cache/lgogdownloader/xml/\fP. .TP \fI$XDG_CONFIG_HOME/lgogdownloader/blacklist.txt\fP Allows user to specify individual files that should not be downloaded. .br It doesn't have to exist, but if it does exist, it must be readable to lgogdownloader. .TP \fI$XDG_CONFIG_HOME/lgogdownloader/ignorelist.txt\fP Allows user to specify individual files that should not be mentioned as orphans. The file has the same format and interpretation as a blacklist. .br It doesn't have to exist, but if it does exist, it must be readable to lgogdownloader. .TP \fI$XDG_CONFIG_HOME/lgogdownloader/game_has_dlc.txt\fP Allows user to specify which games have dlc and should have their DLC count information ignored. The file has the same format and interpretation as a blacklist. .br It doesn't have to exist, but if it does exist, it must be readable to lgogdownloader. .br If the file exists lgogdownloader uses it instead of list specified with \fB--dlc-list\fP option .TP \fI$XDG_CONFIG_HOME/lgogdownloader/gamespecific/gamename.conf\fP JSON formatted file. Sets game specific settings for \fBgamename\fP. .br Allowed settings are \fBlanguage\fP, \fBplatform\fP, \fBdlc\fP, \fBignore-dlc-count\fP \fBsubdirectories\fP, \fBdirectory\fP, \fBsubdir-game\fP, \fBsubdir-installers\fP, \fBsubdir-extras\fP, \fBsubdir-patches\fP, \fBsubdir-language-packs\fP and \fBsubdir-dlc\fP. .br The \fBdlc\fP option is limited to disabling DLC for specific game. It can't enable DLC listing/downloading if \fB--no-dlc\fP option is used. .br Must be in the following format: .br { "language" : , "platform" : , "dlc" : , "ignore-dlc-count" : , "subdirectories" : , "directory" : , "subdir-game" : , "subdir-installers" : , "subdir-extras" : , "subdir-patches" : , "subdir-language-packs" : , "subdir-dlc" : .br } [priorities] Separating values with "," when using \fBlanguage\fP and \fBplatform\fP switches enables a priority-based mode: only the first matching one will be downloaded. .PP For example, setting \fBlanguage\fP to \fBfr+en\fP means both French and English will be downloaded (if available) for all games. Setting \fBlanguage\fP to \fBfr,en\fP means that the French version (and only that one) will be downloaded if available, and if not, the English version will be downloaded. .PP You're allowed to "stack" codes in the priority string if needed. If you set \fBlanguage\fP to \fBes+fr,en\fP it means it'll download both Spanish (es) and French (fr) versions if they are available, and the English (en) one only if none of French and Spanish are available. [availability] The latest version of this distribution is available from \fIhttps://github.com/Sude-/lgogdownloader\fP lgogdownloader-3.1/src/000077500000000000000000000000001303617702600151605ustar00rootroot00000000000000lgogdownloader-3.1/src/api.cpp000066400000000000000000000705211303617702600164420ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "api.h" #include "gamefile.h" #include #include #include #include #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40900 # define _regex_namespace_ std # include #else # define _regex_namespace_ boost # include #endif size_t writeMemoryCallback(char *ptr, size_t size, size_t nmemb, void *userp) { std::ostringstream *stream = (std::ostringstream*)userp; std::streamsize count = (std::streamsize) size * nmemb; stream->write(ptr, count); return count; } API::API(const std::string& token, const std::string& secret) { curlhandle = curl_easy_init(); curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 1); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curlhandle, CURLOPT_PROGRESSDATA, this); curl_easy_setopt(curlhandle, CURLOPT_FAILONERROR, true); curl_easy_setopt(curlhandle, CURLOPT_NOSIGNAL, 1); this->error = false; this->config.oauth_token = token; this->config.oauth_secret = secret; } /* Initialize the API returns 0 if failed returns 1 if successful */ int API::init() { int res = 0; this->getAPIConfig(); if (!this->getError()) res = 1; else this->clearError(); return res; } /* Login check returns false if not logged in returns true if logged in */ bool API::isLoggedIn() { int res = 0; // Check if we already have token and secret if (!this->config.oauth_token.empty() && !this->config.oauth_secret.empty()) { // Test authorization by getting user details res = this->getUserDetails(); // res = 1 if successful } return res; } int API::getAPIConfig() { std::string url = "https://api.gog.com/downloader2/status/stable/"; // Stable API //std::string url = "https://api.gog.com/downloader2/status/beta/"; // Beta API //std::string url = "https://api.gog.com/downloader2/status/e77989ed21758e78331b20e477fc5582/"; // Development API? Not sure because the downloader version number it reports is lower than beta. int res = 0; std::string json = this->getResponse(url); if (!json.empty()) { Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getAPIConfig)" << std::endl << root << std::endl; #endif this->config.oauth_authorize_temp_token = root["config"]["oauth_authorize_temp_token"].asString() + "/"; this->config.oauth_get_temp_token = root["config"]["oauth_get_temp_token"].asString() + "/"; this->config.oauth_get_token = root["config"]["oauth_get_token"].asString() + "/"; this->config.get_user_games = root["config"]["get_user_games"].asString() + "/"; this->config.get_user_details = root["config"]["get_user_details"].asString() + "/"; this->config.get_installer_link = root["config"]["get_installer_link"].asString() + "/"; this->config.get_game_details = root["config"]["get_game_details"].asString() + "/"; this->config.get_extra_link = root["config"]["get_extra_link"].asString() + "/"; this->config.set_app_status = root["config"]["set_app_status"].asString() + "/"; res = 1; } else { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getAPIConfig)" << std::endl << json << std::endl; #endif this->setError(jsonparser->getFormattedErrorMessages()); res = 0; } delete jsonparser; } else { this->setError("Found nothing in " + url); res = 0; } return res; } int API::login(const std::string& email, const std::string& password) { int res = 0; std::string url; std::string token, secret; // Get temporary request token url = oauth_sign_url2(this->config.oauth_get_temp_token.c_str(), NULL, OA_HMAC, NULL, CONSUMER_KEY.c_str(), CONSUMER_SECRET.c_str(), NULL /* token */, NULL /* secret */); std::string request_token_resp = this->getResponse(url); char **rv = NULL; int rc = oauth_split_url_parameters(request_token_resp.c_str(), &rv); qsort(rv, rc, sizeof(char *), oauth_cmpstringp); if (rc == 3 && !strncmp(rv[1], "oauth_token=", OAUTH_TOKEN_LENGTH) && !strncmp(rv[2], "oauth_token_secret=", OAUTH_SECRET_LENGTH)) { token = rv[1]+OAUTH_TOKEN_LENGTH+1; secret = rv[2]+OAUTH_SECRET_LENGTH+1; rv = NULL; } else { return res; } // Authorize temporary token and get verifier url = this->config.oauth_authorize_temp_token + "?username=" + oauth_url_escape(email.c_str()) + "&password=" + oauth_url_escape(password.c_str()); url = oauth_sign_url2(url.c_str(), NULL, OA_HMAC, NULL, CONSUMER_KEY.c_str(), CONSUMER_SECRET.c_str(), token.c_str(), secret.c_str()); std::string authorize_resp = this->getResponse(url); std::string verifier; rc = oauth_split_url_parameters(authorize_resp.c_str(), &rv); qsort(rv, rc, sizeof(char *), oauth_cmpstringp); if (rc == 2 && !strncmp(rv[1], "oauth_verifier=", OAUTH_VERIFIER_LENGTH)) { verifier = rv[1]+OAUTH_VERIFIER_LENGTH+1; rv = NULL; } else { return res; } // Get final token and secret url = this->config.oauth_get_token + "?oauth_verifier=" + verifier; url = oauth_sign_url2(url.c_str(), NULL, OA_HMAC, NULL, CONSUMER_KEY.c_str(), CONSUMER_SECRET.c_str(), token.c_str(), secret.c_str()); std::string token_resp = this->getResponse(url); rc = oauth_split_url_parameters(token_resp.c_str(), &rv); qsort(rv, rc, sizeof(char *), oauth_cmpstringp); if (rc == 2 && !strncmp(rv[0], "oauth_token=", OAUTH_TOKEN_LENGTH) && !strncmp(rv[1], "oauth_token_secret=", OAUTH_SECRET_LENGTH)) { this->config.oauth_token = rv[0]+OAUTH_TOKEN_LENGTH+1; this->config.oauth_secret = rv[1]+OAUTH_SECRET_LENGTH+1; free(rv); res = 1; } return res; } int API::getUserDetails() { int res = 0; std::string url; url = this->config.get_user_details; std::string json = this->getResponseOAuth(url); if (!json.empty()) { Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getUserDetails)" << std::endl << root << std::endl; #endif this->user.id = std::stoull(root["user"]["id"].asString()); this->user.username = root["user"]["xywka"].asString(); this->user.email = root["user"]["email"].asString(); this->user.avatar_big = root["user"]["avatar"]["big"].asString(); this->user.avatar_small = root["user"]["avatar"]["small"].asString(); this->user.notifications_forum = root["user"]["notifications"]["forum"].isInt() ? root["user"]["notifications"]["forum"].asInt() : std::stoi(root["user"]["notifications"]["forum"].asString()); this->user.notifications_games = root["user"]["notifications"]["games"].isInt() ? root["user"]["notifications"]["games"].asInt() : std::stoi(root["user"]["notifications"]["games"].asString()); this->user.notifications_messages = root["user"]["notifications"]["messages"].isInt() ? root["user"]["notifications"]["messages"].asInt() : std::stoi(root["user"]["notifications"]["messages"].asString()); res = 1; } else { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getUserDetails)" << std::endl << json << std::endl; #endif this->setError(jsonparser->getFormattedErrorMessages()); res = 0; } delete jsonparser; } else { this->setError("Found nothing in " + url); res = 0; } return res; } int API::getGames() { // Not implemented on the server side currently //std::string json = this->getResponseOAuth(this->config.get_user_games); return 0; } std::string API::getResponse(const std::string& url) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getResponse)" << std::endl << "URL: " << url << std::endl; #endif std::ostringstream memory; curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str()); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, writeMemoryCallback); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &memory); CURLcode result = curl_easy_perform(curlhandle); std::string response = memory.str(); memory.str(std::string()); if (result == CURLE_HTTP_RETURNED_ERROR) { long int response_code = 0; result = curl_easy_getinfo(curlhandle, CURLINFO_RESPONSE_CODE, &response_code); if (result == CURLE_OK) this->setError("HTTP ERROR: " + std::to_string(response_code) + " (" + url + ")"); else this->setError("HTTP ERROR: failed to get error code: " + static_cast(curl_easy_strerror(result)) + " (" + url + ")"); #ifdef DEBUG curl_easy_setopt(curlhandle, CURLOPT_FAILONERROR, false); result = curl_easy_perform(curlhandle); std::string debug_response = memory.str(); memory.str(std::string()); std::cerr << "Response (CURLE_HTTP_RETURNED_ERROR):"; if (debug_response.empty()) std::cerr << " Response was empty" << std::endl; else std::cerr << std::endl << debug_response << std::endl; curl_easy_setopt(curlhandle, CURLOPT_FAILONERROR, true); #endif } return response; } std::string API::getResponseOAuth(const std::string& url) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getResponseOAuth)" << std::endl << "URL: " << url << std::endl; #endif std::string url_oauth = oauth_sign_url2(url.c_str(), NULL, OA_HMAC, NULL, CONSUMER_KEY.c_str(), CONSUMER_SECRET.c_str(), this->config.oauth_token.c_str(), this->config.oauth_secret.c_str()); std::string response = this->getResponse(url_oauth); return response; } gameDetails API::getGameDetails(const std::string& game_name, const unsigned int& platform, const unsigned int& lang, const bool& useDuplicateHandler) { std::string url; gameDetails game; struct gameFileInfo { Json::Value jsonNode; unsigned int platform; unsigned int language; }; url = this->config.get_game_details + game_name + "/" + "installer_win_en"; // can't get game details without file id, any file id seems to return all details which is good for us std::string json = this->getResponseOAuth(url); if (!json.empty()) { Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getGameDetails)" << std::endl << root << std::endl; #endif game.gamename = game_name; game.title = root["game"]["title"].asString(); game.icon = root["game"]["icon"].asString(); std::vector membernames = root["game"].getMemberNames(); // Installer details // Create a list of installers from JSON std::vector installers; for (unsigned int i = 0; i < GlobalConstants::PLATFORMS.size(); ++i) { // Check against the specified platforms if (platform & GlobalConstants::PLATFORMS[i].id) { std::string installer = "installer_" + GlobalConstants::PLATFORMS[i].code + "_"; for (unsigned int j = 0; j < GlobalConstants::LANGUAGES.size(); ++j) { // Check against the specified languages if (lang & GlobalConstants::LANGUAGES[j].id) { // Make sure that the installer exists in the JSON if (root["game"].isMember(installer+GlobalConstants::LANGUAGES[j].code)) { gameFileInfo installerInfo; installerInfo.jsonNode = root["game"][installer+GlobalConstants::LANGUAGES[j].code]; installerInfo.platform = GlobalConstants::PLATFORMS[i].id; installerInfo.language = GlobalConstants::LANGUAGES[j].id; installers.push_back(installerInfo); } } } } } for ( unsigned int i = 0; i < installers.size(); ++i ) { for ( unsigned int index = 0; index < installers[i].jsonNode.size(); ++index ) { Json::Value installer = installers[i].jsonNode[index]; unsigned int language = installers[i].language; // Check for duplicate installers in different languages and add languageId of duplicate installer to the original installer // https://secure.gog.com/forum/general/introducing_the_beta_release_of_the_new_gogcom_downloader/post1483 if (useDuplicateHandler) { bool bDuplicate = false; for (unsigned int j = 0; j < game.installers.size(); ++j) { if (game.installers[j].path == installer["link"].asString()) { game.installers[j].language |= language; // Add language code to installer bDuplicate = true; break; } } if (bDuplicate) continue; } gameFile gf; gf.type = GFTYPE_INSTALLER; gf.gamename = game.gamename; gf.updated = installer["notificated"].isInt() ? installer["notificated"].asInt() : std::stoi(installer["notificated"].asString()); gf.id = installer["id"].isInt() ? std::to_string(installer["id"].asInt()) : installer["id"].asString(); gf.name = installer["name"].asString(); gf.path = installer["link"].asString(); gf.size = installer["size"].asString(); gf.language = language; gf.platform = installers[i].platform; gf.silent = installer["silent"].isInt() ? installer["silent"].asInt() : std::stoi(installer["silent"].asString()); game.installers.push_back(gf); } } // Extra details const Json::Value extras = root["game"]["extras"]; for ( unsigned int index = 0; index < extras.size(); ++index ) { Json::Value extra = extras[index]; gameFile gf; gf.type = GFTYPE_EXTRA; gf.gamename = game.gamename; gf.updated = false; // extras don't have "updated" flag gf.id = extra["id"].isInt() ? std::to_string(extra["id"].asInt()) : extra["id"].asString(); gf.name = extra["name"].asString(); gf.path = extra["link"].asString(); gf.size = extra["size_mb"].asString(); game.extras.push_back(gf); } // Patch details for (unsigned int i = 0; i < GlobalConstants::LANGUAGES.size(); ++i) { // Check against the specified languages if (lang & GlobalConstants::LANGUAGES[i].id) { // Try to find a patch _regex_namespace_::regex re(GlobalConstants::LANGUAGES[i].code + "\\d+patch\\d+", _regex_namespace_::regex_constants::icase); // regex for patch node names std::vector patches; for (unsigned int j = 0; j < membernames.size(); ++j) { if (_regex_namespace_::regex_match(membernames[j], re)) { // Regex matches, we have a patch node gameFileInfo patchInfo; patchInfo.jsonNode = root["game"][membernames[j]]; patchInfo.language = GlobalConstants::LANGUAGES[i].id; if (patchInfo.jsonNode["link"].asString().find("/mac/") != std::string::npos) patchInfo.platform = GlobalConstants::PLATFORM_MAC; else if (patchInfo.jsonNode["link"].asString().find("/linux/") != std::string::npos) patchInfo.platform = GlobalConstants::PLATFORM_LINUX; else patchInfo.platform = GlobalConstants::PLATFORM_WINDOWS; if (platform & patchInfo.platform) patches.push_back(patchInfo); } } if (!patches.empty()) // found at least one patch { for (unsigned int j = 0; j < patches.size(); ++j) { Json::Value patchnode = patches[j].jsonNode; if (patchnode.isArray()) // Patch has multiple files { for ( unsigned int index = 0; index < patchnode.size(); ++index ) { Json::Value patch = patchnode[index]; // Check for duplicate patches in different languages and add languageId of duplicate patch to the original patch if (useDuplicateHandler) { bool bDuplicate = false; for (unsigned int j = 0; j < game.patches.size(); ++j) { if (game.patches[j].path == patch["link"].asString()) { game.patches[j].language |= GlobalConstants::LANGUAGES[i].id; // Add language code to patch bDuplicate = true; break; } } if (bDuplicate) continue; } gameFile gf; gf.type = GFTYPE_PATCH; gf.gamename = game.gamename; gf.updated = patch["notificated"].isInt() ? patch["notificated"].asInt() : std::stoi(patch["notificated"].asString()); gf.id = patch["id"].isInt() ? std::to_string(patch["id"].asInt()) : patch["id"].asString(); gf.name = patch["name"].asString(); gf.path = patch["link"].asString(); gf.size = patch["size"].asString(); gf.language = GlobalConstants::LANGUAGES[i].id; gf.platform = patches[j].platform; game.patches.push_back(gf); } } else // Patch is a single file { // Check for duplicate patches in different languages and add languageId of duplicate patch to the original patch if (useDuplicateHandler) { bool bDuplicate = false; for (unsigned int k = 0; k < game.patches.size(); ++k) { if (game.patches[k].path == patchnode["link"].asString()) { game.patches[k].language |= GlobalConstants::LANGUAGES[i].id; // Add language code to patch bDuplicate = true; break; } } if (bDuplicate) continue; } gameFile gf; gf.type = GFTYPE_PATCH; gf.gamename = game.gamename; gf.updated = patchnode["notificated"].isInt() ? patchnode["notificated"].asInt() : std::stoi(patchnode["notificated"].asString()); gf.id = patchnode["id"].isInt() ? std::to_string(patchnode["id"].asInt()) : patchnode["id"].asString(); gf.name = patchnode["name"].asString(); gf.path = patchnode["link"].asString(); gf.size = patchnode["size"].asString(); gf.language = GlobalConstants::LANGUAGES[i].id; gf.platform = patches[j].platform; game.patches.push_back(gf); } } } } } // Language pack details for (unsigned int i = 0; i < GlobalConstants::LANGUAGES.size(); ++i) { // Check against the specified languages if (lang & GlobalConstants::LANGUAGES[i].id) { // Try to find a language pack _regex_namespace_::regex re(GlobalConstants::LANGUAGES[i].code + "\\d+langpack\\d+", _regex_namespace_::regex_constants::icase); // regex for language pack node names std::vector langpacknames; for (unsigned int j = 0; j < membernames.size(); ++j) { if (_regex_namespace_::regex_match(membernames[j], re)) langpacknames.push_back(membernames[j]); } if (!langpacknames.empty()) // found at least one language pack { for (unsigned int j = 0; j < langpacknames.size(); ++j) { Json::Value langpack = root["game"][langpacknames[j]]; gameFile gf; gf.type = GFTYPE_LANGPACK; gf.gamename = game.gamename; gf.updated = false; // language packs don't have "updated" flag gf.id = langpack["id"].isInt() ? std::to_string(langpack["id"].asInt()) : langpack["id"].asString(); gf.name = langpack["name"].asString(); gf.path = langpack["link"].asString(); gf.size = langpack["size"].asString(); gf.language = GlobalConstants::LANGUAGES[i].id; game.languagepacks.push_back(gf); } } } } } else { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getGameDetails)" << std::endl << json << std::endl; #endif this->setError(jsonparser->getFormattedErrorMessages()); } delete jsonparser; } else { this->setError("Found nothing in " + url); } return game; } std::string API::getInstallerLink(const std::string& game_name, const std::string& id) { std::string url, link; url = this->config.get_installer_link + game_name + "/" + id + "/"; std::string json = this->getResponseOAuth(url); if (!json.empty()) { Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getInstallerLink)" << std::endl << root << std::endl; #endif int available = root["file"]["available"].isInt() ? root["file"]["available"].asInt() : std::stoi(root["file"]["available"].asString()); if (available) link = root["file"]["link"].asString(); } else { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getInstallerLink)" << std::endl << json << std::endl; #endif this->setError(jsonparser->getFormattedErrorMessages()); } delete jsonparser; } else { this->setError("Found nothing in " + url); } return link; } std::string API::getExtraLink(const std::string& game_name, const std::string& id) { std::string url, link; url = this->config.get_extra_link + game_name + "/" + id + "/"; std::string json = this->getResponseOAuth(url); if (!json.empty()) { Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getExtraLink)" << std::endl << root << std::endl; #endif int available = root["file"]["available"].isInt() ? root["file"]["available"].asInt() : std::stoi(root["file"]["available"].asString()); if (available) link = root["file"]["link"].asString(); } else { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getExtraLink)" << std::endl << json << std::endl; #endif this->setError(jsonparser->getFormattedErrorMessages()); } delete jsonparser; } else { this->setError("Found nothing in " + url); } return link; } std::string API::getPatchLink(const std::string& game_name, const std::string& id) { return this->getInstallerLink(game_name, id); } std::string API::getLanguagePackLink(const std::string& game_name, const std::string& id) { return this->getInstallerLink(game_name, id); } std::string API::getXML(const std::string& game_name, const std::string& id) { std::string url, XML; url = this->config.get_installer_link + game_name + "/" + id + "/crc/"; std::string json = this->getResponseOAuth(url); if (!json.empty()) { Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getXML)" << std::endl << root << std::endl; #endif int available = root["file"]["available"].isInt() ? root["file"]["available"].asInt() : std::stoi(root["file"]["available"].asString()); if (available) { url = root["file"]["link"].asString(); XML = this->getResponse(url); } } else { #ifdef DEBUG std::cerr << "DEBUG INFO (API::getXML)" << std::endl << json << std::endl; #endif this->setError(jsonparser->getFormattedErrorMessages()); } delete jsonparser; } else { this->setError("Found nothing in " + url); } return XML; } void API::clearError() { this->error = false; this->error_message = ""; } void API::setError(const std::string& err) { this->error = true; if (this->error_message.empty()) this->error_message = err; else this->error_message += "\n" + err; } API::~API() { curl_easy_cleanup(curlhandle); } lgogdownloader-3.1/src/blacklist.cpp000066400000000000000000000050611303617702600176360ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "blacklist.h" #include "config.h" #include "api.h" #include "util.h" #include #include enum { BLFLAG_RX = 1 << 0, BLFLAG_PERL = 1 << 1 }; void Blacklist::initialize(const std::vector& lines) { int linenr = 1; for (auto it = lines.begin(); it != lines.end(); ++it, ++linenr) { BlacklistItem item; const std::string& s = *it; if (s.length() == 0 || s[0] == '#') continue; std::size_t i; for (i = 0; i < s.length() && s[i] != '\x20'; ++i) { switch (s[i]) { case 'R': item.flags |= BLFLAG_RX; break; case 'p': item.flags |= BLFLAG_PERL; break; default: std::cout << "unknown flag '" << s[i] << "' in blacklist line " << linenr << std::endl; break; } } ++i; if (i == s.length()) { std::cout << "empty expression in blacklist line " << linenr << std::endl; continue; } if (item.flags & BLFLAG_RX) { boost::regex::flag_type rx_flags = boost::regex::normal; // we only support perl-like syntax for now, which is boost default (normal). Add further flag processing // here if that changes. rx_flags |= boost::regex::nosubs; item.linenr = linenr; item.source.assign(s.substr(i).c_str()); item.regex.assign(item.source, rx_flags); blacklist_.push_back(std::move(item)); } else { std::cout << "unknown expression type in blacklist line " << linenr << std::endl; } } } bool Blacklist::isBlacklisted(const std::string& path) { for (auto it = blacklist_.begin(); it != blacklist_.end(); ++it) { const BlacklistItem& item = *it; if (item.flags & BLFLAG_RX && boost::regex_search(path, item.regex)) return true; } return false; } bool Blacklist::isBlacklisted(const std::string& path, const std::string& gamename, std::string subdirectory) { std::string filepath = Util::makeRelativeFilepath(path, gamename, subdirectory); return isBlacklisted(filepath); } lgogdownloader-3.1/src/downloader.cpp000066400000000000000000004065461303617702600200410ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "downloader.h" #include "util.h" #include "globalconstants.h" #include "downloadinfo.h" #include "message.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace bptime = boost::posix_time; std::vector vDownloadInfo; ThreadSafeQueue dlQueue; ThreadSafeQueue msgQueue; ThreadSafeQueue createXMLQueue; ThreadSafeQueue gameItemQueue; ThreadSafeQueue gameDetailsQueue; std::mutex mtx_create_directories; // Mutex for creating directories in Downloader::processDownloadQueue Downloader::Downloader(Config &conf) { this->config = conf; if (config.bLoginHTTP && boost::filesystem::exists(config.sCookiePath)) if (!boost::filesystem::remove(config.sCookiePath)) std::cerr << "Failed to delete " << config.sCookiePath << std::endl; this->resume_position = 0; this->retries = 0; // Initialize curl and set curl options curlhandle = curl_easy_init(); curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 1); curl_easy_setopt(curlhandle, CURLOPT_USERAGENT, config.sVersionString.c_str()); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 0); curl_easy_setopt(curlhandle, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(curlhandle, CURLOPT_CONNECTTIMEOUT, config.iTimeout); curl_easy_setopt(curlhandle, CURLOPT_FAILONERROR, true); curl_easy_setopt(curlhandle, CURLOPT_SSL_VERIFYPEER, config.bVerifyPeer); curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, config.bVerbose); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Downloader::writeData); curl_easy_setopt(curlhandle, CURLOPT_READFUNCTION, Downloader::readData); curl_easy_setopt(curlhandle, CURLOPT_MAX_RECV_SPEED_LARGE, config.iDownloadRate); curl_easy_setopt(curlhandle, CURLOPT_XFERINFOFUNCTION, Downloader::progressCallback); curl_easy_setopt(curlhandle, CURLOPT_XFERINFODATA, this); // Assume that we have connection error and abort transfer with CURLE_OPERATION_TIMEDOUT if download speed is less than 200 B/s for 30 seconds curl_easy_setopt(curlhandle, CURLOPT_LOW_SPEED_TIME, 30); curl_easy_setopt(curlhandle, CURLOPT_LOW_SPEED_LIMIT, 200); if (!config.sCACertPath.empty()) curl_easy_setopt(curlhandle, CURLOPT_CAINFO, config.sCACertPath.c_str()); // Create new GOG website handle gogWebsite = new Website(config); // Create new API handle and set curl options for the API gogAPI = new API(config.sToken, config.sSecret); gogAPI->curlSetOpt(CURLOPT_VERBOSE, config.bVerbose); gogAPI->curlSetOpt(CURLOPT_SSL_VERIFYPEER, config.bVerifyPeer); gogAPI->curlSetOpt(CURLOPT_CONNECTTIMEOUT, config.iTimeout); if (!config.sCACertPath.empty()) gogAPI->curlSetOpt(CURLOPT_CAINFO, config.sCACertPath.c_str()); gogAPI->init(); progressbar = new ProgressBar(config.bUnicode, config.bColor); } Downloader::~Downloader() { if (config.bReport) if (this->report_ofs) this->report_ofs.close(); delete progressbar; delete gogAPI; delete gogWebsite; curl_easy_cleanup(curlhandle); // Make sure that cookie file is only readable/writable by owner if (!config.bRespectUmask) Util::setFilePermissions(config.sCookiePath, boost::filesystem::owner_read | boost::filesystem::owner_write); } /* Login check returns false if not logged in returns true if logged in */ bool Downloader::isLoggedIn() { bool bIsLoggedIn = false; config.bLoginAPI = false; config.bLoginHTTP = false; bool bWebsiteIsLoggedIn = gogWebsite->IsLoggedIn(); if (!bWebsiteIsLoggedIn) config.bLoginHTTP = true; bool bIsLoggedInAPI = gogAPI->isLoggedIn(); if (!bIsLoggedInAPI) config.bLoginAPI = true; if (bIsLoggedInAPI && bWebsiteIsLoggedIn) bIsLoggedIn = true; return bIsLoggedIn; } /* Initialize the downloader returns 0 if failed returns 1 if successful */ int Downloader::init() { if (!config.sGameHasDLCList.empty()) { if (config.gamehasdlc.empty()) { std::string game_has_dlc_list = this->getResponse(config.sGameHasDLCList); if (!game_has_dlc_list.empty()) config.gamehasdlc.initialize(Util::tokenize(game_has_dlc_list, "\n")); } } gogWebsite->setConfig(config); // Update config for website handle if (config.bReport && (config.bDownload || config.bRepair)) { this->report_ofs.open(config.sReportFilePath); if (!this->report_ofs) { config.bReport = false; std::cerr << "Failed to create " << config.sReportFilePath << std::endl; return 0; } } return 1; } /* Login returns 0 if login fails returns 1 if successful */ int Downloader::login() { std::string email; if (!isatty(STDIN_FILENO)) { std::cerr << "Unable to read email and password" << std::endl; return 0; } std::cerr << "Email: "; std::getline(std::cin,email); std::string password; std::cerr << "Password: "; struct termios termios_old, termios_new; tcgetattr(STDIN_FILENO, &termios_old); // Get current terminal attributes termios_new = termios_old; termios_new.c_lflag &= ~ECHO; // Set ECHO off tcsetattr(STDIN_FILENO, TCSANOW, &termios_new); // Set terminal attributes std::getline(std::cin, password); tcsetattr(STDIN_FILENO, TCSANOW, &termios_old); // Restore old terminal attributes std::cerr << std::endl; if (email.empty() || password.empty()) { std::cerr << "Email and/or password empty" << std::endl; return 0; } else { // Login to website if (config.bLoginHTTP) { // Delete old cookies if (boost::filesystem::exists(config.sCookiePath)) if (!boost::filesystem::remove(config.sCookiePath)) std::cerr << "Failed to delete " << config.sCookiePath << std::endl; if (!gogWebsite->Login(email, password)) { std::cerr << "HTTP: Login failed" << std::endl; return 0; } else { std::cerr << "HTTP: Login successful" << std::endl; if (!config.bLoginAPI) return 1; } } // Login to API if (config.bLoginAPI) { if (!gogAPI->login(email, password)) { std::cerr << "API: Login failed" << std::endl; return 0; } else { std::cerr << "API: Login successful" << std::endl; config.sToken = gogAPI->getToken(); config.sSecret = gogAPI->getSecret(); return 1; } } } return 0; } void Downloader::updateCheck() { std::cout << "New forum replies: " << gogAPI->user.notifications_forum << std::endl; std::cout << "New private messages: " << gogAPI->user.notifications_messages << std::endl; std::cout << "Updated games: " << gogAPI->user.notifications_games << std::endl; if (gogAPI->user.notifications_games) { config.sGameRegex = ".*"; // Always check all games gogWebsite->setConfig(config); // Make sure that website handle has updated config if (config.bList || config.bListDetails || config.bDownload) { if (config.bList) config.bListDetails = true; // Always list details this->getGameList(); if (config.bDownload) this->download(); else this->listGames(); } } } void Downloader::getGameList() { if (config.sGameRegex == "free") { gameItems = gogWebsite->getFreeGames(); } else { gameItems = gogWebsite->getGames(); } } /* Get detailed info about the games returns 0 if successful returns 1 if fails */ int Downloader::getGameDetails() { // Set default game specific directory options to values from config gameSpecificDirectoryConfig dirConfDefault; dirConfDefault.sDirectory = config.sDirectory; dirConfDefault.bSubDirectories = config.bSubDirectories; dirConfDefault.sGameSubdir = config.sGameSubdir; dirConfDefault.sInstallersSubdir = config.sInstallersSubdir; dirConfDefault.sExtrasSubdir = config.sExtrasSubdir; dirConfDefault.sLanguagePackSubdir = config.sLanguagePackSubdir; dirConfDefault.sDLCSubdir = config.sDLCSubdir; dirConfDefault.sPatchesSubdir = config.sPatchesSubdir; if (config.bUseCache && !config.bUpdateCache) { // GameRegex filter alias for all games if (config.sGameRegex == "all") config.sGameRegex = ".*"; else if (config.sGameRegex == "free") std::cerr << "Warning: regex alias \"free\" doesn't work with cached details" << std::endl; int result = this->loadGameDetailsCache(); if (result == 0) { for (unsigned int i = 0; i < this->games.size(); ++i) { gameSpecificConfig conf; conf.dirConf = dirConfDefault; Util::getGameSpecificConfig(games[i].gamename, &conf); this->games[i].makeFilepaths(conf.dirConf); } return 0; } else { if (result == 1) { std::cerr << "Cache doesn't exist." << std::endl; std::cerr << "Create cache with --update-cache" << std::endl; } else if (result == 3) { std::cerr << "Cache is too old." << std::endl; std::cerr << "Update cache with --update-cache or use bigger --cache-valid" << std::endl; } else if (result == 5) { std::cerr << "Cache version doesn't match current version." << std::endl; std::cerr << "Update cache with --update-cache" << std::endl; } return 1; } } if (gameItems.empty()) this->getGameList(); if (!gameItems.empty()) { for (unsigned int i = 0; i < gameItems.size(); ++i) { gameItemQueue.push(gameItems[i]); } // Create threads unsigned int threads = std::min(config.iThreads, static_cast(gameItemQueue.size())); std::vector vThreads; for (unsigned int i = 0; i < threads; ++i) { DownloadInfo dlInfo; dlInfo.setStatus(DLSTATUS_NOTSTARTED); vDownloadInfo.push_back(dlInfo); vThreads.push_back(std::thread(Downloader::getGameDetailsThread, this->config, i)); } unsigned int dl_status = DLSTATUS_NOTSTARTED; while (dl_status != DLSTATUS_FINISHED) { dl_status = DLSTATUS_NOTSTARTED; // Print progress information once per 100ms std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::cerr << "\033[J\r" << std::flush; // Clear screen from the current line down to the bottom of the screen // Print messages from message queue first Message msg; while (msgQueue.try_pop(msg)) { std::cerr << msg.getFormattedString(config.bColor, true) << std::endl; if (config.bReport) { this->report_ofs << msg.getTimestampString() << ": " << msg.getMessage() << std::endl; } } for (unsigned int i = 0; i < vDownloadInfo.size(); ++i) { unsigned int status = vDownloadInfo[i].getStatus(); dl_status |= status; } std::cerr << "Getting game info " << (gameItems.size() - gameItemQueue.size()) << " / " << gameItems.size() << std::endl; if (dl_status != DLSTATUS_FINISHED) { std::cerr << "\033[1A\r" << std::flush; // Move cursor up by 1 row } } // Join threads for (unsigned int i = 0; i < vThreads.size(); ++i) vThreads[i].join(); vThreads.clear(); vDownloadInfo.clear(); gameDetails details; while (gameDetailsQueue.try_pop(details)) { this->games.push_back(details); } std::sort(this->games.begin(), this->games.end(), [](const gameDetails& i, const gameDetails& j) -> bool { return i.gamename < j.gamename; }); } return 0; } int Downloader::listGames() { if (config.bListDetails) // Detailed list { if (this->games.empty()) { int res = this->getGameDetails(); if (res > 0) return res; } for (unsigned int i = 0; i < games.size(); ++i) { std::cout << "gamename: " << games[i].gamename << std::endl << "title: " << games[i].title << std::endl << "icon: " << "http://static.gog.com" << games[i].icon << std::endl; if (!games[i].serials.empty()) std::cout << "serials:" << std::endl << games[i].serials << std::endl; // List installers if (config.bInstallers) { std::cout << "installers: " << std::endl; for (unsigned int j = 0; j < games[i].installers.size(); ++j) { if (!config.bUpdateCheck || games[i].installers[j].updated) // Always list updated files { std::string filepath = games[i].installers[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::string languages = Util::getOptionNameString(games[i].installers[j].language, GlobalConstants::LANGUAGES); std::cout << "\tid: " << games[i].installers[j].id << std::endl << "\tname: " << games[i].installers[j].name << std::endl << "\tpath: " << games[i].installers[j].path << std::endl << "\tsize: " << games[i].installers[j].size << std::endl << "\tupdated: " << (games[i].installers[j].updated ? "True" : "False") << std::endl << "\tlanguage: " << languages << std::endl << std::endl; } } } // List extras if (config.bExtras && !config.bUpdateCheck && !games[i].extras.empty()) { std::cout << "extras: " << std::endl; for (unsigned int j = 0; j < games[i].extras.size(); ++j) { std::string filepath = games[i].extras[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::cout << "\tid: " << games[i].extras[j].id << std::endl << "\tname: " << games[i].extras[j].name << std::endl << "\tpath: " << games[i].extras[j].path << std::endl << "\tsize: " << games[i].extras[j].size << std::endl << std::endl; } } // List patches if (config.bPatches && !config.bUpdateCheck && !games[i].patches.empty()) { std::cout << "patches: " << std::endl; for (unsigned int j = 0; j < games[i].patches.size(); ++j) { std::string filepath = games[i].patches[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::string languages = Util::getOptionNameString(games[i].patches[j].language, GlobalConstants::LANGUAGES); std::cout << "\tid: " << games[i].patches[j].id << std::endl << "\tname: " << games[i].patches[j].name << std::endl << "\tpath: " << games[i].patches[j].path << std::endl << "\tsize: " << games[i].patches[j].size << std::endl << "\tupdated: " << (games[i].patches[j].updated ? "True" : "False") << std::endl << "\tlanguage: " << languages << std::endl << std::endl; } } // List language packs if (config.bLanguagePacks && !config.bUpdateCheck && !games[i].languagepacks.empty()) { std::cout << "language packs: " << std::endl; for (unsigned int j = 0; j < games[i].languagepacks.size(); ++j) { std::string filepath = games[i].languagepacks[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::cout << "\tid: " << games[i].languagepacks[j].id << std::endl << "\tname: " << games[i].languagepacks[j].name << std::endl << "\tpath: " << games[i].languagepacks[j].path << std::endl << "\tsize: " << games[i].languagepacks[j].size << std::endl << std::endl; } } if (config.bDLC && !games[i].dlcs.empty()) { std::cout << "DLCs: " << std::endl; for (unsigned int j = 0; j < games[i].dlcs.size(); ++j) { if (!games[i].dlcs[j].serials.empty()) { std::cout << "\tDLC gamename: " << games[i].dlcs[j].gamename << std::endl << "\tserials:" << games[i].dlcs[j].serials << std::endl; } for (unsigned int k = 0; k < games[i].dlcs[j].installers.size(); ++k) { std::string filepath = games[i].dlcs[j].installers[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::cout << "\tgamename: " << games[i].dlcs[j].gamename << std::endl << "\tid: " << games[i].dlcs[j].installers[k].id << std::endl << "\tname: " << games[i].dlcs[j].installers[k].name << std::endl << "\tpath: " << games[i].dlcs[j].installers[k].path << std::endl << "\tsize: " << games[i].dlcs[j].installers[k].size << std::endl << "\tupdated: " << (games[i].dlcs[j].installers[k].updated ? "True" : "False") << std::endl << std::endl; } for (unsigned int k = 0; k < games[i].dlcs[j].patches.size(); ++k) { std::string filepath = games[i].dlcs[j].patches[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::cout << "\tgamename: " << games[i].dlcs[j].gamename << std::endl << "\tid: " << games[i].dlcs[j].patches[k].id << std::endl << "\tname: " << games[i].dlcs[j].patches[k].name << std::endl << "\tpath: " << games[i].dlcs[j].patches[k].path << std::endl << "\tsize: " << games[i].dlcs[j].patches[k].size << std::endl << std::endl; } for (unsigned int k = 0; k < games[i].dlcs[j].extras.size(); ++k) { std::string filepath = games[i].dlcs[j].extras[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::cout << "\tgamename: " << games[i].dlcs[j].gamename << std::endl << "\tid: " << games[i].dlcs[j].extras[k].id << std::endl << "\tname: " << games[i].dlcs[j].extras[k].name << std::endl << "\tpath: " << games[i].dlcs[j].extras[k].path << std::endl << "\tsize: " << games[i].dlcs[j].extras[k].size << std::endl << std::endl; } for (unsigned int k = 0; k < games[i].dlcs[j].languagepacks.size(); ++k) { std::string filepath = games[i].dlcs[j].languagepacks[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::cout << "\tgamename: " << games[i].dlcs[j].gamename << std::endl << "\tid: " << games[i].dlcs[j].languagepacks[k].id << std::endl << "\tname: " << games[i].dlcs[j].languagepacks[k].name << std::endl << "\tpath: " << games[i].dlcs[j].languagepacks[k].path << std::endl << "\tsize: " << games[i].dlcs[j].languagepacks[k].size << std::endl << std::endl; } } } } } else { // List game names if (gameItems.empty()) this->getGameList(); for (unsigned int i = 0; i < gameItems.size(); ++i) { std::string gamename = gameItems[i].name; if (gameItems[i].updates > 0) { gamename += " [" + std::to_string(gameItems[i].updates) + "]"; if (config.bColor) gamename = "\033[32m" + gamename + "\033[0m"; } std::cout << gamename << std::endl; for (unsigned int j = 0; j < gameItems[i].dlcnames.size(); ++j) std::cout << "+> " << gameItems[i].dlcnames[j] << std::endl; } } return 0; } void Downloader::repair() { if (this->games.empty()) this->getGameDetails(); for (unsigned int i = 0; i < games.size(); ++i) { // Installers (use remote or local file) if (config.bInstallers) { for (unsigned int j = 0; j < games[i].installers.size(); ++j) { std::string filepath = games[i].installers[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } // Get XML data std::string XML = ""; if (config.bRemoteXML) { XML = gogAPI->getXML(games[i].gamename, games[i].installers[j].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } } // Repair bool bUseLocalXML = !config.bRemoteXML; if (!XML.empty() || bUseLocalXML) { std::string url = gogAPI->getInstallerLink(games[i].gamename, games[i].installers[j].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, XML, games[i].gamename); std::cout << std::endl; } } } // Extras (GOG doesn't provide XML data for extras, use local file) if (config.bExtras) { for (unsigned int j = 0; j < games[i].extras.size(); ++j) { std::string filepath = games[i].extras[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::string url = gogAPI->getExtraLink(games[i].gamename, games[i].extras[j].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, std::string(), games[i].gamename); std::cout << std::endl; } } // Patches (use remote or local file) if (config.bPatches) { for (unsigned int j = 0; j < games[i].patches.size(); ++j) { std::string filepath = games[i].patches[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } // Get XML data std::string XML = ""; if (config.bRemoteXML) { XML = gogAPI->getXML(games[i].gamename, games[i].patches[j].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); } } std::string url = gogAPI->getPatchLink(games[i].gamename, games[i].patches[j].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, XML, games[i].gamename); std::cout << std::endl; } } // Language packs (GOG doesn't provide XML data for language packs, use local file) if (config.bLanguagePacks) { for (unsigned int j = 0; j < games[i].languagepacks.size(); ++j) { std::string filepath = games[i].languagepacks[j].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::string url = gogAPI->getLanguagePackLink(games[i].gamename, games[i].languagepacks[j].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, std::string(), games[i].gamename); std::cout << std::endl; } } if (config.bDLC && !games[i].dlcs.empty()) { for (unsigned int j = 0; j < games[i].dlcs.size(); ++j) { if (config.bInstallers) { for (unsigned int k = 0; k < games[i].dlcs[j].installers.size(); ++k) { std::string filepath = games[i].dlcs[j].installers[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } // Get XML data std::string XML = ""; if (config.bRemoteXML) { XML = gogAPI->getXML(games[i].dlcs[j].gamename, games[i].dlcs[j].installers[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } } // Repair bool bUseLocalXML = !config.bRemoteXML; if (!XML.empty() || bUseLocalXML) { std::string url = gogAPI->getInstallerLink(games[i].dlcs[j].gamename, games[i].dlcs[j].installers[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, XML, games[i].dlcs[j].gamename); std::cout << std::endl; } } } if (config.bPatches) { for (unsigned int k = 0; k < games[i].dlcs[j].patches.size(); ++k) { std::string filepath = games[i].dlcs[j].patches[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } // Get XML data std::string XML = ""; if (config.bRemoteXML) { XML = gogAPI->getXML(games[i].dlcs[j].gamename, games[i].dlcs[j].patches[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); } } std::string url = gogAPI->getPatchLink(games[i].dlcs[j].gamename, games[i].dlcs[j].patches[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, XML, games[i].dlcs[j].gamename); std::cout << std::endl; } } if (config.bExtras) { for (unsigned int k = 0; k < games[i].dlcs[j].extras.size(); ++k) { std::string filepath = games[i].dlcs[j].extras[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } std::string url = gogAPI->getExtraLink(games[i].dlcs[j].gamename, games[i].dlcs[j].extras[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, std::string(), games[i].dlcs[j].gamename); std::cout << std::endl; } } if (config.bLanguagePacks) { for (unsigned int k = 0; k < games[i].dlcs[j].languagepacks.size(); ++k) { std::string filepath = games[i].dlcs[j].languagepacks[k].getFilepath(); if (config.blacklist.isBlacklisted(filepath)) { if (config.bVerbose) std::cerr << "skipped blacklisted file " << filepath << std::endl; continue; } // Get XML data std::string XML = ""; if (config.bRemoteXML) { XML = gogAPI->getXML(games[i].dlcs[j].gamename, games[i].dlcs[j].languagepacks[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); } } std::string url = gogAPI->getLanguagePackLink(games[i].dlcs[j].gamename, games[i].dlcs[j].languagepacks[k].id); if (gogAPI->getError()) { std::cerr << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); continue; } std::cout << "Repairing file " << filepath << std::endl; this->repairFile(url, filepath, XML, games[i].dlcs[j].gamename); std::cout << std::endl; } } } } } } void Downloader::download() { if (this->games.empty()) this->getGameDetails(); if (config.bCover && !config.bUpdateCheck) coverXML = this->getResponse(config.sCoverList); for (unsigned int i = 0; i < games.size(); ++i) { if (config.bSaveSerials && !games[i].serials.empty()) { std::string filepath = games[i].getSerialsFilepath(); this->saveSerials(games[i].serials, filepath); } if (config.bSaveChangelogs && !games[i].changelog.empty()) { std::string filepath = games[i].getChangelogFilepath(); this->saveChangelog(games[i].changelog, filepath); } // Download covers if (config.bCover && !config.bUpdateCheck) { if (!games[i].installers.empty()) { // Take path from installer path because for some games the base directory for installer/extra path is not "gamename" boost::filesystem::path filepath = boost::filesystem::absolute(games[i].installers[0].getFilepath(), boost::filesystem::current_path()); // Get base directory from filepath std::string directory = filepath.parent_path().string(); this->downloadCovers(games[i].gamename, directory, coverXML); } } if (config.bInstallers) { for (unsigned int j = 0; j < games[i].installers.size(); ++j) { dlQueue.push(games[i].installers[j]); } } if (config.bPatches) { for (unsigned int j = 0; j < games[i].patches.size(); ++j) { dlQueue.push(games[i].patches[j]); } } if (config.bExtras) { for (unsigned int j = 0; j < games[i].extras.size(); ++j) { dlQueue.push(games[i].extras[j]); } } if (config.bLanguagePacks) { for (unsigned int j = 0; j < games[i].languagepacks.size(); ++j) { dlQueue.push(games[i].languagepacks[j]); } } if (config.bDLC && !games[i].dlcs.empty()) { for (unsigned int j = 0; j < games[i].dlcs.size(); ++j) { if (config.bSaveSerials && !games[i].dlcs[j].serials.empty()) { std::string filepath = games[i].dlcs[j].getSerialsFilepath(); this->saveSerials(games[i].dlcs[j].serials, filepath); } if (config.bSaveChangelogs && !games[i].dlcs[j].changelog.empty()) { std::string filepath = games[i].dlcs[j].getChangelogFilepath(); this->saveChangelog(games[i].dlcs[j].changelog, filepath); } if (config.bInstallers) { for (unsigned int k = 0; k < games[i].dlcs[j].installers.size(); ++k) { dlQueue.push(games[i].dlcs[j].installers[k]); } } if (config.bPatches) { for (unsigned int k = 0; k < games[i].dlcs[j].patches.size(); ++k) { dlQueue.push(games[i].dlcs[j].patches[k]); } } if (config.bExtras) { for (unsigned int k = 0; k < games[i].dlcs[j].extras.size(); ++k) { dlQueue.push(games[i].dlcs[j].extras[k]); } } if (config.bLanguagePacks) { for (unsigned int k = 0; k < games[i].dlcs[j].languagepacks.size(); ++k) { dlQueue.push(games[i].dlcs[j].languagepacks[k]); } } } } } if (!dlQueue.empty()) { // Limit thread count to number of items in download queue unsigned int iThreads = std::min(config.iThreads, static_cast(dlQueue.size())); // Create download threads std::vector vThreads; for (unsigned int i = 0; i < iThreads; ++i) { DownloadInfo dlInfo; dlInfo.setStatus(DLSTATUS_NOTSTARTED); vDownloadInfo.push_back(dlInfo); vThreads.push_back(std::thread(Downloader::processDownloadQueue, this->config, i)); } this->printProgress(); // Join threads for (unsigned int i = 0; i < vThreads.size(); ++i) vThreads[i].join(); vThreads.clear(); vDownloadInfo.clear(); } // Create xml data for all files in the queue if (!createXMLQueue.empty()) { std::cout << "Starting XML creation" << std::endl; gameFile gf; while (createXMLQueue.try_pop(gf)) { std::string xml_directory = config.sXMLDirectory + "/" + gf.gamename; Util::createXML(gf.getFilepath(), config.iChunkSize, xml_directory); } } } // Download a file, resume if possible CURLcode Downloader::downloadFile(const std::string& url, const std::string& filepath, const std::string& xml_data, const std::string& gamename) { CURLcode res = CURLE_RECV_ERROR; // assume network error bool bResume = false; FILE *outfile; off_t offset=0; // Get directory from filepath boost::filesystem::path pathname = filepath; pathname = boost::filesystem::absolute(pathname, boost::filesystem::current_path()); std::string directory = pathname.parent_path().string(); std::string filenameXML = pathname.filename().string() + ".xml"; std::string xml_directory; if (!gamename.empty()) xml_directory = config.sXMLDirectory + "/" + gamename; else xml_directory = config.sXMLDirectory; // Using local XML data for version check before resuming boost::filesystem::path local_xml_file; local_xml_file = xml_directory + "/" + filenameXML; bool bSameVersion = true; // assume same version bool bLocalXMLExists = boost::filesystem::exists(local_xml_file); // This is additional check to see if remote xml should be saved to speed up future version checks if (!xml_data.empty()) { std::string localHash = this->getLocalFileHash(filepath, gamename); // Do version check if local hash exists if (!localHash.empty()) { tinyxml2::XMLDocument remote_xml; remote_xml.Parse(xml_data.c_str()); tinyxml2::XMLElement *fileElemRemote = remote_xml.FirstChildElement("file"); if (fileElemRemote) { std::string remoteHash = fileElemRemote->Attribute("md5"); if (remoteHash != localHash) bSameVersion = false; } } } // Check that directory exists and create subdirectories boost::filesystem::path path = directory; if (boost::filesystem::exists(path)) { if (!boost::filesystem::is_directory(path)) { std::cerr << path << " is not directory" << std::endl; return res; } } else { if (!boost::filesystem::create_directories(path)) { std::cerr << "Failed to create directory: " << path << std::endl; return res; } } // Check if file exists if ((outfile=fopen(filepath.c_str(), "r"))!=NULL) { if (bSameVersion) { // File exists, resume if ((outfile = freopen(filepath.c_str(), "r+", outfile))!=NULL ) { bResume = true; fseek(outfile, 0, SEEK_END); // use ftello to support large files on 32 bit platforms offset = ftello(outfile); curl_easy_setopt(curlhandle, CURLOPT_RESUME_FROM_LARGE, offset); this->resume_position = offset; } else { std::cerr << "Failed to reopen " << filepath << std::endl; return res; } } else { // File exists but is not the same version fclose(outfile); std::cerr << "Remote file is different, renaming local file" << std::endl; std::string date_old = "." + bptime::to_iso_string(bptime::second_clock::local_time()) + ".old"; boost::filesystem::path new_name = filepath + date_old; // Rename old file by appending date and ".old" to filename boost::system::error_code ec; boost::filesystem::rename(pathname, new_name, ec); // Rename the file if (ec) { std::cerr << "Failed to rename " << filepath << " to " << new_name.string() << std::endl; std::cerr << "Skipping file" << std::endl; return res; } else { // Create new file if ((outfile=fopen(filepath.c_str(), "w"))!=NULL) { curl_easy_setopt(curlhandle, CURLOPT_RESUME_FROM, 0); // start downloading from the beginning of file this->resume_position = 0; } else { std::cerr << "Failed to create " << filepath << std::endl; return res; } } } } else { // File doesn't exist, create new file if ((outfile=fopen(filepath.c_str(), "w"))!=NULL) { curl_easy_setopt(curlhandle, CURLOPT_RESUME_FROM, 0); // start downloading from the beginning of file this->resume_position = 0; } else { std::cerr << "Failed to create " << filepath << std::endl; return res; } } // Save remote XML if (!xml_data.empty()) { if ((bLocalXMLExists && (!bSameVersion || config.bRepair)) || !bLocalXMLExists) { // Check that directory exists and create subdirectories boost::filesystem::path path = xml_directory; if (boost::filesystem::exists(path)) { if (!boost::filesystem::is_directory(path)) { std::cerr << path << " is not directory" << std::endl; } } else { if (!boost::filesystem::create_directories(path)) { std::cerr << "Failed to create directory: " << path << std::endl; } } std::ofstream ofs(local_xml_file.string().c_str()); if (ofs) { ofs << xml_data; ofs.close(); } else { std::cerr << "Can't create " << local_xml_file.string() << std::endl; } } } curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str()); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, outfile); res = this->beginDownload(); fclose(outfile); // Download failed and was not a resume attempt so delete the file if (res != CURLE_OK && res != CURLE_PARTIAL_FILE && !bResume && res != CURLE_OPERATION_TIMEDOUT) { boost::filesystem::path path = filepath; if (boost::filesystem::exists(path)) if (!boost::filesystem::remove(path)) std::cerr << "Failed to delete " << path << std::endl; } if (config.bReport) { std::string status = static_cast(curl_easy_strerror(res)); if (bResume && res == CURLE_RANGE_ERROR) // CURLE_RANGE_ERROR on resume attempts is not an error that user needs to know about status = "No error"; std::string report_line = "Downloaded [" + status + "] " + filepath; this->report_ofs << report_line << std::endl; } // Retry partially downloaded file // Retry if we aborted the transfer due to low speed limit if ((res == CURLE_PARTIAL_FILE || res == CURLE_OPERATION_TIMEDOUT) && (this->retries < config.iRetries) ) { this->retries++; std::cerr << std::endl << "Retry " << this->retries << "/" << config.iRetries; if (res == CURLE_PARTIAL_FILE) std::cerr << " (partial download)"; else if (res == CURLE_OPERATION_TIMEDOUT) std::cerr << " (timeout)"; std::cerr << std::endl; res = this->downloadFile(url, filepath, xml_data, gamename); } else { this->retries = 0; // Reset retries counter } return res; } // Repair file int Downloader::repairFile(const std::string& url, const std::string& filepath, const std::string& xml_data, const std::string& gamename) { int res = 0; FILE *outfile; off_t offset=0, from_offset, to_offset, filesize; std::string filehash; int chunks; std::vector chunk_from, chunk_to; std::vector chunk_hash; bool bParsingFailed = false; // Get filename boost::filesystem::path pathname = filepath; std::string filename = pathname.filename().string(); std::string xml_directory; if (!gamename.empty()) xml_directory = config.sXMLDirectory + "/" + gamename; else xml_directory = config.sXMLDirectory; std::string xml_file = xml_directory + "/" + filename + ".xml"; bool bFileExists = boost::filesystem::exists(pathname); bool bLocalXMLExists = boost::filesystem::exists(xml_file); tinyxml2::XMLDocument xml; if (!xml_data.empty()) // Parse remote XML data { std::cout << "XML: Using remote file" << std::endl; xml.Parse(xml_data.c_str()); } else { // Parse local XML data std::cout << "XML: Using local file" << std::endl; if (!bLocalXMLExists) std::cout << "XML: File doesn't exist (" << xml_file << ")" << std::endl; xml.LoadFile(xml_file.c_str()); } // Check if file node exists in XML data tinyxml2::XMLElement *fileElem = xml.FirstChildElement("file"); if (!fileElem) { // File node doesn't exist std::cout << "XML: Parsing failed / not valid XML" << std::endl; if (config.bDownload) bParsingFailed = true; else return res; } else { // File node exists --> valid XML std::cout << "XML: Valid XML" << std::endl; filename = fileElem->Attribute("name"); filehash = fileElem->Attribute("md5"); std::stringstream(fileElem->Attribute("chunks")) >> chunks; std::stringstream(fileElem->Attribute("total_size")) >> filesize; //Iterate through all chunk nodes tinyxml2::XMLElement *chunkElem = fileElem->FirstChildElement("chunk"); while (chunkElem) { std::stringstream(chunkElem->Attribute("from")) >> from_offset; std::stringstream(chunkElem->Attribute("to")) >> to_offset; chunk_from.push_back(from_offset); chunk_to.push_back(to_offset); chunk_hash.push_back(chunkElem->GetText()); chunkElem = chunkElem->NextSiblingElement("chunk"); } std::cout << "XML: Parsing finished" << std::endl << std::endl << filename << std::endl << "\tMD5:\t" << filehash << std::endl << "\tChunks:\t" << chunks << std::endl << "\tSize:\t" << filesize << " bytes" << std::endl << std::endl; } // No local XML file and parsing failed. if (bParsingFailed && !bLocalXMLExists) { if (this->config.bDownload) { std::cout << "Downloading: " << filepath << std::endl; CURLcode result = this->downloadFile(url, filepath, xml_data, gamename); std::cout << std::endl; if ( (!bFileExists && result == CURLE_OK) || /* File doesn't exist so only accept if everything was OK */ (bFileExists && (result == CURLE_OK || result == CURLE_RANGE_ERROR )) /* File exists so accept also CURLE_RANGE_ERROR because curl will return CURLE_RANGE_ERROR */ ) /* if the file is already fully downloaded and we want to resume it */ { bLocalXMLExists = boost::filesystem::exists(xml_file); // Check to see if downloadFile saved XML data if (config.bAutomaticXMLCreation && !bLocalXMLExists) { std::cout << "Starting automatic XML creation" << std::endl; Util::createXML(filepath, config.iChunkSize, xml_directory); } res = 1; } } else { std::cout << "Can't repair file." << std::endl; } return res; } // Check if file exists if (bFileExists) { // File exists if ((outfile = fopen(filepath.c_str(), "r+"))!=NULL ) { fseek(outfile, 0, SEEK_END); // use ftello to support large files on 32 bit platforms offset = ftello(outfile); } else { std::cout << "Failed to open " << filepath << std::endl; return res; } } else { std::cout << "File doesn't exist " << filepath << std::endl; if (this->config.bDownload) { std::cout << "Downloading: " << filepath << std::endl; CURLcode result = this->downloadFile(url, filepath, xml_data, gamename); std::cout << std::endl; if (result == CURLE_OK) { if (config.bAutomaticXMLCreation && bParsingFailed) { std::cout << "Starting automatic XML creation" << std::endl; Util::createXML(filepath, config.iChunkSize, xml_directory); } res = 1; } } return res; } // check if file sizes match if (offset != filesize) { std::cout << "Filesizes don't match" << std::endl << "Incomplete download or different version" << std::endl; fclose(outfile); if (this->config.bDownload) { std::cout << "Redownloading file" << std::endl; std::string date_old = "." + bptime::to_iso_string(bptime::second_clock::local_time()) + ".old"; boost::filesystem::path new_name = filepath + date_old; // Rename old file by appending date and ".old" to filename std::cout << "Renaming old file to " << new_name.string() << std::endl; boost::system::error_code ec; boost::filesystem::rename(pathname, new_name, ec); // Rename the file if (ec) { std::cout << "Failed to rename " << filepath << " to " << new_name.string() << std::endl; std::cout << "Skipping file" << std::endl; res = 0; } else { if (bLocalXMLExists) { std::cout << "Deleting old XML data" << std::endl; boost::filesystem::remove(xml_file, ec); // Delete old XML data if (ec) { std::cout << "Failed to delete " << xml_file << std::endl; } } CURLcode result = this->downloadFile(url, filepath, xml_data, gamename); std::cout << std::endl; if (result == CURLE_OK) { bLocalXMLExists = boost::filesystem::exists(xml_file); // Check to see if downloadFile saved XML data if (!bLocalXMLExists) { std::cout << "Starting automatic XML creation" << std::endl; Util::createXML(filepath, config.iChunkSize, xml_directory); } res = 1; } else { res = 0; } } } return res; } // Check all chunks int iChunksRepaired = 0; for (int i=0; ibeginDownload(); //begin chunk download std::cout << std::endl; if (config.bReport) iChunksRepaired++; i--; //verify downloaded chunk } else { std::cout << "OK\r" << std::flush; } free(chunk); res = 1; } std::cout << std::endl; fclose(outfile); if (config.bReport) { std::string report_line = "Repaired [" + std::to_string(iChunksRepaired) + "/" + std::to_string(chunks) + "] " + filepath; this->report_ofs << report_line << std::endl; } return res; } // Download cover images int Downloader::downloadCovers(const std::string& gamename, const std::string& directory, const std::string& cover_xml_data) { int res = 0; tinyxml2::XMLDocument xml; // Check that directory exists and create subdirectories boost::filesystem::path path = directory; if (boost::filesystem::exists(path)) { if (!boost::filesystem::is_directory(path)) { std::cout << path << " is not directory" << std::endl; return res; } } else { if (!boost::filesystem::create_directories(path)) { std::cout << "Failed to create directory: " << path << std::endl; return res; } } xml.Parse(cover_xml_data.c_str()); tinyxml2::XMLElement *rootNode = xml.RootElement(); if (!rootNode) { std::cout << "Not valid XML" << std::endl; return res; } else { tinyxml2::XMLNode *gameNode = rootNode->FirstChild(); while (gameNode) { tinyxml2::XMLElement *gameElem = gameNode->ToElement(); std::string game_name = gameElem->Attribute("name"); if (game_name == gamename) { boost::match_results what; tinyxml2::XMLNode *coverNode = gameNode->FirstChild(); while (coverNode) { tinyxml2::XMLElement *coverElem = coverNode->ToElement(); std::string cover_url = coverElem->GetText(); // Get file extension for the image boost::regex e1(".*(\\.\\w+)$", boost::regex::perl | boost::regex::icase); boost::regex_search(cover_url, what, e1); std::string file_extension = what[1]; std::string cover_name = std::string("cover_") + coverElem->Attribute("id") + file_extension; std::string filepath = directory + "/" + cover_name; std::cout << "Downloading cover " << filepath << std::endl; CURLcode result = this->downloadFile(cover_url, filepath); std::cout << std::endl; if (result == CURLE_OK) res = 1; else res = 0; if (result == CURLE_HTTP_RETURNED_ERROR) { long int response_code = 0; result = curl_easy_getinfo(curlhandle, CURLINFO_RESPONSE_CODE, &response_code); std::cout << "HTTP ERROR: "; if (result == CURLE_OK) std::cout << response_code << " (" << cover_url << ")" << std::endl; else std::cout << "failed to get error code: " << curl_easy_strerror(result) << " (" << cover_url << ")" << std::endl; } coverNode = coverNode->NextSibling(); } break; // Found cover for game, no need to go through rest of the game nodes } gameNode = gameNode->NextSibling(); } } return res; } CURLcode Downloader::beginDownload() { this->TimeAndSize.clear(); this->timer.reset(); CURLcode result = curl_easy_perform(curlhandle); this->resume_position = 0; return result; } std::string Downloader::getResponse(const std::string& url) { std::ostringstream memory; std::string response; curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str()); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Downloader::writeMemoryCallback); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &memory); CURLcode result; do { if (config.iWait > 0) usleep(config.iWait); // Delay the request by specified time result = curl_easy_perform(curlhandle); response = memory.str(); memory.str(std::string()); } while ((result != CURLE_OK) && response.empty() && (this->retries++ < config.iRetries)); this->retries = 0; // reset retries counter curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Downloader::writeData); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 0); if (result != CURLE_OK) { std::cout << curl_easy_strerror(result) << std::endl; if (result == CURLE_HTTP_RETURNED_ERROR) { long int response_code = 0; result = curl_easy_getinfo(curlhandle, CURLINFO_RESPONSE_CODE, &response_code); std::cout << "HTTP ERROR: "; if (result == CURLE_OK) std::cout << response_code << " (" << url << ")" << std::endl; else std::cout << "failed to get error code: " << curl_easy_strerror(result) << " (" << url << ")" << std::endl; } } return response; } int Downloader::progressCallback(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) { // unused so lets prevent warnings and be more pedantic (void) ulnow; (void) ultotal; // on entry: dltotal - how much remains to download till the end of the file (bytes) // dlnow - how much was downloaded from the start of the program (bytes) int bar_length = 26; int min_bar_length = 5; Downloader* downloader = static_cast(clientp); double rate; // average download speed in B/s // trying to get rate and setting to NaN if it fails if (CURLE_OK != curl_easy_getinfo(downloader->curlhandle, CURLINFO_SPEED_DOWNLOAD, &rate)) rate = std::numeric_limits::quiet_NaN(); // (Shmerl): this flag is needed to catch the case before anything was downloaded on resume, // and there is no way to calculate the fraction, so we set to 0 (otherwise it'd be 1). // This is to prevent the progress bar from jumping to 100% and then to lower value. // It's visually better to jump from 0% to higher one. bool starting = ((0 == dlnow) && (0 == dltotal)); // (Shmerl): DEBUG: strange thing - when resuming a file which is already downloaded, dlnow is correctly 0.0 // but dltotal is 389.0! This messes things up in the progress bar not showing the very last bar as full. // enable this debug line to test the problem: // // printf("\r\033[0K dlnow: %0.2f, dltotal: %0.2f\r", dlnow, dltotal); fflush(stdout); return 0; // // For now making a quirky workaround and setting dltotal to 0.0 in that case. // It's probably better to find a real fix. if ((0 == dlnow) && (389 == dltotal)) dltotal = 0; // setting full dlwnow and dltotal curl_off_t offset = static_cast(downloader->getResumePosition()); if (offset>0) { dlnow += offset; dltotal += offset; } // Update progress bar every 100ms if (downloader->timer.getTimeBetweenUpdates()>=100 || dlnow == dltotal) { downloader->timer.reset(); int iTermWidth = Util::getTerminalWidth(); // 10 second average download speed // Don't use static value of 10 seconds because update interval depends on when and how often progress callback is called downloader->TimeAndSize.push_back(std::make_pair(time(NULL), static_cast(dlnow))); if (downloader->TimeAndSize.size() > 100) // 100 * 100ms = 10s { downloader->TimeAndSize.pop_front(); time_t time_first = downloader->TimeAndSize.front().first; uintmax_t size_first = downloader->TimeAndSize.front().second; time_t time_last = downloader->TimeAndSize.back().first; uintmax_t size_last = downloader->TimeAndSize.back().second; rate = (size_last - size_first) / static_cast((time_last - time_first)); } bptime::time_duration eta(bptime::seconds((long)((dltotal - dlnow) / rate))); std::stringstream eta_ss; if (eta.hours() > 23) { eta_ss << eta.hours() / 24 << "d " << std::setfill('0') << std::setw(2) << eta.hours() % 24 << "h " << std::setfill('0') << std::setw(2) << eta.minutes() << "m " << std::setfill('0') << std::setw(2) << eta.seconds() << "s"; } else if (eta.hours() > 0) { eta_ss << eta.hours() << "h " << std::setfill('0') << std::setw(2) << eta.minutes() << "m " << std::setfill('0') << std::setw(2) << eta.seconds() << "s"; } else if (eta.minutes() > 0) { eta_ss << eta.minutes() << "m " << std::setfill('0') << std::setw(2) << eta.seconds() << "s"; } else { eta_ss << eta.seconds() << "s"; } // Create progressbar double fraction = starting ? 0.0 : static_cast(dlnow) / static_cast(dltotal); std::cout << Util::formattedString("\033[0K\r%3.0f%% ", fraction * 100); // Download rate unit conversion std::string rate_unit; if (rate > 1048576) // 1 MB { rate /= 1048576; rate_unit = "MB/s"; } else { rate /= 1024; rate_unit = "kB/s"; } std::string status_text = Util::formattedString(" %0.2f/%0.2fMB @ %0.2f%s ETA: %s\r", static_cast(dlnow)/1024/1024, static_cast(dltotal)/1024/1024, rate, rate_unit.c_str(), eta_ss.str().c_str()); int status_text_length = status_text.length() + 6; if ((status_text_length + bar_length) > iTermWidth) bar_length -= (status_text_length + bar_length) - iTermWidth; // Don't draw progressbar if length is less than min_bar_length if (bar_length >= min_bar_length) downloader->progressbar->draw(bar_length, fraction); std::cout << status_text << std::flush; } return 0; } size_t Downloader::writeMemoryCallback(char *ptr, size_t size, size_t nmemb, void *userp) { std::ostringstream *stream = (std::ostringstream*)userp; size_t count = size * nmemb; stream->write(ptr, count); return count; } size_t Downloader::writeData(void *ptr, size_t size, size_t nmemb, FILE *stream) { return fwrite(ptr, size, nmemb, stream); } size_t Downloader::readData(void *ptr, size_t size, size_t nmemb, FILE *stream) { return fread(ptr, size, nmemb, stream); } uintmax_t Downloader::getResumePosition() { return this->resume_position; } std::vector Downloader::getExtrasFromJSON(const Json::Value& json, const std::string& gamename, const Config& config) { std::vector extras; // Create new API handle and set curl options for the API API* api = new API(config.sToken, config.sSecret); api->curlSetOpt(CURLOPT_VERBOSE, config.bVerbose); api->curlSetOpt(CURLOPT_SSL_VERIFYPEER, config.bVerifyPeer); api->curlSetOpt(CURLOPT_CONNECTTIMEOUT, config.iTimeout); if (!config.sCACertPath.empty()) api->curlSetOpt(CURLOPT_CAINFO, config.sCACertPath.c_str()); if (!api->init()) { delete api; return extras; } for (unsigned int i = 0; i < json["extras"].size(); ++i) { std::string id, name, path, downloaderUrl; name = json["extras"][i]["name"].asString(); downloaderUrl = json["extras"][i]["downloaderUrl"].asString(); id.assign(downloaderUrl.begin()+downloaderUrl.find_last_of("/")+1, downloaderUrl.end()); // Get path from download link std::string url = api->getExtraLink(gamename, id); if (api->getError()) { api->clearError(); continue; } url = htmlcxx::Uri::decode(url); if (url.find("/extras/") != std::string::npos) { path.assign(url.begin()+url.find("/extras/"), url.begin()+url.find_first_of("?")); path = "/" + gamename + path; } else { path.assign(url.begin()+url.find_last_of("/")+1, url.begin()+url.find_first_of("?")); path = "/" + gamename + "/extras/" + path; } // Get filename std::string filename; filename.assign(path.begin()+path.find_last_of("/")+1,path.end()); // Use filename if name was not specified if (name.empty()) name = filename; if (name.empty()) { #ifdef DEBUG std::cerr << "DEBUG INFO (getExtrasFromJSON)" << std::endl; std::cerr << "Skipped file without a name (game: " << gamename << ", fileid: " << id << ")" << std::endl; #endif continue; } if (filename.empty()) { #ifdef DEBUG std::cerr << "DEBUG INFO (getExtrasFromJSON)" << std::endl; std::cerr << "Skipped file without a filename (game: " << gamename << ", fileid: " << id << ", name: " << name << ")" << std::endl; #endif continue; } gameFile gf; gf.type = GFTYPE_EXTRA; gf.gamename = gamename; gf.updated = false; gf.id = id; gf.name = name; gf.path = path; extras.push_back(gf); } delete api; return extras; } std::string Downloader::getSerialsFromJSON(const Json::Value& json) { std::ostringstream serials; if (!json.isMember("cdKey")) return std::string(); std::string cdkey = json["cdKey"].asString(); if (cdkey.empty()) return std::string(); if (cdkey.find("") == std::string::npos) { serials << cdkey << std::endl; } else { htmlcxx::HTML::ParserDom parser; tree dom = parser.parseTree(cdkey); tree::iterator it = dom.begin(); tree::iterator end = dom.end(); for (; it != end; ++it) { std::string tag_text; if (it->tagName() == "span") { for (unsigned int j = 0; j < dom.number_of_children(it); ++j) { tree::iterator span_it = dom.child(it, j); if (!span_it->isTag() && !span_it->isComment()) tag_text = span_it->text(); } } if (!tag_text.empty()) { boost::regex expression("^\\h+|\\h+$"); std::string text = boost::regex_replace(tag_text, expression, ""); if (!text.empty()) serials << text << std::endl; } } } return serials.str(); } std::string Downloader::getChangelogFromJSON(const Json::Value& json) { std::string changelog; std::string title = "Changelog"; if (!json.isMember("changelog")) return std::string(); changelog = json["changelog"].asString(); if (changelog.empty()) return std::string(); if (json.isMember("title")) title = title + ": " + json["title"].asString(); changelog = "\n\n\n\n" + title + "\n\n" + changelog + "\n"; return changelog; } // Linear search. Good thing computers are fast and lists are small. static int isPresent(std::vector& list, const boost::filesystem::path& path, Blacklist& blacklist) { if(blacklist.isBlacklisted(path.native())) return false; for (unsigned int k = 0; k < list.size(); ++k) if (list[k].getFilepath() == path.native()) return true; return false; } void Downloader::checkOrphans() { // Always check everything when checking for orphaned files config.bInstallers = true; config.bExtras = true; config.bPatches = true; config.bLanguagePacks = true; if (this->games.empty()) this->getGameDetails(); std::vector orphans; for (unsigned int i = 0; i < games.size(); ++i) { std::cerr << "Checking for orphaned files " << i+1 << " / " << games.size() << "\r" << std::flush; std::vector filepath_vector; try { std::vector paths; std::vector platformIds; platformIds.push_back(0); for (unsigned int j = 0; j < GlobalConstants::PLATFORMS.size(); ++j) { platformIds.push_back(GlobalConstants::PLATFORMS[j].id); } for (unsigned int j = 0; j < platformIds.size(); ++j) { std::string directory = config.sDirectory + "/" + config.sGameSubdir + "/"; Util::filepathReplaceReservedStrings(directory, games[i].gamename, platformIds[j]); boost::filesystem::path path (directory); if (boost::filesystem::exists(path)) { bool bDuplicate = false; for (unsigned int k = 0; k < paths.size(); ++k) { if (path == paths[k]) { bDuplicate = true; break; } } if (!bDuplicate) paths.push_back(path); } } for (unsigned int j = 0; j < paths.size(); ++j) { std::size_t pathlen = config.sDirectory.length(); if (boost::filesystem::exists(paths[j])) { if (boost::filesystem::is_directory(paths[j])) { // Recursively iterate over files in directory boost::filesystem::recursive_directory_iterator end_iter; boost::filesystem::recursive_directory_iterator dir_iter(paths[j]); while (dir_iter != end_iter) { if (boost::filesystem::is_regular_file(dir_iter->status())) { std::string filepath = dir_iter->path().string(); if (config.ignorelist.isBlacklisted(filepath.substr(pathlen))) { if (config.bVerbose) std::cerr << "skipped ignorelisted file " << filepath << std::endl; } else { boost::regex expression(config.sOrphanRegex); // Limit to files matching the regex boost::match_results what; if (boost::regex_search(filepath, what, expression)) filepath_vector.push_back(dir_iter->path()); } } dir_iter++; } } } else std::cerr << paths[j] << " does not exist" << std::endl; } } catch (const boost::filesystem::filesystem_error& ex) { std::cout << ex.what() << std::endl; } if (!filepath_vector.empty()) { for (unsigned int j = 0; j < filepath_vector.size(); ++j) { bool bFoundFile = isPresent(games[i].installers, filepath_vector[j], config.blacklist) || isPresent(games[i].extras, filepath_vector[j], config.blacklist) || isPresent(games[i].patches, filepath_vector[j], config.blacklist) || isPresent(games[i].languagepacks, filepath_vector[j], config.blacklist); if (!bFoundFile) { // Check dlcs for (unsigned int k = 0; k < games[i].dlcs.size(); ++k) { bFoundFile = isPresent(games[i].dlcs[k].installers, filepath_vector[j], config.blacklist) || isPresent(games[i].dlcs[k].extras, filepath_vector[j], config.blacklist) || isPresent(games[i].dlcs[k].patches, filepath_vector[j], config.blacklist) || isPresent(games[i].dlcs[k].languagepacks, filepath_vector[j], config.blacklist); if(bFoundFile) break; } } if (!bFoundFile) orphans.push_back(filepath_vector[j].string()); } } } std::cout << std::endl; if (!orphans.empty()) { for (unsigned int i = 0; i < orphans.size(); ++i) { std::cout << orphans[i] << std::endl; } } else { std::cout << "No orphaned files" << std::endl; } return; } // Check status of files void Downloader::checkStatus() { if (this->games.empty()) this->getGameDetails(); // Create a vector containing all game files std::vector vGameFiles; for (unsigned int i = 0; i < games.size(); ++i) { std::vector vec = games[i].getGameFileVector(); vGameFiles.insert(std::end(vGameFiles), std::begin(vec), std::end(vec)); } for (unsigned int i = 0; i < vGameFiles.size(); ++i) { unsigned int type = vGameFiles[i].type; if (!config.bDLC && (type & GFTYPE_DLC)) continue; if (!config.bInstallers && (type & GFTYPE_INSTALLER)) continue; if (!config.bExtras && (type & GFTYPE_EXTRA)) continue; if (!config.bPatches && (type & GFTYPE_PATCH)) continue; if (!config.bLanguagePacks && (type & GFTYPE_LANGPACK)) continue; boost::filesystem::path filepath = vGameFiles[i].getFilepath(); if (config.blacklist.isBlacklisted(filepath.native())) continue; std::string gamename = vGameFiles[i].gamename; std::string id = vGameFiles[i].id; if (boost::filesystem::exists(filepath) && boost::filesystem::is_regular_file(filepath)) { std::string remoteHash; bool bHashOK = true; // assume hash OK uintmax_t filesize = boost::filesystem::file_size(filepath); // GOG only provides xml data for installers, patches and language packs if (type & (GFTYPE_INSTALLER | GFTYPE_PATCH | GFTYPE_LANGPACK)) remoteHash = this->getRemoteFileHash(gamename, id); std::string localHash = this->getLocalFileHash(filepath.string(), gamename); if (!remoteHash.empty()) { if (remoteHash != localHash) bHashOK = false; else { // Check for incomplete file by comparing the filesizes // Remote hash was saved but download was incomplete and therefore getLocalFileHash returned the same as getRemoteFileHash uintmax_t filesize_xml = 0; boost::filesystem::path path = filepath; boost::filesystem::path local_xml_file; if (!gamename.empty()) local_xml_file = config.sXMLDirectory + "/" + gamename + "/" + path.filename().string() + ".xml"; else local_xml_file = config.sXMLDirectory + "/" + path.filename().string() + ".xml"; if (boost::filesystem::exists(local_xml_file)) { tinyxml2::XMLDocument local_xml; local_xml.LoadFile(local_xml_file.string().c_str()); tinyxml2::XMLElement *fileElemLocal = local_xml.FirstChildElement("file"); if (fileElemLocal) { std::string filesize_xml_str = fileElemLocal->Attribute("total_size"); filesize_xml = std::stoull(filesize_xml_str); } } if (filesize_xml > 0 && filesize_xml != filesize) { localHash = Util::getFileHash(path.string(), RHASH_MD5); std::cout << "FS " << gamename << " " << filepath.filename().string() << " " << filesize << " " << localHash << std::endl; continue; } } } std::cout << (bHashOK ? "OK " : "MD5 ") << gamename << " " << filepath.filename().string() << " " << filesize << " " << localHash << std::endl; } else { std::cout << "ND " << gamename << " " << filepath.filename().string() << std::endl; } } return; } std::string Downloader::getLocalFileHash(const std::string& filepath, const std::string& gamename) { std::string localHash; boost::filesystem::path path = filepath; boost::filesystem::path local_xml_file; if (!gamename.empty()) local_xml_file = config.sXMLDirectory + "/" + gamename + "/" + path.filename().string() + ".xml"; else local_xml_file = config.sXMLDirectory + "/" + path.filename().string() + ".xml"; if (config.bAutomaticXMLCreation && !boost::filesystem::exists(local_xml_file) && boost::filesystem::exists(path)) { std::string xml_directory = config.sXMLDirectory + "/" + gamename; Util::createXML(filepath, config.iChunkSize, xml_directory); } localHash = Util::getLocalFileHash(config.sXMLDirectory, filepath, gamename); return localHash; } std::string Downloader::getRemoteFileHash(const std::string& gamename, const std::string& id) { std::string remoteHash; std::string xml_data = gogAPI->getXML(gamename, id); if (gogAPI->getError()) { std::cout << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); } if (!xml_data.empty()) { tinyxml2::XMLDocument remote_xml; remote_xml.Parse(xml_data.c_str()); tinyxml2::XMLElement *fileElemRemote = remote_xml.FirstChildElement("file"); if (fileElemRemote) { remoteHash = fileElemRemote->Attribute("md5"); } } return remoteHash; } /* Load game details from cache file returns 0 if successful returns 1 if cache file doesn't exist returns 2 if JSON parsing failed returns 3 if cache is too old returns 4 if JSON doesn't contain "games" node returns 5 if cache version doesn't match */ int Downloader::loadGameDetailsCache() { int res = 0; std::string cachepath = config.sCacheDirectory + "/gamedetails.json"; // Make sure file exists boost::filesystem::path path = cachepath; if (!boost::filesystem::exists(path)) { return res = 1; } bptime::ptime now = bptime::second_clock::local_time(); bptime::ptime cachedate; std::ifstream json(cachepath, std::ifstream::binary); Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { if (root.isMember("date")) { cachedate = bptime::from_iso_string(root["date"].asString()); if ((now - cachedate) > bptime::minutes(config.iCacheValid)) { // cache is too old delete jsonparser; json.close(); return res = 3; } } int iCacheVersion = 0; if (root.isMember("gamedetails-cache-version")) iCacheVersion = root["gamedetails-cache-version"].asInt(); if (iCacheVersion != GlobalConstants::GAMEDETAILS_CACHE_VERSION) { res = 5; } else { if (root.isMember("games")) { this->games = getGameDetailsFromJsonNode(root["games"]); res = 0; } else { res = 4; } } } else { res = 2; std::cout << "Failed to parse cache" << std::endl; std::cout << jsonparser->getFormattedErrorMessages() << std::endl; } delete jsonparser; if (json) json.close(); return res; } /* Save game details to cache file returns 0 if successful returns 1 if fails */ int Downloader::saveGameDetailsCache() { int res = 0; // Don't try to save cache if we don't have any game details if (this->games.empty()) { return 1; } std::string cachepath = config.sCacheDirectory + "/gamedetails.json"; Json::Value json; json["gamedetails-cache-version"] = GlobalConstants::GAMEDETAILS_CACHE_VERSION; json["version-string"] = config.sVersionString; json["version-number"] = config.sVersionNumber; json["date"] = bptime::to_iso_string(bptime::second_clock::local_time()); for (unsigned int i = 0; i < this->games.size(); ++i) json["games"].append(this->games[i].getDetailsAsJson()); std::ofstream ofs(cachepath); if (!ofs) { res = 1; } else { Json::StyledStreamWriter jsonwriter; jsonwriter.write(ofs, json); ofs.close(); } return res; } std::vector Downloader::getGameDetailsFromJsonNode(Json::Value root, const int& recursion_level) { std::vector details; // If root node is not array and we use root.size() it will return the number of nodes --> limit to 1 "array" node to make sure it is handled properly for (unsigned int i = 0; i < (root.isArray() ? root.size() : 1); ++i) { Json::Value gameDetailsNode = (root.isArray() ? root[i] : root); // This json node can be array or non-array so take that into account gameDetails game; game.gamename = gameDetailsNode["gamename"].asString(); // DLCs are handled as part of the game so make sure that filtering is done with base game name if (recursion_level == 0) // recursion level is 0 when handling base game { boost::regex expression(config.sGameRegex); boost::match_results what; if (!boost::regex_search(game.gamename, what, expression)) // Check if name matches the specified regex continue; } game.title = gameDetailsNode["title"].asString(); game.icon = gameDetailsNode["icon"].asString(); game.serials = gameDetailsNode["serials"].asString(); game.changelog = gameDetailsNode["changelog"].asString(); // Make a vector of valid node names to make things easier std::vector nodes; nodes.push_back("extras"); nodes.push_back("installers"); nodes.push_back("patches"); nodes.push_back("languagepacks"); nodes.push_back("dlcs"); gameSpecificConfig conf; conf.bDLC = config.bDLC; conf.iInstallerLanguage = config.iInstallerLanguage; conf.iInstallerPlatform = config.iInstallerPlatform; conf.vLanguagePriority = config.vLanguagePriority; conf.vPlatformPriority = config.vPlatformPriority; if (Util::getGameSpecificConfig(game.gamename, &conf) > 0) std::cerr << game.gamename << " - Language: " << conf.iInstallerLanguage << ", Platform: " << conf.iInstallerPlatform << ", DLC: " << (conf.bDLC ? "true" : "false") << std::endl; for (unsigned int j = 0; j < nodes.size(); ++j) { std::string nodeName = nodes[j]; if (gameDetailsNode.isMember(nodeName)) { Json::Value fileDetailsNodeVector = gameDetailsNode[nodeName]; for (unsigned int index = 0; index < fileDetailsNodeVector.size(); ++index) { Json::Value fileDetailsNode = fileDetailsNodeVector[index]; gameFile fileDetails; if (nodeName != "dlcs") { fileDetails.updated = fileDetailsNode["updated"].asInt(); fileDetails.id = fileDetailsNode["id"].asString(); fileDetails.name = fileDetailsNode["name"].asString(); fileDetails.path = fileDetailsNode["path"].asString(); fileDetails.size = fileDetailsNode["size"].asString(); fileDetails.platform = fileDetailsNode["platform"].asUInt(); fileDetails.language = fileDetailsNode["language"].asUInt(); fileDetails.silent = fileDetailsNode["silent"].asInt(); fileDetails.gamename = fileDetailsNode["gamename"].asString(); fileDetails.type = fileDetailsNode["type"].asUInt(); if (nodeName != "extras" && !(fileDetails.platform & conf.iInstallerPlatform)) continue; if (nodeName != "extras" && !(fileDetails.language & conf.iInstallerLanguage)) continue; } if (nodeName == "extras" && config.bExtras) game.extras.push_back(fileDetails); else if (nodeName == "installers" && config.bInstallers) game.installers.push_back(fileDetails); else if (nodeName == "patches" && config.bPatches) game.patches.push_back(fileDetails); else if (nodeName == "languagepacks" && config.bLanguagePacks) game.languagepacks.push_back(fileDetails); else if (nodeName == "dlcs" && conf.bDLC) { std::vector dlcs = this->getGameDetailsFromJsonNode(fileDetailsNode, recursion_level + 1); game.dlcs.insert(game.dlcs.end(), dlcs.begin(), dlcs.end()); } } } } if (!game.extras.empty() || !game.installers.empty() || !game.patches.empty() || !game.languagepacks.empty() || !game.dlcs.empty()) { game.filterWithPriorities(conf); details.push_back(game); } } return details; } void Downloader::updateCache() { // Make sure that all details get cached config.bExtras = true; config.bInstallers = true; config.bPatches = true; config.bLanguagePacks = true; config.bDLC = true; config.sGameRegex = ".*"; config.iInstallerLanguage = Util::getOptionValue("all", GlobalConstants::LANGUAGES); config.iInstallerPlatform = Util::getOptionValue("all", GlobalConstants::PLATFORMS); config.vLanguagePriority.clear(); config.vPlatformPriority.clear(); config.sIgnoreDLCCountRegex = ".*"; // Ignore DLC count for all games because GOG doesn't report DLC count correctly gogWebsite->setConfig(config); // Make sure that website handle has updated config this->getGameList(); this->getGameDetails(); if (this->saveGameDetailsCache()) std::cout << "Failed to save cache" << std::endl; return; } // Save serials to file void Downloader::saveSerials(const std::string& serials, const std::string& filepath) { bool bFileExists = boost::filesystem::exists(filepath); if (bFileExists) return; // Get directory from filepath boost::filesystem::path pathname = filepath; std::string directory = pathname.parent_path().string(); // Check that directory exists and create subdirectories boost::filesystem::path path = directory; if (boost::filesystem::exists(path)) { if (!boost::filesystem::is_directory(path)) { std::cout << path << " is not directory" << std::endl; return; } } else { if (!boost::filesystem::create_directories(path)) { std::cout << "Failed to create directory: " << path << std::endl; return; } } std::ofstream ofs(filepath); if (ofs) { std::cout << "Saving serials: " << filepath << std::endl; ofs << serials; ofs.close(); } else { std::cout << "Failed to create file: " << filepath << std::endl; } return; } // Save changelog to file void Downloader::saveChangelog(const std::string& changelog, const std::string& filepath) { // Get directory from filepath boost::filesystem::path pathname = filepath; std::string directory = pathname.parent_path().string(); // Check that directory exists and create subdirectories boost::filesystem::path path = directory; if (boost::filesystem::exists(path)) { if (!boost::filesystem::is_directory(path)) { std::cout << path << " is not directory" << std::endl; return; } } else { if (!boost::filesystem::create_directories(path)) { std::cout << "Failed to create directory: " << path << std::endl; return; } } std::ofstream ofs(filepath); if (ofs) { std::cout << "Saving changelog: " << filepath << std::endl; ofs << changelog; ofs.close(); } else { std::cout << "Failed to create file: " << filepath << std::endl; } return; } int Downloader::downloadFileWithId(const std::string& fileid_string, const std::string& output_filepath) { int res = 1; size_t pos = fileid_string.find("/"); if (pos == std::string::npos) { std::cout << "Invalid file id " << fileid_string << ": could not find separator \"/\"" << std::endl; } else if (!output_filepath.empty() && boost::filesystem::is_directory(output_filepath)) { std::cout << "Failed to create the file " << output_filepath << ": Is a directory" << std::endl; } else { std::string gamename, fileid, url; gamename.assign(fileid_string.begin(), fileid_string.begin()+pos); fileid.assign(fileid_string.begin()+pos+1, fileid_string.end()); if (fileid.find("installer") != std::string::npos) url = gogAPI->getInstallerLink(gamename, fileid); else if (fileid.find("patch") != std::string::npos) url = gogAPI->getPatchLink(gamename, fileid); else if (fileid.find("langpack") != std::string::npos) url = gogAPI->getLanguagePackLink(gamename, fileid); else url = gogAPI->getExtraLink(gamename, fileid); if (!gogAPI->getError()) { std::string filename, filepath; filename.assign(url.begin()+url.find_last_of("/")+1, url.begin()+url.find_first_of("?")); if (output_filepath.empty()) filepath = Util::makeFilepath(config.sDirectory, filename, gamename); else filepath = output_filepath; std::cout << "Downloading: " << filepath << std::endl; res = this->downloadFile(url, filepath, std::string(), gamename); std::cout << std::endl; } else { std::cout << gogAPI->getErrorMessage() << std::endl; gogAPI->clearError(); } } return res; } void Downloader::showWishlist() { std::vector wishlistItems = gogWebsite->getWishlistItems(); for (unsigned int i = 0; i < wishlistItems.size(); ++i) { wishlistItem item = wishlistItems[i]; std::string platforms_text = Util::getOptionNameString(item.platform, GlobalConstants::PLATFORMS); std::string tags_text; for (unsigned int j = 0; j < item.tags.size(); ++j) { tags_text += (tags_text.empty() ? "" : ", ")+item.tags[j]; } if (!tags_text.empty()) tags_text = "[" + tags_text + "]"; std::string price_text = item.price; if (item.bIsDiscounted) price_text += " (-" + item.discount_percent + " | -" + item.discount + ")"; std::cout << item.title; if (!tags_text.empty()) std::cout << " " << tags_text; std::cout << std::endl; std::cout << "\t" << item.url << std::endl; if (item.platform != 0) std::cout << "\tPlatforms: " << platforms_text << std::endl; if (item.release_date_time != 0) std::cout << "\tRelease date: " << bptime::to_simple_string(bptime::from_time_t(item.release_date_time)) << std::endl; std::cout << "\tPrice: " << price_text << std::endl; if (item.bIsBonusStoreCreditIncluded) std::cout << "\tStore credit: " << item.store_credit << std::endl; std::cout << std::endl; } return; } void Downloader::processDownloadQueue(Config conf, const unsigned int& tid) { std::string msg_prefix = "[Thread #" + std::to_string(tid) + "]"; API* api = new API(conf.sToken, conf.sSecret); api->curlSetOpt(CURLOPT_SSL_VERIFYPEER, conf.bVerifyPeer); api->curlSetOpt(CURLOPT_CONNECTTIMEOUT, conf.iTimeout); if (!conf.sCACertPath.empty()) api->curlSetOpt(CURLOPT_CAINFO, conf.sCACertPath.c_str()); if (!api->init()) { delete api; msgQueue.push(Message("API init failed", MSGTYPE_ERROR, msg_prefix)); vDownloadInfo[tid].setStatus(DLSTATUS_FINISHED); return; } CURL* dlhandle = curl_easy_init(); curl_easy_setopt(dlhandle, CURLOPT_FOLLOWLOCATION, 1); curl_easy_setopt(dlhandle, CURLOPT_USERAGENT, conf.sVersionString.c_str()); curl_easy_setopt(dlhandle, CURLOPT_NOPROGRESS, 0); curl_easy_setopt(dlhandle, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(dlhandle, CURLOPT_CONNECTTIMEOUT, conf.iTimeout); curl_easy_setopt(dlhandle, CURLOPT_FAILONERROR, true); curl_easy_setopt(dlhandle, CURLOPT_SSL_VERIFYPEER, conf.bVerifyPeer); curl_easy_setopt(dlhandle, CURLOPT_VERBOSE, conf.bVerbose); curl_easy_setopt(dlhandle, CURLOPT_WRITEFUNCTION, Downloader::writeData); curl_easy_setopt(dlhandle, CURLOPT_READFUNCTION, Downloader::readData); curl_easy_setopt(dlhandle, CURLOPT_MAX_RECV_SPEED_LARGE, conf.iDownloadRate); // Assume that we have connection error and abort transfer with CURLE_OPERATION_TIMEDOUT if download speed is less than 200 B/s for 30 seconds curl_easy_setopt(dlhandle, CURLOPT_LOW_SPEED_TIME, 30); curl_easy_setopt(dlhandle, CURLOPT_LOW_SPEED_LIMIT, 200); if (!conf.sCACertPath.empty()) curl_easy_setopt(dlhandle, CURLOPT_CAINFO, conf.sCACertPath.c_str()); xferInfo xferinfo; xferinfo.tid = tid; xferinfo.curlhandle = dlhandle; curl_easy_setopt(dlhandle, CURLOPT_XFERINFOFUNCTION, Downloader::progressCallbackForThread); curl_easy_setopt(dlhandle, CURLOPT_XFERINFODATA, &xferinfo); gameFile gf; while (dlQueue.try_pop(gf)) { CURLcode result = CURLE_RECV_ERROR; // assume network error int iRetryCount = 0; off_t iResumePosition = 0; vDownloadInfo[tid].setStatus(DLSTATUS_STARTING); // Get directory from filepath boost::filesystem::path filepath = gf.getFilepath(); filepath = boost::filesystem::absolute(filepath, boost::filesystem::current_path()); boost::filesystem::path directory = filepath.parent_path(); // Skip blacklisted files if (conf.blacklist.isBlacklisted(filepath.string())) { msgQueue.push(Message("Blacklisted file: " + filepath.string(), MSGTYPE_INFO, msg_prefix)); continue; } std::string filenameXML = filepath.filename().string() + ".xml"; std::string xml_directory = conf.sXMLDirectory + "/" + gf.gamename; boost::filesystem::path local_xml_file = xml_directory + "/" + filenameXML; vDownloadInfo[tid].setFilename(filepath.filename().string()); msgQueue.push(Message("Begin download: " + filepath.filename().string(), MSGTYPE_INFO, msg_prefix)); // Check that directory exists and create subdirectories mtx_create_directories.lock(); // Use mutex to avoid possible race conditions if (boost::filesystem::exists(directory)) { if (!boost::filesystem::is_directory(directory)) { mtx_create_directories.unlock(); msgQueue.push(Message(directory.string() + " is not directory, skipping file (" + filepath.filename().string() + ")", MSGTYPE_WARNING, msg_prefix)); continue; } else { mtx_create_directories.unlock(); } } else { if (!boost::filesystem::create_directories(directory)) { mtx_create_directories.unlock(); msgQueue.push(Message("Failed to create directory (" + directory.string() + "), skipping file (" + filepath.filename().string() + ")", MSGTYPE_ERROR, msg_prefix)); continue; } else { mtx_create_directories.unlock(); } } bool bSameVersion = true; // assume same version bool bLocalXMLExists = boost::filesystem::exists(local_xml_file); // This is additional check to see if remote xml should be saved to speed up future version checks std::string xml; if (gf.type & (GFTYPE_INSTALLER | GFTYPE_PATCH) && conf.bRemoteXML) { xml = api->getXML(gf.gamename, gf.id); if (api->getError()) { msgQueue.push(Message(api->getErrorMessage(), MSGTYPE_ERROR, msg_prefix)); api->clearError(); } else { if (!xml.empty()) { std::string localHash = Util::getLocalFileHash(conf.sXMLDirectory, filepath.string(), gf.gamename); // Do version check if local hash exists if (!localHash.empty()) { tinyxml2::XMLDocument remote_xml; remote_xml.Parse(xml.c_str()); tinyxml2::XMLElement *fileElem = remote_xml.FirstChildElement("file"); if (fileElem) { std::string remoteHash = fileElem->Attribute("md5"); if (remoteHash != localHash) bSameVersion = false; } } } } } bool bResume = false; if (boost::filesystem::exists(filepath) && boost::filesystem::is_regular_file(filepath)) { if (bSameVersion) { bResume = true; } else { msgQueue.push(Message("Remote file is different, renaming local file", MSGTYPE_INFO, msg_prefix)); std::string date_old = "." + bptime::to_iso_string(bptime::second_clock::local_time()) + ".old"; boost::filesystem::path new_name = filepath.string() + date_old; // Rename old file by appending date and ".old" to filename boost::system::error_code ec; boost::filesystem::rename(filepath, new_name, ec); // Rename the file if (ec) { msgQueue.push(Message("Failed to rename " + filepath.string() + " to " + new_name.string() + " - Skipping file", MSGTYPE_WARNING, msg_prefix)); continue; } } } // Save remote XML if (!xml.empty()) { if ((bLocalXMLExists && !bSameVersion) || !bLocalXMLExists) { // Check that directory exists and create subdirectories boost::filesystem::path path = xml_directory; mtx_create_directories.lock(); // Use mutex to avoid race conditions if (boost::filesystem::exists(path)) { if (!boost::filesystem::is_directory(path)) { msgQueue.push(Message(path.string() + " is not directory", MSGTYPE_WARNING, msg_prefix)); } } else { if (!boost::filesystem::create_directories(path)) { msgQueue.push(Message("Failed to create directory: " + path.string(), MSGTYPE_ERROR, msg_prefix)); } } mtx_create_directories.unlock(); std::ofstream ofs(local_xml_file.string().c_str()); if (ofs) { ofs << xml; ofs.close(); } else { msgQueue.push(Message("Can't create " + local_xml_file.string(), MSGTYPE_ERROR, msg_prefix)); } } } // Get download url std::string url; if (gf.type & GFTYPE_INSTALLER) url = api->getInstallerLink(gf.gamename, gf.id); else if (gf.type & GFTYPE_PATCH) url = api->getPatchLink(gf.gamename, gf.id); else if (gf.type & GFTYPE_LANGPACK) url = api->getLanguagePackLink(gf.gamename, gf.id); else if (gf.type & GFTYPE_EXTRA) url = api->getExtraLink(gf.gamename, gf.id); else url = api->getExtraLink(gf.gamename, gf.id); // assume extra if type didn't match any of the others if (api->getError()) { msgQueue.push(Message(api->getErrorMessage(), MSGTYPE_ERROR, msg_prefix)); api->clearError(); continue; } curl_easy_setopt(dlhandle, CURLOPT_URL, url.c_str()); do { if (iRetryCount != 0) msgQueue.push(Message("Retry " + std::to_string(iRetryCount) + "/" + std::to_string(conf.iRetries) + ": " + filepath.filename().string(), MSGTYPE_INFO, msg_prefix)); FILE* outfile; // File exists, resume if (bResume) { iResumePosition = boost::filesystem::file_size(filepath); if ((outfile=fopen(filepath.string().c_str(), "r+"))!=NULL) { fseek(outfile, 0, SEEK_END); curl_easy_setopt(dlhandle, CURLOPT_RESUME_FROM_LARGE, iResumePosition); curl_easy_setopt(dlhandle, CURLOPT_WRITEDATA, outfile); } else { msgQueue.push(Message("Failed to open " + filepath.string(), MSGTYPE_ERROR, msg_prefix)); break; } } else // File doesn't exist, create new file { if ((outfile=fopen(filepath.string().c_str(), "w"))!=NULL) { curl_easy_setopt(dlhandle, CURLOPT_RESUME_FROM_LARGE, 0); // start downloading from the beginning of file curl_easy_setopt(dlhandle, CURLOPT_WRITEDATA, outfile); } else { msgQueue.push(Message("Failed to create " + filepath.string(), MSGTYPE_ERROR, msg_prefix)); break; } } xferinfo.offset = iResumePosition; xferinfo.timer.reset(); xferinfo.TimeAndSize.clear(); result = curl_easy_perform(dlhandle); fclose(outfile); if (result == CURLE_PARTIAL_FILE || result == CURLE_OPERATION_TIMEDOUT) { iRetryCount++; if (boost::filesystem::exists(filepath) && boost::filesystem::is_regular_file(filepath)) bResume = true; } } while ((result == CURLE_PARTIAL_FILE || result == CURLE_OPERATION_TIMEDOUT) && (iRetryCount <= conf.iRetries)); long int response_code = 0; if (result == CURLE_HTTP_RETURNED_ERROR) { curl_easy_getinfo(dlhandle, CURLINFO_RESPONSE_CODE, &response_code); } if (result == CURLE_OK || result == CURLE_RANGE_ERROR || (result == CURLE_HTTP_RETURNED_ERROR && response_code == 416)) { // Average download speed std::ostringstream dlrate_avg; std::string rate_unit; progressInfo progress_info = vDownloadInfo[tid].getProgressInfo(); if (progress_info.rate_avg > 1048576) // 1 MB { progress_info.rate_avg /= 1048576; rate_unit = "MB/s"; } else { progress_info.rate_avg /= 1024; rate_unit = "kB/s"; } dlrate_avg << std::setprecision(2) << std::fixed << progress_info.rate_avg << rate_unit; msgQueue.push(Message("Download complete: " + filepath.filename().string() + " (@ " + dlrate_avg.str() + ")", MSGTYPE_SUCCESS, msg_prefix)); } else { msgQueue.push(Message("Download complete (" + static_cast(curl_easy_strerror(result)) + "): " + filepath.filename().string(), MSGTYPE_WARNING, msg_prefix)); // Delete the file if download failed and was not a resume attempt or the result is zero length file if (boost::filesystem::exists(filepath) && boost::filesystem::is_regular_file(filepath)) { if ((result != CURLE_PARTIAL_FILE && !bResume && result != CURLE_OPERATION_TIMEDOUT) || boost::filesystem::file_size(filepath) == 0) { if (!boost::filesystem::remove(filepath)) msgQueue.push(Message("Failed to delete " + filepath.filename().string(), MSGTYPE_ERROR, msg_prefix)); } } } // Automatic xml creation if (conf.bAutomaticXMLCreation) { if (result == CURLE_OK) { if ((gf.type & GFTYPE_EXTRA) || (conf.bRemoteXML && !bLocalXMLExists && xml.empty())) createXMLQueue.push(gf); } } } curl_easy_cleanup(dlhandle); delete api; vDownloadInfo[tid].setStatus(DLSTATUS_FINISHED); msgQueue.push(Message("Finished all tasks", MSGTYPE_INFO, msg_prefix)); return; } int Downloader::progressCallbackForThread(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) { // unused so lets prevent warnings and be more pedantic (void) ulnow; (void) ultotal; xferInfo* xferinfo = static_cast(clientp); // Update progress info every 100ms if (xferinfo->timer.getTimeBetweenUpdates()>=100 || dlnow == dltotal) { xferinfo->timer.reset(); progressInfo info; info.dlnow = dlnow; info.dltotal = dltotal; // trying to get rate and setting to NaN if it fails if (CURLE_OK != curl_easy_getinfo(xferinfo->curlhandle, CURLINFO_SPEED_DOWNLOAD, &info.rate_avg)) info.rate_avg = std::numeric_limits::quiet_NaN(); // setting full dlwnow and dltotal if (xferinfo->offset > 0) { info.dlnow += xferinfo->offset; info.dltotal += xferinfo->offset; } // 10 second average download speed // Don't use static value of 10 seconds because update interval depends on when and how often progress callback is called xferinfo->TimeAndSize.push_back(std::make_pair(time(NULL), static_cast(info.dlnow))); if (xferinfo->TimeAndSize.size() > 100) // 100 * 100ms = 10s { xferinfo->TimeAndSize.pop_front(); time_t time_first = xferinfo->TimeAndSize.front().first; uintmax_t size_first = xferinfo->TimeAndSize.front().second; time_t time_last = xferinfo->TimeAndSize.back().first; uintmax_t size_last = xferinfo->TimeAndSize.back().second; info.rate = (size_last - size_first) / static_cast((time_last - time_first)); } else { info.rate = info.rate_avg; } vDownloadInfo[xferinfo->tid].setProgressInfo(info); vDownloadInfo[xferinfo->tid].setStatus(DLSTATUS_RUNNING); } return 0; } void Downloader::printProgress() { // Print progress information until all threads have finished their tasks ProgressBar bar(config.bUnicode, config.bColor); unsigned int dl_status = DLSTATUS_NOTSTARTED; while (dl_status != DLSTATUS_FINISHED) { dl_status = DLSTATUS_NOTSTARTED; // Print progress information once per 100ms std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::cout << "\033[J\r" << std::flush; // Clear screen from the current line down to the bottom of the screen // Print messages from message queue first Message msg; while (msgQueue.try_pop(msg)) { std::cout << msg.getFormattedString(config.bColor, true) << std::endl; if (config.bReport) { this->report_ofs << msg.getTimestampString() << ": " << msg.getMessage() << std::endl; } } int iTermWidth = Util::getTerminalWidth(); double total_rate = 0; // Create progress info text for all download threads std::vector vProgressText; for (unsigned int i = 0; i < vDownloadInfo.size(); ++i) { std::string progress_text; int bar_length = 26; int min_bar_length = 5; unsigned int status = vDownloadInfo[i].getStatus(); dl_status |= status; if (status == DLSTATUS_FINISHED) { vProgressText.push_back("#" + std::to_string(i) + ": Finished"); continue; } std::string filename = vDownloadInfo[i].getFilename(); progressInfo progress_info = vDownloadInfo[i].getProgressInfo(); total_rate += progress_info.rate; bool starting = ((0 == progress_info.dlnow) && (0 == progress_info.dltotal)); double fraction = starting ? 0.0 : static_cast(progress_info.dlnow) / static_cast(progress_info.dltotal); std::string progress_percentage_text = Util::formattedString("%3.0f%% ", fraction * 100); int progress_percentage_text_length = progress_percentage_text.length() + 1; bptime::time_duration eta(bptime::seconds((long)((progress_info.dltotal - progress_info.dlnow) / progress_info.rate))); std::stringstream eta_ss; if (eta.hours() > 23) { eta_ss << eta.hours() / 24 << "d " << std::setfill('0') << std::setw(2) << eta.hours() % 24 << "h " << std::setfill('0') << std::setw(2) << eta.minutes() << "m " << std::setfill('0') << std::setw(2) << eta.seconds() << "s"; } else if (eta.hours() > 0) { eta_ss << eta.hours() << "h " << std::setfill('0') << std::setw(2) << eta.minutes() << "m " << std::setfill('0') << std::setw(2) << eta.seconds() << "s"; } else if (eta.minutes() > 0) { eta_ss << eta.minutes() << "m " << std::setfill('0') << std::setw(2) << eta.seconds() << "s"; } else { eta_ss << eta.seconds() << "s"; } std::string rate_unit; if (progress_info.rate > 1048576) // 1 MB { progress_info.rate /= 1048576; rate_unit = "MB/s"; } else { progress_info.rate /= 1024; rate_unit = "kB/s"; } std::string progress_status_text = Util::formattedString(" %0.2f/%0.2fMB @ %0.2f%s ETA: %s", static_cast(progress_info.dlnow)/1024/1024, static_cast(progress_info.dltotal)/1024/1024, progress_info.rate, rate_unit.c_str(), eta_ss.str().c_str()); int status_text_length = progress_status_text.length() + 1; if ((status_text_length + progress_percentage_text_length + bar_length) > iTermWidth) bar_length -= (status_text_length + progress_percentage_text_length + bar_length) - iTermWidth; // Don't draw progressbar if length is less than min_bar_length std::string progress_bar_text; if (bar_length >= min_bar_length) progress_bar_text = bar.createBarString(bar_length, fraction); progress_text = progress_percentage_text + progress_bar_text + progress_status_text; std::string filename_text = "#" + std::to_string(i) + " " + filename; Util::shortenStringToTerminalWidth(filename_text); vProgressText.push_back(filename_text); vProgressText.push_back(progress_text); } // Total download speed and number of remaining tasks in download queue if (dl_status != DLSTATUS_FINISHED) { std::ostringstream ss; if (config.iThreads > 1) { std::string rate_unit; if (total_rate > 1048576) // 1 MB { total_rate /= 1048576; rate_unit = "MB/s"; } else { total_rate /= 1024; rate_unit = "kB/s"; } ss << "Total: " << std::setprecision(2) << std::fixed << total_rate << rate_unit << " | "; } ss << "Remaining: " << dlQueue.size(); vProgressText.push_back(ss.str()); } // Print progress info for (unsigned int i = 0; i < vProgressText.size(); ++i) { std::cout << vProgressText[i] << std::endl; } // Move cursor up by vProgressText.size() rows if (dl_status != DLSTATUS_FINISHED) { std::cout << "\033[" << vProgressText.size() << "A\r" << std::flush; } } } void Downloader::getGameDetailsThread(Config config, const unsigned int& tid) { std::string msg_prefix = "[Thread #" + std::to_string(tid) + "]"; API* api = new API(config.sToken, config.sSecret); api->curlSetOpt(CURLOPT_SSL_VERIFYPEER, config.bVerifyPeer); api->curlSetOpt(CURLOPT_CONNECTTIMEOUT, config.iTimeout); if (!config.sCACertPath.empty()) api->curlSetOpt(CURLOPT_CAINFO, config.sCACertPath.c_str()); if (!api->init()) { delete api; msgQueue.push(Message("API init failed", MSGTYPE_ERROR, msg_prefix)); vDownloadInfo[tid].setStatus(DLSTATUS_FINISHED); return; } // Create new GOG website handle Website* website = new Website(config); if (!website->IsLoggedIn()) { delete api; delete website; msgQueue.push(Message("Website not logged in", MSGTYPE_ERROR, msg_prefix)); vDownloadInfo[tid].setStatus(DLSTATUS_FINISHED); return; } // Set default game specific directory options to values from config gameSpecificDirectoryConfig dirConfDefault; dirConfDefault.sDirectory = config.sDirectory; dirConfDefault.bSubDirectories = config.bSubDirectories; dirConfDefault.sGameSubdir = config.sGameSubdir; dirConfDefault.sInstallersSubdir = config.sInstallersSubdir; dirConfDefault.sExtrasSubdir = config.sExtrasSubdir; dirConfDefault.sLanguagePackSubdir = config.sLanguagePackSubdir; dirConfDefault.sDLCSubdir = config.sDLCSubdir; dirConfDefault.sPatchesSubdir = config.sPatchesSubdir; gameItem game_item; while (gameItemQueue.try_pop(game_item)) { gameDetails game; bool bHasDLC = !game_item.dlcnames.empty(); gameSpecificConfig conf; conf.bDLC = config.bDLC; conf.bIgnoreDLCCount = false; conf.iInstallerLanguage = config.iInstallerLanguage; conf.iInstallerPlatform = config.iInstallerPlatform; conf.dirConf = dirConfDefault; conf.vLanguagePriority = config.vLanguagePriority; conf.vPlatformPriority = config.vPlatformPriority; if (!config.bUpdateCache) // Disable game specific config files for cache update { int iOptionsOverridden = Util::getGameSpecificConfig(game_item.name, &conf); if (iOptionsOverridden > 0) { std::ostringstream ss; ss << game_item.name << " - " << iOptionsOverridden << " options overridden with game specific options" << std::endl; if (config.bVerbose) { if (conf.bIgnoreDLCCount) ss << "\tIgnore DLC count" << std::endl; if (conf.bDLC != config.bDLC) ss << "\tDLC: " << (conf.bDLC ? "true" : "false") << std::endl; if (conf.iInstallerLanguage != config.iInstallerLanguage) ss << "\tLanguage: " << Util::getOptionNameString(conf.iInstallerLanguage, GlobalConstants::LANGUAGES) << std::endl; if (conf.vLanguagePriority != config.vLanguagePriority) { ss << "\tLanguage priority:" << std::endl; for (unsigned int j = 0; j < conf.vLanguagePriority.size(); ++j) { ss << "\t " << j << ": " << Util::getOptionNameString(conf.vLanguagePriority[j], GlobalConstants::LANGUAGES) << std::endl; } } if (conf.iInstallerPlatform != config.iInstallerPlatform) ss << "\tPlatform: " << Util::getOptionNameString(conf.iInstallerPlatform, GlobalConstants::PLATFORMS) << std::endl; if (conf.vPlatformPriority != config.vPlatformPriority) { ss << "\tPlatform priority:" << std::endl; for (unsigned int j = 0; j < conf.vPlatformPriority.size(); ++j) { ss << "\t " << j << ": " << Util::getOptionNameString(conf.vPlatformPriority[j], GlobalConstants::PLATFORMS) << std::endl; } } } msgQueue.push(Message(ss.str(), MSGTYPE_INFO, msg_prefix)); } } game = api->getGameDetails(game_item.name, conf.iInstallerPlatform, conf.iInstallerLanguage, config.bDuplicateHandler); if (!api->getError()) { game.filterWithPriorities(conf); Json::Value gameDetailsJSON; if (!game_item.gamedetailsjson.empty()) gameDetailsJSON = game_item.gamedetailsjson; if (game.extras.empty() && config.bExtras) // Try to get extras from account page if API didn't return any extras { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); game.extras = Downloader::getExtrasFromJSON(gameDetailsJSON, game_item.name, config); } if (config.bSaveSerials) { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); game.serials = Downloader::getSerialsFromJSON(gameDetailsJSON); } if (config.bSaveChangelogs) { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); game.changelog = Downloader::getChangelogFromJSON(gameDetailsJSON); } // Ignore DLC count and try to get DLCs from JSON if (game.dlcs.empty() && !bHasDLC && conf.bDLC && conf.bIgnoreDLCCount) { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); game_item.dlcnames = Util::getDLCNamesFromJSON(gameDetailsJSON["dlcs"]); bHasDLC = !game_item.dlcnames.empty(); } if (game.dlcs.empty() && bHasDLC && conf.bDLC) { for (unsigned int j = 0; j < game_item.dlcnames.size(); ++j) { gameDetails dlc; dlc = api->getGameDetails(game_item.dlcnames[j], conf.iInstallerPlatform, conf.iInstallerLanguage, config.bDuplicateHandler); dlc.filterWithPriorities(conf); if (dlc.extras.empty() && config.bExtras) // Try to get extras from account page if API didn't return any extras { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); // Make sure we get extras for the right DLC for (unsigned int k = 0; k < gameDetailsJSON["dlcs"].size(); ++k) { std::vector urls; if (gameDetailsJSON["dlcs"][k].isMember("extras")) Util::getDownloaderUrlsFromJSON(gameDetailsJSON["dlcs"][k]["extras"], urls); if (!urls.empty()) { if (urls[0].find("/" + game_item.dlcnames[j] + "/") != std::string::npos) { dlc.extras = Downloader::getExtrasFromJSON(gameDetailsJSON["dlcs"][k], game_item.dlcnames[j], config); } } } } if (config.bSaveSerials) { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); // Make sure we save serial for the right DLC for (unsigned int k = 0; k < gameDetailsJSON["dlcs"].size(); ++k) { std::vector urls; if (gameDetailsJSON["dlcs"][k].isMember("cdKey") && gameDetailsJSON["dlcs"][k].isMember("downloads")) { // Assuming that only DLC with installers can have serial Util::getDownloaderUrlsFromJSON(gameDetailsJSON["dlcs"][k]["downloads"], urls); } if (!urls.empty()) { if (urls[0].find("/" + game_item.dlcnames[j] + "/") != std::string::npos) { dlc.serials = Downloader::getSerialsFromJSON(gameDetailsJSON["dlcs"][k]); } } } } if (config.bSaveChangelogs) { if (gameDetailsJSON.empty()) gameDetailsJSON = website->getGameDetailsJSON(game_item.id); // Make sure we save changelog for the right DLC for (unsigned int k = 0; k < gameDetailsJSON["dlcs"].size(); ++k) { std::vector urls; if (gameDetailsJSON["dlcs"][k].isMember("changelog") && gameDetailsJSON["dlcs"][k].isMember("downloads")) { // Assuming that only DLC with installers can have changelog Util::getDownloaderUrlsFromJSON(gameDetailsJSON["dlcs"][k]["downloads"], urls); } if (!urls.empty()) { if (urls[0].find("/" + game_item.dlcnames[j] + "/") != std::string::npos) { dlc.changelog = Downloader::getChangelogFromJSON(gameDetailsJSON["dlcs"][k]); } } } } // Add DLC type to all DLC files for (unsigned int a = 0; a < dlc.installers.size(); ++a) dlc.installers[a].type |= GFTYPE_DLC; for (unsigned int a = 0; a < dlc.extras.size(); ++a) dlc.extras[a].type |= GFTYPE_DLC; for (unsigned int a = 0; a < dlc.patches.size(); ++a) dlc.patches[a].type |= GFTYPE_DLC; for (unsigned int a = 0; a < dlc.languagepacks.size(); ++a) dlc.languagepacks[a].type |= GFTYPE_DLC; game.dlcs.push_back(dlc); } } game.makeFilepaths(conf.dirConf); if (!config.bUpdateCheck) gameDetailsQueue.push(game); else { // Update check, only add games that have updated files for (unsigned int j = 0; j < game.installers.size(); ++j) { if (game.installers[j].updated) { gameDetailsQueue.push(game); break; // add the game only once } } } } else { msgQueue.push(Message(api->getErrorMessage(), MSGTYPE_ERROR, msg_prefix)); api->clearError(); continue; } } vDownloadInfo[tid].setStatus(DLSTATUS_FINISHED); delete api; delete website; return; } lgogdownloader-3.1/src/gamedetails.cpp000066400000000000000000000202261303617702600201450ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "gamedetails.h" gameDetails::gameDetails() { //ctor } gameDetails::~gameDetails() { //dtor } void gameDetails::filterWithPriorities(const gameSpecificConfig& config) { if (config.vPlatformPriority.empty() && config.vLanguagePriority.empty()) return; filterListWithPriorities(installers, config); filterListWithPriorities(patches, config); filterListWithPriorities(languagepacks, config); } void gameDetails::filterListWithPriorities(std::vector& list, const gameSpecificConfig& config) { /* Compute the score of each item - we use a scoring mechanism and we keep all ties Like if someone asked French then English and Linux then Windows, but there are only Windows French, Windows English and Linux English versions, we'll get the Windows French and Linux English ones. Score is inverted: lower is better. */ int bestscore = -1; for (std::vector::iterator fileDetails = list.begin(); fileDetails != list.end(); fileDetails++) { fileDetails->score = 0; if (!config.vPlatformPriority.empty()) { for (size_t i = 0; i != config.vPlatformPriority.size(); i++) if (fileDetails->platform & config.vPlatformPriority[i]) { fileDetails->score += i; break; } } if (!config.vLanguagePriority.empty()) { for (size_t i = 0; i != config.vLanguagePriority.size(); i++) if (fileDetails->language & config.vLanguagePriority[i]) { fileDetails->score += i; break; } } if ((fileDetails->score < bestscore) or (bestscore < 0)) bestscore = fileDetails->score; } for (std::vector::iterator fileDetails = list.begin(); fileDetails != list.end(); ) { if (fileDetails->score > bestscore) fileDetails = list.erase(fileDetails); else fileDetails++; } } void gameDetails::makeFilepaths(const gameSpecificDirectoryConfig& config) { std::string filepath; std::string directory = config.sDirectory + "/" + config.sGameSubdir + "/"; std::string subdir; this->serialsFilepath = Util::makeFilepath(directory, "serials.txt", this->gamename, subdir, 0); this->changelogFilepath = Util::makeFilepath(directory, "changelog_" + gamename + ".html", this->gamename, subdir, 0); for (unsigned int i = 0; i < this->installers.size(); ++i) { subdir = config.bSubDirectories ? config.sInstallersSubdir : ""; filepath = Util::makeFilepath(directory, this->installers[i].path, this->gamename, subdir, this->installers[i].platform); this->installers[i].setFilepath(filepath); } for (unsigned int i = 0; i < this->extras.size(); ++i) { subdir = config.bSubDirectories ? config.sExtrasSubdir : ""; filepath = Util::makeFilepath(directory, this->extras[i].path, this->gamename, subdir, 0); this->extras[i].setFilepath(filepath); } for (unsigned int i = 0; i < this->patches.size(); ++i) { subdir = config.bSubDirectories ? config.sPatchesSubdir : ""; filepath = Util::makeFilepath(directory, this->patches[i].path, this->gamename, subdir, this->patches[i].platform); this->patches[i].setFilepath(filepath); } for (unsigned int i = 0; i < this->languagepacks.size(); ++i) { subdir = config.bSubDirectories ? config.sLanguagePackSubdir : ""; filepath = Util::makeFilepath(directory, this->languagepacks[i].path, this->gamename, subdir, 0); this->languagepacks[i].setFilepath(filepath); } for (unsigned int i = 0; i < this->dlcs.size(); ++i) { subdir = config.bSubDirectories ? config.sDLCSubdir + "/" + config.sInstallersSubdir : ""; this->dlcs[i].serialsFilepath = Util::makeFilepath(directory, "serials.txt", this->gamename, subdir, 0); this->dlcs[i].changelogFilepath = Util::makeFilepath(directory, "changelog_" + this->dlcs[i].gamename + ".html", this->gamename, subdir, 0); for (unsigned int j = 0; j < this->dlcs[i].installers.size(); ++j) { subdir = config.bSubDirectories ? config.sDLCSubdir + "/" + config.sInstallersSubdir : ""; filepath = Util::makeFilepath(directory, this->dlcs[i].installers[j].path, this->gamename, subdir, this->dlcs[i].installers[j].platform, this->dlcs[i].gamename); this->dlcs[i].installers[j].setFilepath(filepath); } for (unsigned int j = 0; j < this->dlcs[i].patches.size(); ++j) { subdir = config.bSubDirectories ? config.sDLCSubdir + "/" + config.sPatchesSubdir : ""; filepath = Util::makeFilepath(directory, this->dlcs[i].patches[j].path, this->gamename, subdir, this->dlcs[i].patches[j].platform, this->dlcs[i].gamename); this->dlcs[i].patches[j].setFilepath(filepath); } for (unsigned int j = 0; j < this->dlcs[i].extras.size(); ++j) { subdir = config.bSubDirectories ? config.sDLCSubdir + "/" + config.sExtrasSubdir : ""; filepath = Util::makeFilepath(directory, this->dlcs[i].extras[j].path, this->gamename, subdir, 0, this->dlcs[i].gamename); this->dlcs[i].extras[j].setFilepath(filepath); } for (unsigned int j = 0; j < this->dlcs[i].languagepacks.size(); ++j) { subdir = config.bSubDirectories ? config.sDLCSubdir + "/" + config.sLanguagePackSubdir : ""; filepath = Util::makeFilepath(directory, this->dlcs[i].languagepacks[j].path, this->gamename, subdir, 0, this->dlcs[i].gamename); this->dlcs[i].languagepacks[j].setFilepath(filepath); } } } Json::Value gameDetails::getDetailsAsJson() { Json::Value json; json["gamename"] = this->gamename; json["title"] = this->title; json["icon"] = this->icon; json["serials"] = this->serials; json["changelog"] = this->changelog; for (unsigned int i = 0; i < this->extras.size(); ++i) json["extras"].append(this->extras[i].getAsJson()); for (unsigned int i = 0; i < this->installers.size(); ++i) json["installers"].append(this->installers[i].getAsJson()); for (unsigned int i = 0; i < this->patches.size(); ++i) json["patches"].append(this->patches[i].getAsJson()); for (unsigned int i = 0; i < this->languagepacks.size(); ++i) json["languagepacks"].append(this->languagepacks[i].getAsJson()); if (!this->dlcs.empty()) { for (unsigned int i = 0; i < this->dlcs.size(); ++i) { json["dlcs"].append(this->dlcs[i].getDetailsAsJson()); } } return json; } std::string gameDetails::getSerialsFilepath() { return this->serialsFilepath; } std::string gameDetails::getChangelogFilepath() { return this->changelogFilepath; } // Return vector containing all game files std::vector gameDetails::getGameFileVector() { std::vector vGameFiles; vGameFiles.insert(std::end(vGameFiles), std::begin(installers), std::end(installers)); vGameFiles.insert(std::end(vGameFiles), std::begin(patches), std::end(patches)); vGameFiles.insert(std::end(vGameFiles), std::begin(extras), std::end(extras)); vGameFiles.insert(std::end(vGameFiles), std::begin(languagepacks), std::end(languagepacks)); if (!dlcs.empty()) { for (unsigned int i = 0; i < dlcs.size(); ++i) { std::vector vGameFilesDLC = dlcs[i].getGameFileVector(); vGameFiles.insert(std::end(vGameFiles), std::begin(vGameFilesDLC), std::end(vGameFilesDLC)); } } return vGameFiles; } lgogdownloader-3.1/src/gamefile.cpp000066400000000000000000000021441303617702600174360ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "gamefile.h" gameFile::gameFile() { this->platform = GlobalConstants::PLATFORM_WINDOWS; this->language = GlobalConstants::LANGUAGE_EN; this->silent = 0; this->type = 0; } gameFile::~gameFile() { //dtor } void gameFile::setFilepath(const std::string& path) { this->filepath = path; } std::string gameFile::getFilepath() { return this->filepath; } Json::Value gameFile::getAsJson() { Json::Value json; json["updated"] = this->updated; json["id"] = this->id; json["name"] = this->name; json["path"] = this->path; json["size"] = this->size; json["platform"] = this->platform; json["language"] = this->language; json["silent"] = this->silent; json["gamename"] = this->gamename; json["type"] = this->type; return json; } lgogdownloader-3.1/src/progressbar.cpp000066400000000000000000000060701303617702600202200ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "progressbar.h" #include #include ProgressBar::ProgressBar(bool bUnicode, bool bColor) : // Based on block characters. // See https://en.wikipedia.org/wiki/List_of_Unicode_characters#Block_elements // u8"\u2591" - you can try using this ("light shade") instead of space, but it looks worse, // since partial bar has no shade behind it. m_bar_chars { " ", // 0/8 u8"\u258F", // 1/8 u8"\u258E", // 2/8 u8"\u258D", // 3/8 u8"\u258C", // 4/8 u8"\u258B", // 5/8 u8"\u258A", // 6/8 u8"\u2589", // 7/8 u8"\u2588" /* 8/8 */ }, m_left_border(u8"\u2595"), // right 1/8th m_right_border(u8"\u258F"), // left 1/8th m_simple_left_border("["), m_simple_right_border("]"), m_simple_empty_fill(" "), m_simple_bar_char("="), // using vt100 escape sequences for colors... See http://ascii-table.com/ansi-escape-sequences.php m_bar_color("\033[1;34m"), m_border_color("\033[1;37m"), COLOR_RESET("\033[0m"), m_use_unicode(bUnicode), m_use_color(bColor) { } ProgressBar::~ProgressBar() { //dtor } void ProgressBar::draw(unsigned int length, double fraction) { std::cout << createBarString(length, fraction); } std::string ProgressBar::createBarString(unsigned int length, double fraction) { std::ostringstream ss; // validation if (!std::isnormal(fraction) || (fraction < 0.0)) fraction = 0.0; else if (fraction > 1.0) fraction = 1.0; double bar_part = fraction * length; double whole_bar_chars = std::floor(bar_part); unsigned int whole_bar_chars_i = (unsigned int) whole_bar_chars; // The bar uses symbols graded with 1/8 unsigned int partial_bar_char_index = (unsigned int) std::floor((bar_part - whole_bar_chars) * 8.0); // left border if (m_use_color) ss << m_border_color; ss << (m_use_unicode ? m_left_border : m_simple_left_border); // whole completed bars if (m_use_color) ss << m_bar_color; unsigned int i = 0; for (; i < whole_bar_chars_i; i++) { ss << (m_use_unicode ? m_bar_chars[8] : m_simple_bar_char); } // partial completed bar if (i < length) ss << (m_use_unicode ? m_bar_chars[partial_bar_char_index] : m_simple_empty_fill); // whole unfinished bars if (m_use_color) ss << COLOR_RESET; for (i = whole_bar_chars_i + 1; i < length; i++) { // first entry in m_bar_chars is assumed to be the empty bar ss << (m_use_unicode ? m_bar_chars[0] : m_simple_empty_fill); } // right border if (m_use_color) ss << m_border_color; ss << (m_use_unicode ? m_right_border : m_simple_right_border); if (m_use_color) ss << COLOR_RESET; return ss.str(); } lgogdownloader-3.1/src/util.cpp000066400000000000000000000444451303617702600166540ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "util.h" #include #include #include #include #include #include /* Create filepath from specified directory and path Remove the leading slash from path if needed Use gamename as base directory if specified */ std::string Util::makeFilepath(const std::string& directory, const std::string& path, const std::string& gamename, std::string subdirectory, const unsigned int& platformId, const std::string& dlcname) { std::string dir = directory + makeRelativeFilepath(path, gamename, subdirectory); Util::filepathReplaceReservedStrings(dir, gamename, platformId, dlcname); return dir; } /* Create filepath relative to download base directory specified in config. */ std::string Util::makeRelativeFilepath(const std::string& path, const std::string& gamename, std::string subdirectory) { std::string filepath; if (gamename.empty()) { if (path.at(0)=='/') { std::string tmp_path = path.substr(1,path.length()); filepath = tmp_path; } else { filepath = path; } } else { std::string filename = path.substr(path.find_last_of("/")+1, path.length()); if (!subdirectory.empty()) { subdirectory = "/" + subdirectory; } filepath = subdirectory + "/" + filename; } return filepath; } std::string Util::getFileHash(const std::string& filename, unsigned hash_id) { unsigned char digest[rhash_get_digest_size(hash_id)]; char result[rhash_get_hash_length(hash_id)]; rhash_library_init(); int i = rhash_file(hash_id, filename.c_str(), digest); if (i < 0) std::cerr << "LibRHash error: " << strerror(errno) << std::endl; else rhash_print_bytes(result, digest, rhash_get_digest_size(hash_id), RHPR_HEX); return result; } std::string Util::getChunkHash(unsigned char *chunk, uintmax_t chunk_size, unsigned hash_id) { unsigned char digest[rhash_get_digest_size(hash_id)]; char result[rhash_get_hash_length(hash_id)]; rhash_library_init(); int i = rhash_msg(hash_id, chunk, chunk_size, digest); if (i < 0) std::cerr << "LibRHash error: " << strerror(errno) << std::endl; else rhash_print_bytes(result, digest, rhash_get_digest_size(hash_id), RHPR_HEX); return result; } // Create GOG XML int Util::createXML(std::string filepath, uintmax_t chunk_size, std::string xml_dir) { int res = 0; FILE *infile; FILE *xmlfile; uintmax_t filesize, size; int chunks, i; if (xml_dir.empty()) { xml_dir = Util::getCacheHome() + "/lgogdownloader/xml"; } // Make sure directory exists boost::filesystem::path path = xml_dir; if (!boost::filesystem::exists(path)) { if (!boost::filesystem::create_directories(path)) { std::cerr << "Failed to create directory: " << path << std::endl; return res; } } if ((infile=fopen(filepath.c_str(), "r"))!=NULL) { //File exists fseek(infile, 0, SEEK_END); filesize = ftell(infile); rewind(infile); } else { std::cerr << filepath << " doesn't exist" << std::endl; return res; } // Get filename boost::filesystem::path pathname = filepath; std::string filename = pathname.filename().string(); std::string filenameXML = xml_dir + "/" + filename + ".xml"; std::cout << filename << std::endl; //Determine number of chunks int remaining = filesize % chunk_size; chunks = (remaining == 0) ? filesize/chunk_size : (filesize/chunk_size)+1; std::cout << "Filesize: " << filesize << " bytes" << std::endl << "Chunks: " << chunks << std::endl << "Chunk size: " << (chunk_size >> 20) << " MB" << std::endl; tinyxml2::XMLDocument xml; tinyxml2::XMLElement *fileElem = xml.NewElement("file"); fileElem->SetAttribute("name", filename.c_str()); fileElem->SetAttribute("chunks", chunks); fileElem->SetAttribute("total_size", std::to_string(filesize).c_str()); std::cout << "Getting MD5 for chunks" << std::endl; rhash rhash_context; rhash_library_init(); rhash_context = rhash_init(RHASH_MD5); if(!rhash_context) { std::cerr << "error: couldn't initialize rhash context" << std::endl; return res; } char rhash_result[rhash_get_hash_length(RHASH_MD5)]; for (i = 0; i < chunks; i++) { uintmax_t range_begin = i*chunk_size; fseek(infile, range_begin, SEEK_SET); if ((i == chunks-1) && (remaining != 0)) chunk_size = remaining; uintmax_t range_end = range_begin + chunk_size - 1; unsigned char *chunk = (unsigned char *) malloc(chunk_size * sizeof(unsigned char *)); if (chunk == NULL) { std::cerr << "Memory error" << std::endl; return res; } size = fread(chunk, 1, chunk_size, infile); if (size != chunk_size) { std::cerr << "Read error" << std::endl; free(chunk); return res; } std::string hash = Util::getChunkHash(chunk, chunk_size, RHASH_MD5); rhash_update(rhash_context, chunk, chunk_size); // Update hash for the whole file free(chunk); tinyxml2::XMLElement *chunkElem = xml.NewElement("chunk"); chunkElem->SetAttribute("id", i); chunkElem->SetAttribute("from", std::to_string(range_begin).c_str()); chunkElem->SetAttribute("to", std::to_string(range_end).c_str()); chunkElem->SetAttribute("method", "md5"); tinyxml2::XMLText *text = xml.NewText(hash.c_str()); chunkElem->LinkEndChild(text); fileElem->LinkEndChild(chunkElem); std::cout << "Chunks hashed " << (i+1) << " / " << chunks << "\r" << std::flush; } fclose(infile); rhash_final(rhash_context, NULL); rhash_print(rhash_result, rhash_context, RHASH_MD5, RHPR_HEX); rhash_free(rhash_context); std::cout << std::endl << "MD5: " << rhash_result << std::endl; fileElem->SetAttribute("md5", rhash_result); xml.LinkEndChild(fileElem); std::cout << "Writing XML: " << filenameXML << std::endl; if ((xmlfile=fopen(filenameXML.c_str(), "w"))!=NULL) { tinyxml2::XMLPrinter printer(xmlfile); xml.Print(&printer); fclose(xmlfile); res = 1; } else { std::cerr << "Can't create " << filenameXML << std::endl; return res; } return res; } /* Overrides global settings with game specific settings returns 0 if fails returns number of changed settings if succesful */ int Util::getGameSpecificConfig(std::string gamename, gameSpecificConfig* conf, std::string directory) { int res = 0; if (directory.empty()) { directory = Util::getConfigHome() + "/lgogdownloader/gamespecific"; } std::string filepath = directory + "/" + gamename + ".conf"; // Make sure file exists boost::filesystem::path path = filepath; if (!boost::filesystem::exists(path)) { return res; } std::ifstream json(filepath, std::ifstream::binary); Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (jsonparser->parse(json, root)) { if (root.isMember("language")) { if (root["language"].isInt()) conf->iInstallerLanguage = root["language"].asUInt(); else { Util::parseOptionString(root["language"].asString(), conf->vLanguagePriority, conf->iInstallerLanguage, GlobalConstants::LANGUAGES); } res++; } if (root.isMember("platform")) { if (root["platform"].isInt()) conf->iInstallerPlatform = root["platform"].asUInt(); else { Util::parseOptionString(root["platform"].asString(), conf->vPlatformPriority, conf->iInstallerPlatform, GlobalConstants::PLATFORMS); } res++; } if (root.isMember("dlc")) { conf->bDLC = root["dlc"].asBool(); res++; } if (root.isMember("ignore-dlc-count")) { conf->bIgnoreDLCCount = root["ignore-dlc-count"].asBool(); res++; } if (root.isMember("subdirectories")) { conf->dirConf.bSubDirectories = root["subdirectories"].asBool(); res++; } if (root.isMember("directory")) { conf->dirConf.sDirectory = root["directory"].asString(); res++; } if (root.isMember("subdir-game")) { conf->dirConf.sGameSubdir = root["subdir-game"].asString(); res++; } if (root.isMember("subdir-installers")) { conf->dirConf.sInstallersSubdir = root["subdir-installers"].asString(); res++; } if (root.isMember("subdir-extras")) { conf->dirConf.sExtrasSubdir = root["subdir-extras"].asString(); res++; } if (root.isMember("subdir-patches")) { conf->dirConf.sPatchesSubdir = root["subdir-patches"].asString(); res++; } if (root.isMember("subdir-language-packs")) { conf->dirConf.sLanguagePackSubdir = root["subdir-language-packs"].asString(); res++; } if (root.isMember("subdir-dlc")) { conf->dirConf.sDLCSubdir = root["subdir-dlc"].asString(); res++; } } else { std::cerr << "Failed to parse game specific config " << filepath << std::endl; std::cerr << jsonparser->getFormattedErrorMessages() << std::endl; } delete jsonparser; if (json) json.close(); return res; } int Util::replaceString(std::string& str, const std::string& to_replace, const std::string& replace_with) { size_t pos = str.find(to_replace); if (pos == std::string::npos) { return 0; } str.replace(str.begin()+pos, str.begin()+pos+to_replace.length(), replace_with); return 1; } void Util::filepathReplaceReservedStrings(std::string& str, const std::string& gamename, const unsigned int& platformId, const std::string& dlcname) { std::string platform; for (unsigned int i = 0; i < GlobalConstants::PLATFORMS.size(); ++i) { if ((platformId & GlobalConstants::PLATFORMS[i].id) == GlobalConstants::PLATFORMS[i].id) { platform = boost::algorithm::to_lower_copy(GlobalConstants::PLATFORMS[i].str); break; } } if (platform.empty()) { if (str.find("%gamename%/%platform%") != std::string::npos) platform = ""; else platform = "no_platform"; } while (Util::replaceString(str, "%gamename%", gamename)); while (Util::replaceString(str, "%dlcname%", dlcname)); while (Util::replaceString(str, "%platform%", platform)); while (Util::replaceString(str, "//", "/")); // Replace any double slashes with single slash } void Util::setFilePermissions(const boost::filesystem::path& path, const boost::filesystem::perms& permissions) { if (boost::filesystem::exists(path)) { if (boost::filesystem::is_regular_file(path)) { boost::filesystem::file_status s = boost::filesystem::status(path); if (s.permissions() != permissions) { boost::system::error_code ec; boost::filesystem::permissions(path, permissions, ec); if (ec) { std::cerr << "Failed to set file permissions for " << path.string() << std::endl; } } } } } int Util::getTerminalWidth() { int width; if(isatty(STDOUT_FILENO)) { struct winsize w; ioctl(STDOUT_FILENO, TIOCGWINSZ, &w); width = static_cast(w.ws_col); } else width = 10000;//Something sufficiently big return width; } void Util::getDownloaderUrlsFromJSON(const Json::Value &root, std::vector &urls) { if(root.size() > 0) { for(Json::ValueConstIterator it = root.begin() ; it != root.end() ; ++it) { if (it.key() == "downloaderUrl") { Json::Value url = *it; urls.push_back(url.asString()); } else getDownloaderUrlsFromJSON(*it, urls); } } return; } std::vector Util::getDLCNamesFromJSON(const Json::Value &root) { std::vector urls, dlcnames; getDownloaderUrlsFromJSON(root, urls); for (unsigned int i = 0; i < urls.size(); ++i) { std::string gamename; if (urls[i].find(GlobalConstants::PROTOCOL_PREFIX) == std::string::npos) continue; gamename.assign(urls[i].begin()+urls[i].find(GlobalConstants::PROTOCOL_PREFIX)+GlobalConstants::PROTOCOL_PREFIX.length(), urls[i].begin()+urls[i].find_last_of("/")); bool bDuplicate = false; for (unsigned int j = 0; j < dlcnames.size(); ++j) { if (gamename == dlcnames[j]) { bDuplicate = true; break; } } if (!bDuplicate) dlcnames.push_back(gamename); } return dlcnames; } std::string Util::getHomeDir() { return (std::string)getenv("HOME"); } std::string Util::getConfigHome() { std::string configHome; char *xdgconfig = getenv("XDG_CONFIG_HOME"); if (xdgconfig) configHome = (std::string)xdgconfig; else configHome = Util::getHomeDir() + "/.config"; return configHome; } std::string Util::getCacheHome() { std::string cacheHome; char *xdgcache = getenv("XDG_CACHE_HOME"); if (xdgcache) cacheHome = (std::string)xdgcache; else cacheHome = Util::getHomeDir() + "/.cache"; return cacheHome; } std::vector Util::tokenize(const std::string& str, const std::string& separator) { std::vector tokens; std::string token; size_t idx = 0, found; while ((found = str.find(separator, idx)) != std::string::npos) { token = str.substr(idx, found - idx); if (!token.empty()) tokens.push_back(token); idx = found + separator.length(); } token = str.substr(idx); if (!token.empty()) tokens.push_back(token); return tokens; } unsigned int Util::getOptionValue(const std::string& str, const std::vector& options) { unsigned int value = 0; boost::regex expression("^[+-]?\\d+$", boost::regex::perl); boost::match_results what; if (str == "all") { value = (1 << options.size()) - 1; } else if (boost::regex_search(str, what, expression)) { value = std::stoi(str); } else { for (unsigned int i = 0; i < options.size(); ++i) { if (!options[i].regexp.empty()) { boost::regex expr("^(" + options[i].regexp + ")$", boost::regex::perl | boost::regex::icase); if (boost::regex_search(str, what, expr)) { value = options[i].id; break; } } else if (str == options[i].code) { value = options[i].id; break; } } } return value; } std::string Util::getOptionNameString(const unsigned int& value, const std::vector& options) { std::string str; for (unsigned int i = 0; i < options.size(); ++i) { if (value & options[i].id) str += (str.empty() ? "" : ", ")+options[i].str; } return str; } // Parse the options string void Util::parseOptionString(const std::string &option_string, std::vector &priority, unsigned int &type, const std::vector& options) { type = 0; priority.clear(); std::vector tokens_priority = Util::tokenize(option_string, ","); for (std::vector::iterator it_priority = tokens_priority.begin(); it_priority != tokens_priority.end(); it_priority++) { unsigned int value = 0; std::vector tokens_value = Util::tokenize(*it_priority, "+"); for (std::vector::iterator it_value = tokens_value.begin(); it_value != tokens_value.end(); it_value++) { value |= Util::getOptionValue(*it_value, options); } priority.push_back(value); type |= value; } } std::string Util::getLocalFileHash(const std::string& xml_dir, const std::string& filepath, const std::string& gamename) { std::string localHash; boost::filesystem::path path = filepath; boost::filesystem::path local_xml_file; if (!gamename.empty()) local_xml_file = xml_dir + "/" + gamename + "/" + path.filename().string() + ".xml"; else local_xml_file = xml_dir + "/" + path.filename().string() + ".xml"; if (boost::filesystem::exists(local_xml_file)) { tinyxml2::XMLDocument local_xml; local_xml.LoadFile(local_xml_file.string().c_str()); tinyxml2::XMLElement *fileElem = local_xml.FirstChildElement("file"); if (fileElem) { localHash = fileElem->Attribute("md5"); } } else if (boost::filesystem::exists(path) && boost::filesystem::is_regular_file(path)) { localHash = Util::getFileHash(path.string(), RHASH_MD5); } return localHash; } void Util::shortenStringToTerminalWidth(std::string& str) { int iStrLen = static_cast(str.length()); int iTermWidth = Util::getTerminalWidth(); if (iStrLen >= iTermWidth) { size_t chars_to_remove = (iStrLen - iTermWidth) + 4; size_t middle = iStrLen / 2; size_t pos1 = middle - (chars_to_remove / 2); size_t pos2 = middle + (chars_to_remove / 2); str.replace(str.begin()+pos1, str.begin()+pos2, "..."); } } lgogdownloader-3.1/src/website.cpp000066400000000000000000000750341303617702600173370ustar00rootroot00000000000000/* This program is free software. It comes without any warranty, to * the extent permitted by applicable law. You can redistribute it * and/or modify it under the terms of the Do What The Fuck You Want * To Public License, Version 2, as published by Sam Hocevar. See * http://www.wtfpl.net/ for more details. */ #include "website.h" #include "globalconstants.h" #include #include Website::Website(Config &conf) { this->config = conf; this->retries = 0; curlhandle = curl_easy_init(); curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 1); curl_easy_setopt(curlhandle, CURLOPT_USERAGENT, config.sVersionString.c_str()); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curlhandle, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(curlhandle, CURLOPT_CONNECTTIMEOUT, config.iTimeout); curl_easy_setopt(curlhandle, CURLOPT_FAILONERROR, true); curl_easy_setopt(curlhandle, CURLOPT_COOKIEFILE, config.sCookiePath.c_str()); curl_easy_setopt(curlhandle, CURLOPT_COOKIEJAR, config.sCookiePath.c_str()); curl_easy_setopt(curlhandle, CURLOPT_SSL_VERIFYPEER, config.bVerifyPeer); curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, config.bVerbose); curl_easy_setopt(curlhandle, CURLOPT_MAX_RECV_SPEED_LARGE, config.iDownloadRate); // Assume that we have connection error and abort transfer with CURLE_OPERATION_TIMEDOUT if download speed is less than 200 B/s for 30 seconds curl_easy_setopt(curlhandle, CURLOPT_LOW_SPEED_TIME, 30); curl_easy_setopt(curlhandle, CURLOPT_LOW_SPEED_LIMIT, 200); if (!config.sCACertPath.empty()) curl_easy_setopt(curlhandle, CURLOPT_CAINFO, config.sCACertPath.c_str()); } Website::~Website() { curl_easy_cleanup(curlhandle); } size_t Website::writeMemoryCallback(char *ptr, size_t size, size_t nmemb, void *userp) { std::ostringstream *stream = (std::ostringstream*)userp; size_t count = size * nmemb; stream->write(ptr, count); return count; } std::string Website::getResponse(const std::string& url) { std::ostringstream memory; std::string response; curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str()); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Website::writeMemoryCallback); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &memory); CURLcode result; do { if (config.iWait > 0) usleep(config.iWait); // Delay the request by specified time result = curl_easy_perform(curlhandle); response = memory.str(); memory.str(std::string()); } while ((result != CURLE_OK) && response.empty() && (this->retries++ < config.iRetries)); this->retries = 0; // reset retries counter if (result != CURLE_OK) { std::cout << curl_easy_strerror(result) << std::endl; if (result == CURLE_HTTP_RETURNED_ERROR) { long int response_code = 0; result = curl_easy_getinfo(curlhandle, CURLINFO_RESPONSE_CODE, &response_code); std::cout << "HTTP ERROR: "; if (result == CURLE_OK) std::cout << response_code << " (" << url << ")" << std::endl; else std::cout << "failed to get error code: " << curl_easy_strerror(result) << " (" << url << ")" << std::endl; } else if (result == CURLE_SSL_CACERT) { std::cout << "Try using CA certificate bundle from cURL: https://curl.haxx.se/ca/cacert.pem" << std::endl; std::cout << "Use --cacert to set the path for CA certificate bundle" << std::endl; } } return response; } Json::Value Website::getGameDetailsJSON(const std::string& gameid) { std::string gameDataUrl = "https://www.gog.com/account/gameDetails/" + gameid + ".json"; std::string json = this->getResponse(gameDataUrl); // Parse JSON Json::Value root; Json::Reader *jsonparser = new Json::Reader; if (!jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getGameDetailsJSON)" << std::endl << json << std::endl; #endif std::cout << jsonparser->getFormattedErrorMessages(); delete jsonparser; exit(1); } #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getGameDetailsJSON)" << std::endl << root << std::endl; #endif delete jsonparser; return root; } // Get list of games from account page std::vector Website::getGames() { std::vector games; Json::Value root; Json::Reader *jsonparser = new Json::Reader; int i = 1; bool bAllPagesParsed = false; do { std::string response = this->getResponse("https://www.gog.com/account/getFilteredProducts?hasHiddenProducts=false&hiddenFlag=0&isUpdated=0&mediaType=1&sortBy=title&system=&page=" + std::to_string(i)); // Parse JSON if (!jsonparser->parse(response, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getGames)" << std::endl << response << std::endl; #endif std::cout << jsonparser->getFormattedErrorMessages(); delete jsonparser; if (!response.empty()) { if(response[0] != '{') { // Response was not JSON. Assume that cookies have expired. std::cerr << "Response was not JSON. Cookies have most likely expired. Try --login first." << std::endl; } } exit(1); } #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getGames)" << std::endl << root << std::endl; #endif if (root["page"].asInt() == root["totalPages"].asInt()) bAllPagesParsed = true; if (root["products"].isArray()) { for (unsigned int i = 0; i < root["products"].size(); ++i) { std::cerr << "\033[KGetting game names " << "(" << root["page"].asInt() << "/" << root["totalPages"].asInt() << ") " << i+1 << " / " << root["products"].size() << "\r" << std::flush; Json::Value product = root["products"][i]; gameItem game; game.name = product["slug"].asString(); game.id = product["id"].isInt() ? std::to_string(product["id"].asInt()) : product["id"].asString(); game.updates = product["updates"].isInt() ? product["updates"].asInt() : std::stoi(product["updates"].asString()); unsigned int platform = 0; if (product["worksOn"]["Windows"].asBool()) platform |= GlobalConstants::PLATFORM_WINDOWS; if (product["worksOn"]["Mac"].asBool()) platform |= GlobalConstants::PLATFORM_MAC; if (product["worksOn"]["Linux"].asBool()) platform |= GlobalConstants::PLATFORM_LINUX; // Skip if platform doesn't match if (config.bPlatformDetection && !(platform & config.iInstallerPlatform)) continue; // Filter the game list if (!config.sGameRegex.empty()) { // GameRegex filter aliases if (config.sGameRegex == "all") config.sGameRegex = ".*"; boost::regex expression(config.sGameRegex); boost::match_results what; if (!boost::regex_search(game.name, what, expression)) // Check if name matches the specified regex continue; } if (config.bDLC) { int dlcCount = product["dlcCount"].asInt(); bool bDownloadDLCInfo = (dlcCount != 0); if (!bDownloadDLCInfo && !config.sIgnoreDLCCountRegex.empty()) { boost::regex expression(config.sIgnoreDLCCountRegex); boost::match_results what; if (boost::regex_search(game.name, what, expression)) // Check if name matches the specified regex { bDownloadDLCInfo = true; } } if (!bDownloadDLCInfo && !config.gamehasdlc.empty()) { if (config.gamehasdlc.isBlacklisted(game.name)) bDownloadDLCInfo = true; } // Check game specific config if (!config.bUpdateCache) // Disable game specific config files for cache update { gameSpecificConfig conf; conf.bIgnoreDLCCount = bDownloadDLCInfo; Util::getGameSpecificConfig(game.name, &conf); bDownloadDLCInfo = conf.bIgnoreDLCCount; } if (bDownloadDLCInfo && !config.sGameRegex.empty()) { // don't download unnecessary info if user is only interested in a subset of his account boost::regex expression(config.sGameRegex); boost::match_results what; if (!boost::regex_search(game.name, what, expression)) { bDownloadDLCInfo = false; } } if (bDownloadDLCInfo) { game.gamedetailsjson = this->getGameDetailsJSON(game.id); if (!game.gamedetailsjson.empty()) game.dlcnames = Util::getDLCNamesFromJSON(game.gamedetailsjson["dlcs"]); } } games.push_back(game); } } i++; } while (!bAllPagesParsed); std::cerr << std::endl; delete jsonparser; return games; } // Get list of free games std::vector Website::getFreeGames() { Json::Value root; Json::Reader *jsonparser = new Json::Reader; std::vector games; std::string json = this->getResponse("https://www.gog.com/games/ajax/filtered?mediaType=game&page=1&price=free&sort=title"); // Parse JSON if (!jsonparser->parse(json, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getFreeGames)" << std::endl << json << std::endl; #endif std::cout << jsonparser->getFormattedErrorMessages(); delete jsonparser; exit(1); } #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getFreeGames)" << std::endl << root << std::endl; #endif Json::Value products = root["products"]; for (unsigned int i = 0; i < products.size(); ++i) { gameItem game; game.name = products[i]["slug"].asString(); game.id = products[i]["id"].isInt() ? std::to_string(products[i]["id"].asInt()) : products[i]["id"].asString(); games.push_back(game); } delete jsonparser; return games; } // Login to GOG website int Website::Login(const std::string& email, const std::string& password) { int res = 0; std::string postdata; std::ostringstream memory; std::string token; std::string tagname_username; std::string tagname_password; std::string tagname_login; std::string tagname_token; // Get login token std::string html = this->getResponse("https://www.gog.com/"); htmlcxx::HTML::ParserDom parser; tree dom = parser.parseTree(html); tree::iterator it = dom.begin(); tree::iterator end = dom.end(); // Find auth_url bool bFoundAuthUrl = false; for (; it != end; ++it) { if (it->tagName()=="script") { std::string auth_url; for (unsigned int i = 0; i < dom.number_of_children(it); ++i) { tree::iterator script_it = dom.child(it, i); if (!script_it->isTag() && !script_it->isComment()) { if (script_it->text().find("GalaxyAccounts") != std::string::npos) { boost::match_results what; boost::regex expression(".*'(https://auth.gog.com/.*?)'.*"); boost::regex_match(script_it->text(), what, expression); auth_url = what[1]; break; } } } if (!auth_url.empty()) { // Found auth_url, get the necessary info for login bFoundAuthUrl = true; std::string login_form_html = this->getResponse(auth_url); #ifdef DEBUG std::cerr << "DEBUG INFO (Website::Login)" << std::endl; std::cerr << login_form_html << std::endl; #endif if (login_form_html.find("google.com/recaptcha") != std::string::npos) { std::cout << "Login form contains reCAPTCHA (https://www.google.com/recaptcha/)" << std::endl << "Login with browser and export cookies to \"" << config.sCookiePath << "\"" << std::endl; return res = 0; } tree login_dom = parser.parseTree(login_form_html); tree::iterator login_it = login_dom.begin(); tree::iterator login_it_end = login_dom.end(); for (; login_it != login_it_end; ++login_it) { if (login_it->tagName()=="input") { login_it->parseAttributes(); std::string id_login = login_it->attribute("id").second; if (id_login == "login_username") { tagname_username = login_it->attribute("name").second; } else if (id_login == "login_password") { tagname_password = login_it->attribute("name").second; } else if (id_login == "login__token") { token = login_it->attribute("value").second; // login token tagname_token = login_it->attribute("name").second; } } else if (login_it->tagName()=="button") { login_it->parseAttributes(); std::string id_login = login_it->attribute("id").second; if (id_login == "login_login") { tagname_login = login_it->attribute("name").second; } } } break; } } } if (!bFoundAuthUrl) { std::cout << "Failed to find url for login form" << std::endl; } if (token.empty()) { std::cout << "Failed to get login token" << std::endl; return res = 0; } //Create postdata - escape characters in email/password to support special characters postdata = (std::string)curl_easy_escape(curlhandle, tagname_username.c_str(), tagname_username.size()) + "=" + (std::string)curl_easy_escape(curlhandle, email.c_str(), email.size()) + "&" + (std::string)curl_easy_escape(curlhandle, tagname_password.c_str(), tagname_password.size()) + "=" + (std::string)curl_easy_escape(curlhandle, password.c_str(), password.size()) + "&" + (std::string)curl_easy_escape(curlhandle, tagname_login.c_str(), tagname_login.size()) + "=" + "&" + (std::string)curl_easy_escape(curlhandle, tagname_token.c_str(), tagname_token.size()) + "=" + (std::string)curl_easy_escape(curlhandle, token.c_str(), token.size()); curl_easy_setopt(curlhandle, CURLOPT_URL, "https://login.gog.com/login_check"); curl_easy_setopt(curlhandle, CURLOPT_POST, 1); curl_easy_setopt(curlhandle, CURLOPT_POSTFIELDS, postdata.c_str()); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Website::writeMemoryCallback); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &memory); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curlhandle, CURLOPT_MAXREDIRS, 0); curl_easy_setopt(curlhandle, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL); // Don't follow to redirect location because we need to check it for two step authorization. curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 0); CURLcode result = curl_easy_perform(curlhandle); memory.str(std::string()); if (result != CURLE_OK) { // Expected to hit maximum amount of redirects so don't print error on it if (result != CURLE_TOO_MANY_REDIRECTS) std::cout << curl_easy_strerror(result) << std::endl; } // Get redirect url char *redirect_url; curl_easy_getinfo(curlhandle, CURLINFO_REDIRECT_URL, &redirect_url); // Handle two step authorization if (std::string(redirect_url).find("two_step") != std::string::npos) { std::string security_code, tagname_two_step_send, tagname_two_step_auth_letter_1, tagname_two_step_auth_letter_2, tagname_two_step_auth_letter_3, tagname_two_step_auth_letter_4, tagname_two_step_token, token_two_step; std::string two_step_html = this->getResponse(redirect_url); redirect_url = NULL; tree two_step_dom = parser.parseTree(two_step_html); tree::iterator two_step_it = two_step_dom.begin(); tree::iterator two_step_it_end = two_step_dom.end(); for (; two_step_it != two_step_it_end; ++two_step_it) { if (two_step_it->tagName()=="input") { two_step_it->parseAttributes(); std::string id_two_step = two_step_it->attribute("id").second; if (id_two_step == "second_step_authentication_token_letter_1") { tagname_two_step_auth_letter_1 = two_step_it->attribute("name").second; } else if (id_two_step == "second_step_authentication_token_letter_2") { tagname_two_step_auth_letter_2 = two_step_it->attribute("name").second; } else if (id_two_step == "second_step_authentication_token_letter_3") { tagname_two_step_auth_letter_3 = two_step_it->attribute("name").second; } else if (id_two_step == "second_step_authentication_token_letter_4") { tagname_two_step_auth_letter_4 = two_step_it->attribute("name").second; } else if (id_two_step == "second_step_authentication__token") { token_two_step = two_step_it->attribute("value").second; // two step token tagname_two_step_token = two_step_it->attribute("name").second; } } else if (two_step_it->tagName()=="button") { two_step_it->parseAttributes(); std::string id_two_step = two_step_it->attribute("id").second; if (id_two_step == "second_step_authentication_send") { tagname_two_step_send = two_step_it->attribute("name").second; } } } std::cerr << "Security code: "; std::getline(std::cin,security_code); if (security_code.size() != 4) { std::cerr << "Security code must be 4 characters long" << std::endl; exit(1); } postdata = (std::string)curl_easy_escape(curlhandle, tagname_two_step_auth_letter_1.c_str(), tagname_two_step_auth_letter_1.size()) + "=" + security_code[0] + "&" + (std::string)curl_easy_escape(curlhandle, tagname_two_step_auth_letter_2.c_str(), tagname_two_step_auth_letter_2.size()) + "=" + security_code[1] + "&" + (std::string)curl_easy_escape(curlhandle, tagname_two_step_auth_letter_3.c_str(), tagname_two_step_auth_letter_3.size()) + "=" + security_code[2] + "&" + (std::string)curl_easy_escape(curlhandle, tagname_two_step_auth_letter_4.c_str(), tagname_two_step_auth_letter_4.size()) + "=" + security_code[3] + "&" + (std::string)curl_easy_escape(curlhandle, tagname_two_step_send.c_str(), tagname_two_step_send.size()) + "=" + "&" + (std::string)curl_easy_escape(curlhandle, tagname_two_step_token.c_str(), tagname_two_step_token.size()) + "=" + (std::string)curl_easy_escape(curlhandle, token_two_step.c_str(), token_two_step.size()); curl_easy_setopt(curlhandle, CURLOPT_URL, "https://login.gog.com/login/two_step"); curl_easy_setopt(curlhandle, CURLOPT_POST, 1); curl_easy_setopt(curlhandle, CURLOPT_POSTFIELDS, postdata.c_str()); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Website::writeMemoryCallback); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &memory); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curlhandle, CURLOPT_MAXREDIRS, 0); curl_easy_setopt(curlhandle, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL); // Don't follow to redirect location because it doesn't work properly. Must clean up the redirect url first. curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 0); result = curl_easy_perform(curlhandle); memory.str(std::string()); curl_easy_getinfo(curlhandle, CURLINFO_REDIRECT_URL, &redirect_url); } curl_easy_setopt(curlhandle, CURLOPT_URL, redirect_url); curl_easy_setopt(curlhandle, CURLOPT_HTTPGET, 1); curl_easy_setopt(curlhandle, CURLOPT_MAXREDIRS, -1); curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 1); result = curl_easy_perform(curlhandle); if (result != CURLE_OK) { std::cout << curl_easy_strerror(result) << std::endl; } if (this->IsLoggedInComplex(email)) { res = 1; // Login was successful } else { if (this->IsloggedInSimple()) res = 1; // Login was successful } if (res == 1) { curl_easy_setopt(curlhandle, CURLOPT_COOKIELIST, "FLUSH"); // Write all known cookies to the file specified by CURLOPT_COOKIEJAR } return res; } bool Website::IsLoggedIn() { return this->IsloggedInSimple(); } /* Complex login check. Check login by checking email address on the account settings page. returns true if we are logged in returns false if we are not logged in */ bool Website::IsLoggedInComplex(const std::string& email) { bool bIsLoggedIn = false; std::string html = this->getResponse("https://www.gog.com/account/settings/personal"); std::string email_lowercase = boost::algorithm::to_lower_copy(email); // boost::algorithm::to_lower does in-place modification but "email" is read-only so we need to make a copy of it htmlcxx::HTML::ParserDom parser; tree dom = parser.parseTree(html); tree::iterator it = dom.begin(); tree::iterator end = dom.end(); dom = parser.parseTree(html); it = dom.begin(); end = dom.end(); for (; it != end; ++it) { if (it->tagName()=="strong") { it->parseAttributes(); if (it->attribute("class").second == "settings-item__value settings-item__section") { for (unsigned int i = 0; i < dom.number_of_children(it); ++i) { tree::iterator tag_it = dom.child(it, i); if (!tag_it->isTag() && !tag_it->isComment()) { std::string tag_text = boost::algorithm::to_lower_copy(tag_it->text()); if (tag_text == email_lowercase) { bIsLoggedIn = true; // We are logged in break; } } } } } if (bIsLoggedIn) // We are logged in so no need to go through the remaining tags break; } return bIsLoggedIn; } /* Simple login check. Check login by trying to get account page. If response code isn't 200 then login failed. returns true if we are logged in returns false if we are not logged in */ bool Website::IsloggedInSimple() { bool bIsLoggedIn = false; std::ostringstream memory; std::string url = "https://www.gog.com/account"; long int response_code = 0; curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str()); curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 0); curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, Website::writeMemoryCallback); curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, &memory); curl_easy_setopt(curlhandle, CURLOPT_NOPROGRESS, 1); curl_easy_perform(curlhandle); memory.str(std::string()); curl_easy_getinfo(curlhandle, CURLINFO_RESPONSE_CODE, &response_code); curl_easy_setopt(curlhandle, CURLOPT_FOLLOWLOCATION, 1); if (response_code == 200) bIsLoggedIn = true; // We are logged in return bIsLoggedIn; } std::vector Website::getWishlistItems() { Json::Value root; Json::Reader *jsonparser = new Json::Reader; int i = 1; bool bAllPagesParsed = false; std::vector wishlistItems; do { std::string response = this->getResponse("https://www.gog.com/account/wishlist/search?hasHiddenProducts=false&hiddenFlag=0&isUpdated=0&mediaType=0&sortBy=title&system=&page=" + std::to_string(i)); // Parse JSON if (!jsonparser->parse(response, root)) { #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getWishlistItems)" << std::endl << response << std::endl; #endif std::cout << jsonparser->getFormattedErrorMessages(); delete jsonparser; exit(1); } #ifdef DEBUG std::cerr << "DEBUG INFO (Website::getWishlistItems)" << std::endl << root << std::endl; #endif if (root["page"].asInt() >= root["totalPages"].asInt()) bAllPagesParsed = true; if (root["products"].isArray()) { for (unsigned int i = 0; i < root["products"].size(); ++i) { wishlistItem item; Json::Value product = root["products"][i]; item.platform = 0; std::string platforms_text; bool bIsMovie = product["isMovie"].asBool(); if (!bIsMovie) { if (product["worksOn"]["Windows"].asBool()) item.platform |= GlobalConstants::PLATFORM_WINDOWS; if (product["worksOn"]["Mac"].asBool()) item.platform |= GlobalConstants::PLATFORM_MAC; if (product["worksOn"]["Linux"].asBool()) item.platform |= GlobalConstants::PLATFORM_LINUX; // Skip if platform doesn't match if (config.bPlatformDetection && !(item.platform & config.iInstallerPlatform)) continue; } if (product["isComingSoon"].asBool()) item.tags.push_back("Coming soon"); if (product["isDiscounted"].asBool()) item.tags.push_back("Discount"); if (bIsMovie) item.tags.push_back("Movie"); item.release_date_time = 0; if (product.isMember("releaseDate") && product["isComingSoon"].asBool()) { if (!product["releaseDate"].empty()) { if (product["releaseDate"].isInt()) { item.release_date_time = product["releaseDate"].asInt(); } else { std::string release_date_time_string = product["releaseDate"].asString(); if (!release_date_time_string.empty()) { try { item.release_date_time = std::stoi(release_date_time_string); } catch (std::invalid_argument& e) { item.release_date_time = 0; } } } } } item.currency = product["price"]["symbol"].asString(); item.price = product["price"]["finalAmount"].isDouble() ? std::to_string(product["price"]["finalAmount"].asDouble()) + item.currency : product["price"]["finalAmount"].asString() + item.currency; item.discount_percent = product["price"]["discountPercentage"].isInt() ? std::to_string(product["price"]["discountPercentage"].asInt()) + "%" : product["price"]["discountPercentage"].asString() + "%"; item.discount = product["price"]["discountDifference"].isDouble() ? std::to_string(product["price"]["discountDifference"].asDouble()) + item.currency : product["price"]["discountDifference"].asString() + item.currency; item.store_credit = product["price"]["bonusStoreCreditAmount"].isDouble() ? std::to_string(product["price"]["bonusStoreCreditAmount"].asDouble()) + item.currency : product["price"]["bonusStoreCreditAmount"].asString() + item.currency; item.url = product["url"].asString(); if (item.url.find("/game/") == 0) item.url = "https://www.gog.com" + item.url; else if (item.url.find("/movie/") == 0) item.url = "https://www.gog.com" + item.url; item.title = product["title"].asString(); item.bIsBonusStoreCreditIncluded = product["price"]["isBonusStoreCreditIncluded"].asBool(); item.bIsDiscounted = product["isDiscounted"].asBool(); wishlistItems.push_back(item); } } i++; } while (!bAllPagesParsed); delete jsonparser; return wishlistItems; } void Website::setConfig(Config &conf) { this->config = conf; }