support CURLOPT_XFERINFOFUNCTION, add callback wrapper for both methods

vgmoose · vgmoose · commit 9886d5c73346 · 2025-11-23T23:05:59.000-05:00
diff --git a/src/Get.cpp b/src/Get.cpp
@@ -72,7 +72,7 @@ int Get::install(Package& package, bool resume)
 	printf("--> Downloaded [%s] to sdroot/\n", package.getPackageName().c_str());
 
 	// clear any progress callbacks before updating repo metadata
-	extern int (*networking_callback)(void*, double, double, double, double);
+	extern libget_progress_callback_t networking_callback;
 	extern void* networking_callback_data;
 	networking_callback = nullptr;
 	networking_callback_data = nullptr;
diff --git a/src/Package.cpp b/src/Package.cpp
@@ -201,7 +201,7 @@ bool Package::install(const std::string& pkg_path, const std::string& tmp_path)
 		libget_status_callback(STATUS_ANALYZING, 1, 1);
 
 	if (networking_callback != nullptr)
-		networking_callback(nullptr, 10, 10, 0, 0);
+		networking_callback(nullptr, 1.0);
 
 	std::string downloadedFilePath = tmp_path + this->pkg_name + getUrlFileExt();
 
@@ -349,8 +349,10 @@ bool Package::install(const std::string& pkg_path, const std::string& tmp_path)
 		const auto& entries = manifest.getEntries();
 		for (const auto& entry : entries)
 		{
-			if (networking_callback != nullptr)
-				networking_callback(nullptr, entries.size(), i + 1, 0, 0);
+			if (networking_callback != nullptr) {
+				double progress = (double)(i + 1) / (double)entries.size();
+				networking_callback(nullptr, progress);
+			}
 
 			i++;
 
@@ -480,8 +482,10 @@ bool Package::remove(std::string_view pkg_path)
 		const auto& entries = manifest.getEntries();
 		for (const auto& entry : entries)
 		{
-			if (networking_callback != nullptr)
-				networking_callback(nullptr, entries.size(), i + 1, 0, 0);
+			if (networking_callback != nullptr) {
+				double progress = (double)(i + 1) / (double)entries.size();
+				networking_callback(nullptr, progress);
+			}
 			i++;
 			const std::string& DeletePath = entry.path;
 
diff --git a/src/Utils.cpp b/src/Utils.cpp
@@ -1,6 +1,14 @@
 // operating system level utilities
 // contains directory utils, http utils, and helper methods
 
+// CURLOPT_PROGRESSFUNCTION deprecated in 7.32.0 and is replaced with CURLOPT_XFERINFOFUNCTION
+#include <curl/curl.h>
+#if LIBCURL_VERSION_NUM >= 0x072000
+	#define COMPAT_CURL_PROGRESS_OPTION CURLOPT_XFERINFOFUNCTION
+#else
+	#define COMPAT_CURL_PROGRESS_OPTION CURLOPT_PROGRESSFUNCTION
+#endif
+
 #if defined(WII) && !defined(NETWORK_MOCK)
 #include <wiisocket.h>
 #endif
@@ -48,12 +56,31 @@
 
 #define BUF_SIZE 0x800000 // 8MB.
 
-int (*networking_callback)(void*, double, double, double, double);
-int (*libget_status_callback)(int, int, int);
+libget_progress_callback_t networking_callback = nullptr;
+int (*libget_status_callback)(int, int, int) = nullptr;
 void* networking_callback_data = nullptr; // User data to pass to callback
 
 static const char* USER_AGENT = "libget-unknown/0.0.0";
 
+// different signature depending on curl version
+#ifndef NETWORK_MOCK
+#if LIBCURL_VERSION_NUM >= 0x072000
+static int libget_curl_progress_wrapper(void* /*clientp*/, curl_off_t dltotal, curl_off_t dlnow, curl_off_t, curl_off_t)
+#else
+static int libget_curl_progress_wrapper(void* /*clientp*/, double dltotal, double dlnow, double, double)
+#endif
+{
+	if (networking_callback == nullptr)
+		return 0;
+	
+	if (dltotal == 0)
+		dltotal = 1;
+	
+	double progress = (double)dlnow / (double)dltotal;
+	return networking_callback(networking_callback_data, progress);
+}
+#endif
+
 // reference to the curl handle so that we can re-use the connection
 #ifndef NETWORK_MOCK
 CURL* curl = nullptr;
@@ -181,7 +208,7 @@ void resetCurlToCleanState(CURL* c)
 	if (!c) return;
 		
 	// clear callbacks which might reference freed objects
-	curl_easy_setopt(c, CURLOPT_PROGRESSFUNCTION, nullptr);
+	curl_easy_setopt(c, COMPAT_CURL_PROGRESS_OPTION, nullptr);
 	curl_easy_setopt(c, CURLOPT_PROGRESSDATA, nullptr);
 	curl_easy_setopt(c, CURLOPT_NOPROGRESS, 1);
 	
@@ -274,12 +301,12 @@ bool downloadFileCommon(const std::string& path, std::string* buffer = nullptr,
 	
 	if (networking_callback != nullptr) {
 		printf("[downloadFileCommon] Setting progress callback (networking_callback=%p)\n", networking_callback);
-		curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, networking_callback);
-		curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, networking_callback_data);
+		curl_easy_setopt(curl, COMPAT_CURL_PROGRESS_OPTION, libget_curl_progress_wrapper);
+		curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, curl);
 		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
 	} else {
 		printf("[downloadFileCommon] Disabling progress callbacks (networking_callback is nullptr)\n");
-		curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, nullptr);
+		curl_easy_setopt(curl, COMPAT_CURL_PROGRESS_OPTION, nullptr);
 		curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, nullptr);
 		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
 	}
