Fix all compiler warnings from strict flags (-Wall -Wextra -Wconversion -Werror)

- Add (void) casts for unused function parameters
- Fix sign conversion warnings with explicit casts
- Change variable types to match library function signatures
- Fix format string specifiers (%d -> %zu, %lu -> %lld)
- Add __attribute__((unused)) to static functions not currently used
- Replace sprintf with snprintf for buffer safety
- Fix strncpy to ensure null termination
- Add version check for deprecated g_spawn_check_exit_status
- Add missing return statement in archToName()
- Fix sign comparison warnings by adding explicit casts

All changes maintain correctness while satisfying strict compiler warnings.

Co-authored-by: probonopd <[email protected]>

Author: Copilot

src/appimagetool.c

@@ -123,7 +123,7 @@ int sfs_mksquashfs(char *source, char *destination, int offset) {
 
         guint sqfs_opts_len = sqfs_opts ? g_strv_length(sqfs_opts) : 0;
 
-        int max_num_args = sqfs_opts_len + 22;
+        int max_num_args = (int)sqfs_opts_len + 22;
         char* args[max_num_args];
 
         int i = 0;
@@ -270,9 +270,9 @@ static void replacestr(char *line, const char *search, const char *replace)
     if ((sp = strstr(line, search)) == NULL) {
         return;
     }
-    int search_len = strlen(search);
-    int replace_len = strlen(replace);
-    int tail_len = strlen(sp+search_len);
+    size_t search_len = strlen(search);
+    size_t replace_len = strlen(replace);
+    size_t tail_len = strlen(sp+search_len);
 
     memmove(sp+replace_len,sp+search_len,tail_len+1);
     memcpy(sp, replace, replace_len);
@@ -304,6 +304,8 @@ gchar* archToName(fARCH arch) {
         case fARCH_x86_64:
             return "x86_64";
     }
+    // Should never reach here if all enum values are handled
+    return "unknown";
 }
 
 gchar* getArchName(bool* archs) {
@@ -464,10 +466,10 @@ bool readFile(char* filename, size_t* size, char** buffer) {
     long fsize = ftell(f);
     fseek(f, 0, SEEK_SET);
 
-    char *indata = malloc(fsize);
-    fread(indata, fsize, 1, f);
+    char *indata = malloc((size_t)fsize);
+    fread(indata, (size_t)fsize, 1, f);
     fclose(f);
-    *size = (int)fsize;
+    *size = (size_t)fsize;
     *buffer = indata; 
     return TRUE;
 }
@@ -694,7 +696,11 @@ main (int argc, char *argv[])
                     g_spawn_command_line_sync(command_line, &out, NULL, &exit_status, &error);
 
                     // g_spawn_command_line_sync might have set error already, in that case we don't want to overwrite
+#if GLIB_CHECK_VERSION(2, 70, 0)
+                    if (error != NULL || !g_spawn_check_wait_status(exit_status, &error)) {
+#else
                     if (error != NULL || !g_spawn_check_exit_status(exit_status, &error)) {
+#endif
                         if (error == NULL) {
                             g_printerr("Failed to run 'git rev-parse --short HEAD, but failed to interpret GLib error state: %d\n", exit_status);
                         } else {
@@ -776,7 +782,8 @@ main (int argc, char *argv[])
             const char* const env_app_name = getenv("APPIMAGETOOL_APP_NAME");
             if (env_app_name != NULL) {
                 fprintf(stderr, "Using user-specified app name: %s\n", env_app_name);
-                strncpy(app_name_for_filename, env_app_name, PATH_MAX);
+                strncpy(app_name_for_filename, env_app_name, PATH_MAX - 1);
+                app_name_for_filename[PATH_MAX - 1] = '\0';
             } else {
                 const gchar* const desktop_file_app_name = get_desktop_entry(kf, "Name");
                 sprintf(app_name_for_filename, "%s", desktop_file_app_name);
@@ -797,9 +804,9 @@ main (int argc, char *argv[])
 
             // if $VERSION is specified, we embed it into the filename
             if (version_env != NULL) {
-                sprintf(dest_path, "%s-%s-%s.AppImage", app_name_for_filename, version_env, arch);
+                snprintf(dest_path, sizeof(dest_path), "%s-%s-%s.AppImage", app_name_for_filename, version_env, arch);
             } else {
-                sprintf(dest_path, "%s-%s.AppImage", app_name_for_filename, arch);
+                snprintf(dest_path, sizeof(dest_path), "%s-%s.AppImage", app_name_for_filename, arch);
             }
 
             destination = strdup(dest_path);
@@ -922,9 +929,9 @@ main (int argc, char *argv[])
             }
         }
         if (verbose)
-            printf("Size of the embedded runtime: %d bytes\n", size);
-        
-        int result = sfs_mksquashfs(source, destination, size);
+            printf("Size of the embedded runtime: %zu bytes\n", size);
+
+        int result = sfs_mksquashfs(source, destination, (int)size);
         if(result != 0)
             die("sfs_mksquashfs error");
 
@@ -961,7 +968,7 @@ main (int argc, char *argv[])
                         int ret = snprintf(buf, sizeof(buf), "gh-releases-zsync|%s|%s|latest|%s*-%s.AppImage.zsync", github_repository_owner, github_repository_name, app_name_for_filename, arch);
                         if (ret < 0) {
                             die("snprintf error");
-                        } else if (ret >= sizeof(buf)) {
+                        } else if ((size_t)ret >= sizeof(buf)) {
                             die("snprintf buffer overflow");
                         }
                         updateinformation = buf;
@@ -996,7 +1003,7 @@ main (int argc, char *argv[])
                         int ret = snprintf(buf, sizeof(buf), "gh-releases-zsync|%s|%s|%s|%s*-%s.AppImage.zsync", parts[0], parts[1], channel, app_name_for_filename, arch);
                         if (ret < 0) {
                             die("snprintf error");
-                        } else if (ret >= sizeof(buf)) {
+                        } else if ((size_t)ret >= sizeof(buf)) {
                             die("snprintf buffer overflow");
                         }
                         updateinformation = buf;
@@ -1014,7 +1021,7 @@ main (int argc, char *argv[])
                     int ret = snprintf(buf, sizeof(buf), "zsync|%s/-/jobs/artifacts/%s/raw/%s-%s.AppImage.zsync?job=%s", CI_PROJECT_URL, CI_COMMIT_REF_NAME, app_name_for_filename, arch, CI_JOB_NAME);
                     if (ret < 0) {
                         die("snprintf error");
-                    } else if (ret >= sizeof(buf)) {
+                    } else if ((size_t)ret >= sizeof(buf)) {
                         die("snprintf buffer overflow");
                     }
                     updateinformation = buf;
@@ -1061,7 +1068,7 @@ main (int argc, char *argv[])
                 FILE *fpdst2 = fopen(destination, "r+");
                 if (fpdst2 == NULL)
                     die("Not able to open the destination file for writing, aborting");
-                fseek(fpdst2, ui_offset, SEEK_SET);
+                fseek(fpdst2, (long)ui_offset, SEEK_SET);
                 // fseek(fpdst2, ui_offset, SEEK_SET);
                 // fwrite(0x00, 1, 1024, fpdst); // FIXME: Segfaults; why?
                 // fseek(fpdst, ui_offset, SEEK_SET);
@@ -1107,7 +1114,7 @@ main (int argc, char *argv[])
                 die("Failed to open AppImage for updating");
             }
 
-            if (fseek(destinationfp, digest_md5_offset, SEEK_SET) != 0) {
+            if (fseek(destinationfp, (long)digest_md5_offset, SEEK_SET) != 0) {
                 fclose(destinationfp);
                 die("Failed to embed MD5 digest: could not seek to section offset");
             }
@@ -1141,7 +1148,7 @@ main (int argc, char *argv[])
 
                 if (verbose) {
                     fprintf(stderr, "Running zsyncmake process: ");
-                    for (gint j = 0; j < (sizeof(zsyncmake_command) / sizeof(char*) - 1); ++j) {
+                    for (gint j = 0; j < (gint)(sizeof(zsyncmake_command) / sizeof(char*) - 1); ++j) {
                         fprintf(stderr, "'%s' ", zsyncmake_command[j]);
                     }
                     fprintf(stderr, "\n");

src/appimagetool_fetch_runtime.cpp

@@ -281,15 +281,15 @@ bool fetch_runtime(char *arch, size_t *size, char **buffer, bool verbose) {
 
         auto runtimeData = response.data();
 
-        if (runtimeData.size() != response.contentLength()) {
+        if (runtimeData.size() != static_cast<std::vector<char>::size_type>(response.contentLength())) {
             std::cerr << "Error: downloaded data size of " << runtimeData.size()
                       << " does not match content-length of " << response.contentLength() << std::endl;
             return false;
         }
 
-        *size = response.contentLength();
+        *size = static_cast<size_t>(response.contentLength());
 
-        *buffer = (char *) calloc(response.contentLength() + 1, 1);
+        *buffer = (char *) calloc(static_cast<size_t>(response.contentLength()) + 1, 1);
 
         if (*buffer == nullptr) {
             std::cerr << "Failed to allocate buffer" << std::endl;

src/appimagetool_sign.c

@@ -20,6 +20,7 @@ char* get_passphrase_from_environment() {
 }
 
 gpgme_error_t gpgme_passphrase_callback(void* hook, const char* uid_hint, const char* passphrase_info, int prev_was_valid, int fd) {
+    (void) hook;
     (void) passphrase_info;
     (void) prev_was_valid;
 
@@ -45,6 +46,7 @@ gpgme_error_t gpgme_passphrase_callback(void* hook, const char* uid_hint, const
 }
 
 gpgme_error_t gpgme_status_callback(void* hook, const char* keyword, const char* args) {
+    (void) hook;
     assert(hook == gpgme_hook);
 
     fprintf(stderr, "[gpgme] %s: %s\n", keyword, args);
@@ -221,7 +223,7 @@ bool embed_data_in_elf_section(const char* filename, const char* elf_section, gp
         return false;
     }
 
-    if (data_size > key_section_length) {
+    if ((unsigned long)data_size > key_section_length) {
         fprintf(stderr, "[sign] cannot embed key in AppImage: size exceeds reserved ELF section size\n");
         gpg_release_resources();
         return false;
@@ -231,10 +233,10 @@ bool embed_data_in_elf_section(const char* filename, const char* elf_section, gp
     char data_buffer[data_size];
 
     size_t total_bytes_read = 0;
-    size_t bytes_read = 0;
+    ssize_t bytes_read = 0;
 
     for (;;) {
-        bytes_read = gpgme_data_read(data, data_buffer, data_size);
+        bytes_read = gpgme_data_read(data, data_buffer + total_bytes_read, (size_t)(data_size - (off_t)total_bytes_read));
 
         // EOF
         if (bytes_read == 0) {
@@ -248,15 +250,15 @@ bool embed_data_in_elf_section(const char* filename, const char* elf_section, gp
             return false;
         }
 
-        total_bytes_read += bytes_read;
+        total_bytes_read += (size_t)bytes_read;
     }
 
-    if (total_bytes_read != data_size) {
+    if ((off_t)total_bytes_read != data_size) {
         fprintf(
             stderr,
-            "[sign] failed to read entire data from data object (%lu != %lu)\n",
+            "[sign] failed to read entire data from data object (%zu != %lld)\n",
             total_bytes_read,
-            data_size
+            (long long)data_size
         );
         gpg_release_resources();
         return false;
@@ -278,7 +280,7 @@ bool embed_data_in_elf_section(const char* filename, const char* elf_section, gp
     }
 
     // write at once
-    if (fwrite(data_buffer, sizeof(char), data_size, destinationfp) != data_size) {
+    if (fwrite(data_buffer, sizeof(char), (size_t)data_size, destinationfp) != (size_t)data_size) {
         fprintf(stderr, "[sign] failed to write signature to AppImage file\n");
         gpg_release_resources();
         fclose(destinationfp);

src/elf.c

@@ -47,17 +47,18 @@ static uint64_t file64_to_cpu(uint64_t val)
     return val;
 }
 
+__attribute__((unused))
 static off_t read_elf32(FILE* fd)
 {
     Elf32_Ehdr ehdr32;
     Elf32_Shdr shdr32;
     off_t last_shdr_offset;
-    ssize_t ret;
+    size_t ret;
     off_t  sht_end, last_section_end;
 
     fseeko(fd, 0, SEEK_SET);
     ret = fread(&ehdr32, 1, sizeof(ehdr32), fd);
-    if (ret < 0 || (size_t)ret != sizeof(ehdr32)) {
+    if (ret != sizeof(ehdr32)) {
         fprintf(stderr, "Read of ELF header from %s failed: %s\n",
                 fname, strerror(errno));
         return -1;
@@ -67,32 +68,33 @@ static off_t read_elf32(FILE* fd)
     ehdr.e_shentsize	= file16_to_cpu(ehdr32.e_shentsize);
     ehdr.e_shnum		= file16_to_cpu(ehdr32.e_shnum);
 
-    last_shdr_offset = ehdr.e_shoff + (ehdr.e_shentsize * (ehdr.e_shnum - 1));
+    last_shdr_offset = (off_t)(ehdr.e_shoff + ((uint64_t)ehdr.e_shentsize * (ehdr.e_shnum - 1)));
     fseeko(fd, last_shdr_offset, SEEK_SET);
     ret = fread(&shdr32, 1, sizeof(shdr32), fd);
-    if (ret < 0 || (size_t)ret != sizeof(shdr32)) {
+    if (ret != sizeof(shdr32)) {
         fprintf(stderr, "Read of ELF section header from %s failed: %s\n",
                 fname, strerror(errno));
         return -1;
     }
 
     /* ELF ends either with the table of section headers (SHT) or with a section. */
-    sht_end = ehdr.e_shoff + (ehdr.e_shentsize * ehdr.e_shnum);
-    last_section_end = file64_to_cpu(shdr32.sh_offset) + file64_to_cpu(shdr32.sh_size);
+    sht_end = (off_t)(ehdr.e_shoff + ((uint64_t)ehdr.e_shentsize * ehdr.e_shnum));
+    last_section_end = (off_t)(file64_to_cpu(shdr32.sh_offset) + file64_to_cpu(shdr32.sh_size));
     return sht_end > last_section_end ? sht_end : last_section_end;
 }
 
+__attribute__((unused))
 static off_t read_elf64(FILE* fd)
 {
     Elf64_Ehdr ehdr64;
     Elf64_Shdr shdr64;
     off_t last_shdr_offset;
-    off_t ret;
+    size_t ret;
     off_t sht_end, last_section_end;
 
     fseeko(fd, 0, SEEK_SET);
     ret = fread(&ehdr64, 1, sizeof(ehdr64), fd);
-    if (ret < 0 || (size_t)ret != sizeof(ehdr64)) {
+    if (ret != sizeof(ehdr64)) {
         fprintf(stderr, "Read of ELF header from %s failed: %s\n",
                 fname, strerror(errno));
         return -1;
@@ -102,18 +104,18 @@ static off_t read_elf64(FILE* fd)
     ehdr.e_shentsize	= file16_to_cpu(ehdr64.e_shentsize);
     ehdr.e_shnum		= file16_to_cpu(ehdr64.e_shnum);
 
-    last_shdr_offset = ehdr.e_shoff + (ehdr.e_shentsize * (ehdr.e_shnum - 1));
+    last_shdr_offset = (off_t)(ehdr.e_shoff + ((uint64_t)ehdr.e_shentsize * (ehdr.e_shnum - 1)));
     fseeko(fd, last_shdr_offset, SEEK_SET);
     ret = fread(&shdr64, 1, sizeof(shdr64), fd);
-    if (ret < 0 || ret != sizeof(shdr64)) {
+    if (ret != sizeof(shdr64)) {
         fprintf(stderr, "Read of ELF section header from %s failed: %s\n",
                 fname, strerror(errno));
         return -1;
     }
 
     /* ELF ends either with the table of section headers (SHT) or with a section. */
-    sht_end = ehdr.e_shoff + (ehdr.e_shentsize * ehdr.e_shnum);
-    last_section_end = file64_to_cpu(shdr64.sh_offset) + file64_to_cpu(shdr64.sh_size);
+    sht_end = (off_t)(ehdr.e_shoff + ((uint64_t)ehdr.e_shentsize * ehdr.e_shnum));
+    last_section_end = (off_t)(file64_to_cpu(shdr64.sh_offset) + file64_to_cpu(shdr64.sh_size));
     return sht_end > last_section_end ? sht_end : last_section_end;
 }
 
@@ -155,8 +157,8 @@ bool appimage_get_elf_section_offset_and_length(const char* fname, const char* s
         char* strTab = (char*) (data + shdr[elf->e_shstrndx].sh_offset);
         for (i = 0; i < elf->e_shnum; i++) {
             if (strcmp(&strTab[shdr[i].sh_name], section_name) == 0) {
-                *offset = shdr[i].sh_offset;
-                *length = shdr[i].sh_size;
+                *offset = (unsigned long)shdr[i].sh_offset;
+                *length = (unsigned long)shdr[i].sh_size;
             }
         }
     } else {
@@ -175,7 +177,7 @@ char* read_file_offset_length(const char* fname, unsigned long offset, unsigned
         return NULL;
     }
 
-    fseek(f, offset, SEEK_SET);
+    fseek(f, (long)offset, SEEK_SET);
 
     char* buffer = calloc(length + 1, sizeof(char));
     fread(buffer, length, sizeof(char), f);
@@ -191,7 +193,7 @@ int appimage_print_hex(const char* fname, unsigned long offset, unsigned long le
         return 1;
     }
 
-    for (long long k = 0; k < length && data[k] != '\0'; k++) {
+    for (unsigned long k = 0; k < length && data[k] != '\0'; k++) {
         printf("%x", data[k]);
     }