diff --git a/src/Utils.hpp b/src/Utils.hpp
@@ -56,9 +56,12 @@ int my_mkdir(const std::string& path, int perms = 0700);
 char* my_strptime(const char* s, const char* f, struct tm* tm);
 
 
+// curl callback wrapper, progress is between 0 and 1 (inclusive)
+typedef int (*libget_progress_callback_t)(void* clientp, double progress);
+
 // callback for networking progress
 // if set, will be invoked during the download
-extern int (*networking_callback)(void*, double, double, double, double);
+extern libget_progress_callback_t networking_callback;
 extern int (*libget_status_callback)(int, int, int);
 extern void* networking_callback_data; // User data to pass to networking_callback
 void setUserAgent(const char* data);
diff --git a/src/libs/minizip/crypt.h b/src/libs/minizip/crypt.h
@@ -38,6 +38,7 @@ static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
                      * unpredictable manner on 16-bit systems; not a problem
                      * with any known compiler so far, though */
 
+    (void)pcrc_32_tab;  // unused
     temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
     return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
 }
diff --git a/src/libs/minizip/ioapi.c b/src/libs/minizip/ioapi.c
@@ -96,6 +96,7 @@ static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, in
 {
     FILE* file = NULL;
     const char* mode_fopen = NULL;
+    (void)opaque;
     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
         mode_fopen = "rb";
     else
@@ -114,6 +115,7 @@ static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename,
 {
     FILE* file = NULL;
     const char* mode_fopen = NULL;
+    (void)opaque;
     if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
         mode_fopen = "rb";
     else
@@ -132,20 +134,23 @@ static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename,
 static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
 {
     uLong ret;
+    (void)opaque;
     ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
     return ret;
 }
 
 static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
 {
     uLong ret;
+    (void)opaque;
     ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
     return ret;
 }
 
 static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
 {
     long ret;
+    (void)opaque;
     ret = ftell((FILE *)stream);
     return ret;
 }
@@ -154,6 +159,7 @@ static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
 static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
 {
     ZPOS64_T ret;
+    (void)opaque;
     ret = FTELLO_FUNC((FILE *)stream);
     return ret;
 }
@@ -162,6 +168,7 @@ static long ZCALLBACK fseek_file_func (voidpf  opaque, voidpf stream, uLong offs
 {
     int fseek_origin=0;
     long ret;
+    (void)opaque;
     switch (origin)
     {
     case ZLIB_FILEFUNC_SEEK_CUR :
@@ -185,6 +192,7 @@ static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T
 {
     int fseek_origin=0;
     long ret;
+    (void)opaque;
     switch (origin)
     {
     case ZLIB_FILEFUNC_SEEK_CUR :
@@ -210,13 +218,15 @@ static long ZCALLBACK fseek64_file_func (voidpf  opaque, voidpf stream, ZPOS64_T
 static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
 {
     int ret;
+    (void)opaque;
     ret = fclose((FILE *)stream);
     return ret;
 }
 
 static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
 {
     int ret;
+    (void)opaque;
     ret = ferror((FILE *)stream);
     return ret;
 }
diff --git a/src/libs/tinyxml/tinyxmlparser.cpp b/src/libs/tinyxml/tinyxmlparser.cpp
@@ -111,14 +111,17 @@ void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* leng
 			--output; 
 			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
 			input >>= 6;
+			/* fall through */
 		case 3:
 			--output; 
 			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
 			input >>= 6;
+			/* fall through */
 		case 2:
 			--output; 
 			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
 			input >>= 6;
+			/* fall through */
 		case 1:
 			--output; 
 			*output = (char)(input | FIRST_BYTE_MARK[*length]);
diff --git a/src/repos/GetRepo.cpp b/src/repos/GetRepo.cpp
@@ -71,8 +71,10 @@ std::vector<std::unique_ptr<Package>> GetRepo::loadPackages()
 	auto total = packages_doc.Size();
 	for (int i = 0; i < (int)total; i++)
 	{
-		if (networking_callback != nullptr)
-			networking_callback(nullptr, total, i + 1, 0, 0);
+		if (networking_callback != nullptr) {
+			double progress = (double)(i + 1) / (double)total;
+			networking_callback(nullptr, progress);
+		}
 
 		auto package = std::make_unique<Package>(GET);
 
diff --git a/src/repos/OSCRepo.cpp b/src/repos/OSCRepo.cpp
@@ -68,10 +68,12 @@ std::vector<std::unique_ptr<Package>> OSCRepo::loadPackages()
 
 	// for every repo
 	auto total = (int32_t)packages_doc.Size();
-	for (int i = 0; i < total; i++)
+	for (int32_t i = 0; i < total; i++)
 	{
-		if (networking_callback != nullptr)
-			networking_callback(nullptr, total, i + 1, 0, 0);
+		if (networking_callback != nullptr) {
+			double progress = (double)(i + 1) / (double)total;
+			networking_callback(nullptr, progress);
+		}
 
 		auto package = std::make_unique<Package>(GET);
 
diff --git a/src/repos/UniStoreRepo.cpp b/src/repos/UniStoreRepo.cpp
@@ -69,10 +69,12 @@ std::vector<std::unique_ptr<Package>> UniStoreRepo::loadPackages()
 
 	// for every package in the repo
 	auto total = (int32_t)packages_doc.Size();
-	for (int i = 0; i < total; i++)
+	for (int32_t i = 0; i < total; i++)
 	{
-		if (networking_callback != nullptr)
-			networking_callback(nullptr, total, i + 1, 0, 0);
+		if (networking_callback != nullptr) {
+			double progress = (double)(i + 1) / (double)total;
+			networking_callback(nullptr, progress);
+		}
 		
 		std::vector<std::string> keys;
 		auto start = packages_doc[i].GetObj().MemberBegin();
diff --git a/tests/14_LargeDownloadProgressTest.hpp b/tests/14_LargeDownloadProgressTest.hpp
@@ -7,49 +7,43 @@
 #include <ctime>
 
 struct ProgressTracker {
-	std::vector<double> downloadedBytes;
-	std::vector<double> totalBytes;
+	std::vector<double> progressValues;
 	bool downloadFinished = false;
 	int callCount = 0;
 	bool sequentialCheck = true;
 	
 	void reset() {
-		downloadedBytes.clear();
-		totalBytes.clear();
+		progressValues.clear();
 		downloadFinished = false;
 		callCount = 0;
 		sequentialCheck = true;
 	}
 	
 	bool isSequential() const {
-		// ensure that downloaded bytes aren't going in the wrong direction
-		for (size_t i = 1; i < downloadedBytes.size(); i++) {
-			if (downloadedBytes[i] < downloadedBytes[i-1]) {
+		// ensure that progress isn't going backwards
+		for (size_t i = 1; i < progressValues.size(); i++) {
+			if (progressValues[i] < progressValues[i-1]) {
 				return false;
 			}
 		}
 		return true;
 	}
 	
 	bool wasCompleted() const {
-		// check if we reached 100% in updates, or very close
-		if (downloadedBytes.empty() || totalBytes.empty()) return false;
-		double lastDownloaded = downloadedBytes.back();
-		double lastTotal = totalBytes.back();
-		if (lastTotal <= 0) return false;
-		double percent = (lastDownloaded / lastTotal) * 100.0;
-		return percent >= 99.0;
+		// check if we reached 100% (or very close) in updates
+		if (progressValues.empty()) return false;
+		double lastProgress = progressValues.back();
+		return lastProgress >= 0.99;
 	}
 } progressTracker;
 
-int testProgressCallback(void*, double dltotal, double dlnow, double, double) {
+int testProgressCallback(void*, double progress) {
 	progressTracker.callCount++;
-	progressTracker.downloadedBytes.push_back(dlnow);
-	progressTracker.totalBytes.push_back(dltotal);
+	progressTracker.progressValues.push_back(progress);
 	
-	if (progressTracker.downloadedBytes.size() > 1) {
-		size_t idx = progressTracker.downloadedBytes.size() - 1;
-		if (progressTracker.downloadedBytes[idx] < progressTracker.downloadedBytes[idx-1]) {
+	if (progressTracker.progressValues.size() > 1) {
+		size_t idx = progressTracker.progressValues.size() - 1;
+		if (progressTracker.progressValues[idx] < progressTracker.progressValues[idx-1]) {
 			progressTracker.sequentialCheck = false;
 		}
 	}
@@ -227,10 +221,9 @@ class LargeDownloadProgressTest : public Test {
 		
 		if (!progressTracker.wasCompleted()) {
 			error << "Progress did not reach completion" << endl;
-			if (!progressTracker.downloadedBytes.empty() && !progressTracker.totalBytes.empty()) {
-				double lastDl = progressTracker.downloadedBytes.back();
-				double lastTotal = progressTracker.totalBytes.back();
-				cout << "  Last progress: " << lastDl << " / " << lastTotal << " bytes" << endl;
+			if (!progressTracker.progressValues.empty()) {
+				double lastProgress = progressTracker.progressValues.back();
+				cout << "  Last progress: " << (lastProgress * 100.0) << "%" << endl;
 			}
 			return false;
 		}

Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,7 @@ static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)`
`38`	`38`	`* unpredictable manner on 16-bit systems; not a problem`
`39`	`39`	`* with any known compiler so far, though */`
`40`	`40`
	`41`	`+ (void)pcrc_32_tab; // unused`
`41`	`42`	`temp = ((unsigned)(*(pkeys+2)) & 0xffff) \| 2;`
`42`	`43`	`return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);`
`43`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,6 +96,7 @@ static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, in`
`96`	`96`	`{`
`97`	`97`	`FILE* file = NULL;`
`98`	`98`	`const char* mode_fopen = NULL;`
	`99`	`+ (void)opaque;`
`99`	`100`	`if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)`
`100`	`101`	`mode_fopen = "rb";`
`101`	`102`	`else`
`@@ -114,6 +115,7 @@ static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename,`
`114`	`115`	`{`
`115`	`116`	`FILE* file = NULL;`
`116`	`117`	`const char* mode_fopen = NULL;`
	`118`	`+ (void)opaque;`
`117`	`119`	`if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)`
`118`	`120`	`mode_fopen = "rb";`
`119`	`121`	`else`
`@@ -132,20 +134,23 @@ static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename,`
`132`	`134`	`static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)`
`133`	`135`	`{`
`134`	`136`	`uLong ret;`
	`137`	`+ (void)opaque;`
`135`	`138`	`ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);`
`136`	`139`	`return ret;`
`137`	`140`	`}`
`138`	`141`
`139`	`142`	`static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)`
`140`	`143`	`{`
`141`	`144`	`uLong ret;`
	`145`	`+ (void)opaque;`
`142`	`146`	`ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);`
`143`	`147`	`return ret;`
`144`	`148`	`}`
`145`	`149`
`146`	`150`	`static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)`
`147`	`151`	`{`
`148`	`152`	`long ret;`
	`153`	`+ (void)opaque;`
`149`	`154`	`ret = ftell((FILE *)stream);`
`150`	`155`	`return ret;`
`151`	`156`	`}`
`@@ -154,6 +159,7 @@ static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)`
`154`	`159`	`static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)`
`155`	`160`	`{`
`156`	`161`	`ZPOS64_T ret;`
	`162`	`+ (void)opaque;`
`157`	`163`	`ret = FTELLO_FUNC((FILE *)stream);`
`158`	`164`	`return ret;`
`159`	`165`	`}`
`@@ -162,6 +168,7 @@ static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offs`
`162`	`168`	`{`
`163`	`169`	`int fseek_origin=0;`
`164`	`170`	`long ret;`
	`171`	`+ (void)opaque;`
`165`	`172`	`switch (origin)`
`166`	`173`	`{`
`167`	`174`	`case ZLIB_FILEFUNC_SEEK_CUR :`
`@@ -185,6 +192,7 @@ static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T`
`185`	`192`	`{`
`186`	`193`	`int fseek_origin=0;`
`187`	`194`	`long ret;`
	`195`	`+ (void)opaque;`
`188`	`196`	`switch (origin)`
`189`	`197`	`{`
`190`	`198`	`case ZLIB_FILEFUNC_SEEK_CUR :`
`@@ -210,13 +218,15 @@ static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T`
`210`	`218`	`static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)`
`211`	`219`	`{`
`212`	`220`	`int ret;`
	`221`	`+ (void)opaque;`
`213`	`222`	`ret = fclose((FILE *)stream);`
`214`	`223`	`return ret;`
`215`	`224`	`}`
`216`	`225`
`217`	`226`	`static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)`
`218`	`227`	`{`
`219`	`228`	`int ret;`
	`229`	`+ (void)opaque;`
`220`	`230`	`ret = ferror((FILE *)stream);`
`221`	`231`	`return ret;`
`222`	`232`	`}`