WebSVN – QNX 8.QNX8 IFS tool – Diff – /ifstool.c

 typedef struct __attribute__((packed)) image_header_s
+{
    uint8_t signature[7]; // image filesystem signature, i.e. "imagefs"
    uint8_t flags; // endian neutral flags, 0x1c
-   uint32_t image_size; // size from header to end of trailer (here 0xca6fe0 or 13 266 912)
+   uint32_t image_size; // size from start of header to end of trailer (here 0xca6fe0 or 13 266 912)
-   uint32_t hdr_dir_size; // size from header to last dirent (here 0x12b8 or 4792)
+   uint32_t hdr_dir_size; // size from start of header to last dirent (here 0x12b8 or 4792)
-   uint32_t dir_offset; // offset from header to first dirent (here 0x5c or 92)
+   uint32_t dir_offset; // offset from start of header to start of first dirent (here 0x5c or 92)
    uint32_t boot_ino[4]; // inode of files for bootstrap pgms (here 0xa0000002, 0, 0, 0)
    uint32_t script_ino; // inode of file for script (here 3)
    uint32_t chain_paddr; // offset to next filesystem signature (0)
    uint32_t spare[10]; // zerofill
    uint32_t mountflags; // default _MOUNT_* from sys/iomsg.h (0)
 static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data); // used internally in SHA512_Update() and SHA512_Final()
 static void SHA512_Init (SHA512_CTX *context);
 static void SHA512_Update (SHA512_CTX *context, void *data, size_t len);
 static void SHA512_Final (uint8_t digest[SHA512_DIGEST_LENGTH], SHA512_CTX *context);
 static uint8_t *SHA512 (void *data, size_t data_len, uint8_t *digest); // computes a SHA-512 in one pass (shortcut for SHA512_Init(), SHA512_Update() N times and SHA512_Final())
-static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t len); // update the sum of an array of 32-bit signed integers
-static int32_t update_image_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image checksum to store in the image trailer
+static int32_t update_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer
 static long long read_integer (const char *str); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)
 static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...); // hexdump-style formatted output to a file stream (which may be stdout/stderr)
 static char *binary (const uint8_t x, char char_for_zero, char char_for_one); // returns the binary representation of byte 'x' as a string
 static char *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8]); // returns the ORed description of byte 'x' according to the description strings for each bit
 static int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp
       sprintf (&digest_as_string[2 * byte_index], "%02x", digest_or_NULL[byte_index]);
    return (digest_as_string);
+}
-static int32_t update_checksum32_NOT (const int32_t start_value, const void *data, const size_t len)
+static int32_t update_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness)
+{
-   // compute the sum of an array of 32-bit signed integers
-   const int32_t *values_array = data;
-   int32_t sum = start_value;
-   for (size_t value_index = 0; value_index < len / sizeof (int32_t); value_index++)
-      sum += values_array[value_index];
-   return (sum);
-}
-static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t data_len)
-{
-   uint8_t hold_cksum_4[4] = { 0, 0, 0, 0 };
-   int32_t image_cksum = start_value;
-   int hold_index; // ST2C_4@4
-   uint64_t i; // [sp+30h] [bp-10h]@3
-   char *current_char_ptr; // [sp+38h] [bp-8h]@3
-   char *data_start; // [sp+50h] [bp+10h]@1
-   uint64_t _data_len; // [sp+58h] [bp+18h]@1
-   data_start = data;
-   _data_len = data_len;
-   current_char_ptr = data_start;
-   for (i = 0; i < data_len; ++i)
-   {
-      hold_index = i & 3;
-      hold_cksum_4[hold_index] = *current_char_ptr;
-      if (hold_index == 3)
-      {
-         if (false) // endianness
-            image_cksum += (hold_cksum_4[3] << 0)
-            + (hold_cksum_4[2] << 8)
-            + (hold_cksum_4[1] << 16)
-            + (hold_cksum_4[0] << 24);
-         else
-            image_cksum += (hold_cksum_4[0] << 0)
-            + (hold_cksum_4[1] << 8)
-            + (hold_cksum_4[2] << 16)
-            + (hold_cksum_4[3] << 24);
-      }
-      current_char_ptr++;
-   }
-   return (-image_cksum);
-}
-static int32_t update_image_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness)
-{
-   // computes the checksum of an IFS image section, i.e. from the start of the image header to the end of the image trailer minus the last 4 bytes where the checksum is stored
+   // computes the checksum of an IFS image or startup section, i.e. from the start of the header to the end of the trailer minus the last 4 bytes where the checksum is stored
    uint8_t accumulator[4] = { 0, 0, 0, 0 };
    int32_t image_cksum = start_value;
-   char *current_char_ptr = data;
+   const char *current_char_ptr = data;
    size_t i;
    for (i = 0; i < data_len; i++)
+   {
       accumulator[i % 4] = *current_char_ptr;
                if (entry_parms.precompiled_data == NULL)
+               {
                   fprintf (stderr, "fatal error: out of memory\n");
                   exit (1);
+               }
-               fp = fopen ("procnto-smp-instr.bin", "rb");
+               fp = fopen (kernelfile_pathname, "rb");
                fread (entry_parms.precompiled_data, 1, stat_buf.st_size, fp);
                fclose (fp);
                entry_parms.precompiled_datalen = stat_buf.st_size;
+            }
             else if (strcmp (token, "+script") == 0) {
       if (blob_datasize > 0)
          free (blob_data); // if blob data was allocated, free it
+   }
    // sort the filesystem entries by pathname
-   qsort (fsentries, fsentry_count, sizeof (fsentry_t), fsentry_compare_pathnames_cb);
+   qsort (&fsentries[1], fsentry_count - 1, sizeof (fsentry_t), fsentry_compare_pathnames_cb);
    // calculate filesystem entries size
    imgdir_size = sizeof (image_header);
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+   {
    image_header.script_ino    = image_bootscript_ino; // inode of file for script (here 3)
    image_header.mountpoint[0] = '/'; // default mountpoint for image ("/" + "\0\0\0")
    fwrite (&image_header, sizeof (image_header), 1, fp); // write image header
    PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
-   // write empty image directory
+   // write image directory (with the wrong file offsets)
    imgdir_offset = ftell (fp);
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-      fwrite_fsentry (&fsentries[fsentry_index], fp);
+      fwrite_fsentry (&fsentries[fsentry_index], fp); // NOTE: padding is handled in this function
    PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
    // is it a bootable image with a kernel file ?
    if ((startupfile_pathname != NULL) && (kernelfile_pathname != NULL))
+   {
          exit (1);
+      }
       fseek (fp, startupheader_offset, SEEK_SET);
       fread (blob_data, 1, blob_datasize, fp);
       SHA512 (blob_data, blob_datasize, startup_trailer.sha512); // compute SHA512 checksum
+      if (   ( (startup_header.flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
+          || (!(startup_header.flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
+         is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
+      else
+         is_foreign_endianness = false; // else this header is for the same endianness as us
       startup_trailer.cksum = 0; // compute old checksum
-      startup_trailer.cksum = update_checksum32 (startup_trailer.cksum, (const uint32_t *) blob_data, blob_datasize);
+      startup_trailer.cksum = update_checksum (startup_trailer.cksum, (const uint32_t *) blob_data, blob_datasize, is_foreign_endianness);
-      startup_trailer.cksum = update_checksum32 (startup_trailer.cksum, (const uint32_t *) startup_trailer.sha512, sizeof (startup_trailer.sha512));
+      startup_trailer.cksum = update_checksum (startup_trailer.cksum, (const uint32_t *) startup_trailer.sha512, sizeof (startup_trailer.sha512), is_foreign_endianness);
       free (blob_data);
       // rewrite startup trailer with final values
       fseek (fp, startuptrailer_offset, SEEK_SET);
       fwrite (&startup_trailer, sizeof (startup_trailer), 1, fp); // write startup trailer
        || (!(image_header.flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
       is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
    else
       is_foreign_endianness = false; // else this header is for the same endianness as us
    image_trailer.cksum = 0; // compute old checksum
-   image_trailer.cksum = update_image_checksum (image_trailer.cksum, (const uint32_t *) blob_data, blob_datasize, is_foreign_endianness);
+   image_trailer.cksum = update_checksum (image_trailer.cksum, (const uint32_t *) blob_data, blob_datasize, is_foreign_endianness);
-   image_trailer.cksum = update_image_checksum (image_trailer.cksum, (const uint32_t *) image_trailer.sha512, sizeof (image_trailer.sha512), is_foreign_endianness);
+   image_trailer.cksum = update_checksum (image_trailer.cksum, (const uint32_t *) image_trailer.sha512, sizeof (image_trailer.sha512), is_foreign_endianness);
    free (blob_data);
    // rewrite image trailer with final checksum values
    fseek (fp, imgtrailer_offset, SEEK_SET);
    fwrite (&image_trailer, sizeof (image_trailer), 1, fp); // write image trailer
          current_offset += sizeof (startup_header_t); // jump over the startup header and reach the startup blob
          printf ("\n");
          printf ("Startup blob at offset 0x%zx (%zd):\n", current_offset, current_offset);
          printf ("   size 0x%zx (%zd) bytes\n", startupfile_blobsize, startupfile_blobsize);
-         printf ("   checksum %d\n", update_checksum32 (0, &filedata[current_offset], startupfile_blobsize));
+         printf ("   checksum %d\n", update_checksum (0, &filedata[current_offset], startupfile_blobsize, is_foreign_endianness));
          current_offset += startupfile_blobsize; // jump over the startup blob and reach the startup trailer
          printf ("\n");
          printf ("Startup trailer at offset 0x%zx (%zd) - version %d:\n", current_offset, current_offset, (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? 2 : 1));
          if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
+         {
             for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
                sprintf (&recorded_sha512[2 * byte_index], "%02x", startup_trailer_v2->sha512[byte_index]);
             strcpy (computed_sha512, SHA512 (startup_header, (size_t) ((uint8_t *) startup_trailer_v2 - (uint8_t *) startup_header), NULL));
             recorded_checksum = startup_trailer_v2->cksum;
-            computed_checksum = update_checksum32 (0, startup_header, sizeof (startup_header) + startupfile_blobsize + SHA512_DIGEST_LENGTH);
+            computed_checksum = update_checksum (0, startup_header, sizeof (startup_header_t) + startupfile_blobsize + SHA512_DIGEST_LENGTH, is_foreign_endianness);
             printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (strcasecmp (computed_sha512, recorded_sha512) != 0)
                printf ("Computed SHA-512: %s\n", computed_sha512);
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          else // old v1 trailer
+         {
             recorded_checksum = startup_trailer_v1->cksum;
-            computed_checksum = update_checksum32 (0, startup_header, sizeof (startup_header) + startupfile_blobsize);
+            computed_checksum = update_checksum (0, startup_header, sizeof (startup_header) + startupfile_blobsize, is_foreign_endianness);
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          image_header = (image_header_t *) &filedata[imageheader_offset];
          // layout:
          // [IMAGE HEADER]
          // [image directory entries]
-         // [file blobs up to KERNEL]
+         // [smallest file blobs up to KERNEL]
          // [padding]
          // [KERNEL]
-         // [file blobs]
+         // [rest of file blobs]
          // [IMAGE FOOTER]
          printf ("\n");
          printf ("Image header at offset %zx (%zd):\n", current_offset, current_offset);
          printf ("   signature    = %02x %02x %02x %02x %02x %02x %02x (\"%.7s\") - good\n", image_header->signature[0], image_header->signature[1], image_header->signature[2], image_header->signature[3], image_header->signature[4], image_header->signature[5], image_header->signature[6], image_header->signature);
          current_offset += sizeof (image_header_t); // jump over the image header and reach the first directory entry
          // there may be padding before the first directory entry
          if (image_header->dir_offset - sizeof (image_header_t) > 0)
-            hex_printf (&filedata[current_offset], image_header->dir_offset - sizeof (image_header_t), "\n%d padding bytes at offset 0x%zd (%zd):\n", image_header->dir_offset - sizeof (image_header_t), current_offset, current_offset);
+            hex_printf (&filedata[current_offset], image_header->dir_offset - sizeof (image_header_t), "\n" "%zd padding bytes at offset 0x%zd (%zd):\n", image_header->dir_offset - sizeof (image_header_t), current_offset, current_offset);
          current_offset += image_header->dir_offset - sizeof (image_header_t); // padding was processed, jump over it
          // dump all directory entries until the last one included
          fsentries = NULL;
          fsentry_count = 0;
-         while (&filedata[current_offset] < (uint8_t *) image_header + image_header->hdr_dir_size)
+         while (current_offset < imageheader_offset + image_header->hdr_dir_size)
+         {
             current_fsentry = (fsentry_t *) &filedata[current_offset];
             if (imageheader_offset + image_header->hdr_dir_size - current_offset < sizeof (current_fsentry->header))
                break; // end padding reached
+            }
             current_offset += current_fsentry->header.size;
+         }
          if (imageheader_offset + image_header->hdr_dir_size < current_offset + sizeof (current_fsentry->header))
-            hex_printf (&filedata[current_offset], imageheader_offset + image_header->hdr_dir_size - current_offset, "\n" "%d padding bytes at offset 0x%zx (%zd):\n", imageheader_offset + image_header->hdr_dir_size - current_offset, current_offset, current_offset);
+            hex_printf (&filedata[current_offset], imageheader_offset + image_header->hdr_dir_size - current_offset, "\n" "%zd padding bytes at offset 0x%zx (%zd):\n", imageheader_offset + image_header->hdr_dir_size - current_offset, current_offset, current_offset);
          current_offset += imageheader_offset + image_header->hdr_dir_size - current_offset; // padding was processed, jump over it
          // at this point we are past the directory entries; what is stored now, up to and until the image trailer, is the files' data
          if (fsentry_count > 0)
+         {
                fsentry_index = nearest_index;
                current_fsentry = fsentries[fsentry_index]; // quick access to closest fsentry
                // there may be padding before the file data
                if (imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset > 0)
-                  hex_printf (&filedata[current_offset], imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset, "\n" "%d padding bytes at offset 0x%zx (%zd):\n", imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset, current_offset, current_offset);
+                  hex_printf (&filedata[current_offset], imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset, "\n" "%zd padding bytes at offset 0x%zx (%zd):\n", imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset, current_offset, current_offset);
                current_offset += imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset; // padding was processed, jump over it
                printf ("\n");
                printf ("File data blob at offset 0x%zx (%zd):\n", current_offset, current_offset);
                printf ("   corresponding dirent index: %zd/%zd\n", fsentry_index, fsentry_count);
-               printf ("   corresponding inode 0x%08x (%d) - %s%s%s%s\n", current_fsentry->header.ino, current_fsentry->header.ino, (current_fsentry->header.ino & 0xE0000000 ? "is" : "nothing special"), (current_fsentry->header.ino & IFS_INO_PROCESSED_ELF ? " PROCESSED_ELF" : ""), (current_fsentry->header.ino & IFS_INO_RUNONCE_ELF ? " RUNONCE_ELF" : ""), (current_fsentry->header.ino & IFS_INO_BOOTSTRAP_EXE ? " BOOTSTRAP_EXE" : ""));
+               printf ("   corresponding inode 0x%08x (%d) -%s%s%s%s\n", current_fsentry->header.ino, current_fsentry->header.ino, (current_fsentry->header.ino & 0xE0000000 ? "" : " nothing special"), (current_fsentry->header.ino & IFS_INO_PROCESSED_ELF ? " PROCESSED_ELF" : ""), (current_fsentry->header.ino & IFS_INO_RUNONCE_ELF ? " RUNONCE_ELF" : ""), (current_fsentry->header.ino & IFS_INO_BOOTSTRAP_EXE ? " BOOTSTRAP_EXE" : ""));
                printf ("   corresponding path: \"%s\"\n", (char *) &current_fsentry->u.file.path); // convert from pointer to char array
                printf ("   size 0x%zx (%zd) bytes\n", (size_t) current_fsentry->u.file.size, (size_t) current_fsentry->u.file.size);
-               printf ("   first 4 bytes: %02x%02x%02x%02x [%c%c%c%c] (%s)\n", (uint8_t) filedata[current_offset + 0], (uint8_t) filedata[current_offset + 1], (uint8_t) filedata[current_offset + 2], (uint8_t) filedata[current_offset + 3], (isprint (filedata[current_offset + 0]) ? filedata[current_offset + 0] : '.'), (isprint (filedata[current_offset + 1]) ? filedata[current_offset + 1] : '.'), (isprint (filedata[current_offset + 2]) ? filedata[current_offset + 2] : '.'), (isprint (filedata[current_offset + 3]) ? filedata[current_offset + 3] : '.'), (memcmp (&filedata[current_offset], "\x7f" "ELF", 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "???")));
+               printf ("   first 4 bytes: %02x%02x%02x%02x \"%c%c%c%c\" (%s)\n", (uint8_t) filedata[current_offset + 0], (uint8_t) filedata[current_offset + 1], (uint8_t) filedata[current_offset + 2], (uint8_t) filedata[current_offset + 3], (isprint (filedata[current_offset + 0]) ? filedata[current_offset + 0] : '.'), (isprint (filedata[current_offset + 1]) ? filedata[current_offset + 1] : '.'), (isprint (filedata[current_offset + 2]) ? filedata[current_offset + 2] : '.'), (isprint (filedata[current_offset + 3]) ? filedata[current_offset + 3] : '.'), (memcmp (&filedata[current_offset], "\x7f" "ELF", 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "data file")));
-               printf ("   checksum %d\n", update_image_checksum (0, &filedata[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
+               printf ("   checksum %d\n", update_checksum (0, &filedata[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
                current_offset += current_fsentry->u.file.size; // now jump over this file's data
+            }
+         }
          // ad this point we're past the last file data, there may be padding before the image trailer
          if (imagetrailer_offset - current_offset > 0)
-            hex_printf (&filedata[current_offset], imagetrailer_offset - current_offset, "\n" "%d padding bytes at offset %zx (%zd):\n", imagetrailer_offset - current_offset, current_offset, current_offset);
+            hex_printf (&filedata[current_offset], imagetrailer_offset - current_offset, "\n" "%zd padding bytes at offset %zx (%zd):\n", imagetrailer_offset - current_offset, current_offset, current_offset);
          current_offset += imagetrailer_offset - current_offset; // padding was processed, jump over it
          printf ("\n");
          printf ("Image trailer at offset 0x%zx (%zd) - version %d:\n", current_offset, current_offset, (image_header->flags & IMAGE_FLAGS_TRAILER_V2 ? 2 : 1));
          if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)
+         {
             for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
                sprintf (&recorded_sha512[2 * byte_index], "%02x", image_trailer_v2->sha512[byte_index]);
             strcpy (computed_sha512, SHA512 (image_header, (size_t) ((uint8_t *) image_trailer_v2 - (uint8_t *) image_header), NULL));
             recorded_checksum = image_trailer_v2->cksum;
-            computed_checksum = update_image_checksum (0, image_header, /*sizeof (image_header) +*/ image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH, is_foreign_endianness);
+            computed_checksum = update_checksum (0, image_header, image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH, is_foreign_endianness);
             printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (strcasecmp (computed_sha512, recorded_sha512) != 0)
                printf ("Computed SHA-512: %s\n", computed_sha512);
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          else // old v1 trailer
+         {
             recorded_checksum = image_trailer_v1->cksum;
-            computed_checksum = update_image_checksum (0, image_header, /*sizeof (image_header) +*/ image_header->image_size - sizeof (image_trailer_v1_t), is_foreign_endianness);
+            computed_checksum = update_checksum (0, image_header, image_header->image_size - sizeof (image_trailer_v1_t), is_foreign_endianness);
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
             break; // if not found, stop scanning
          bootfile_blobsize = byte_index - current_offset;
          printf ("Boot blob at offset 0x%zx (%zd):\n", current_offset, current_offset);
          printf ("   size 0x%zx (%zd) bytes\n", bootfile_blobsize, bootfile_blobsize);
-         printf ("   checksum 0x%08x\n", update_checksum32 (0, &filedata[current_offset], bootfile_blobsize));
+         printf ("   checksum 0x%08x\n", update_checksum (0, &filedata[current_offset], bootfile_blobsize, false)); // NOTE: endianness is not known yet -- assume same
          current_offset = byte_index; // now reach the next segment
+      }
+   }
    // at this point there's nothing left we're able to parse
    if (current_offset < filesize)
+   {
       printf ("End of identifiable data reached.\n");
+      if (filesize - current_offset < 16384)
-      hex_printf (&filedata[current_offset], filesize - current_offset, "\n" "%d extra bytes at offset %zx (%zd):\n", filesize - current_offset, current_offset, current_offset);
+         hex_printf (&filedata[current_offset], filesize - current_offset, "\n" "%zd extra bytes at offset %zx (%zd):\n", filesize - current_offset, current_offset, current_offset);
+      else
+         printf ("\n" "%zd extra bytes at offset %zx (%zd) - size > 16k, not printed\n", filesize - current_offset, current_offset, current_offset);
+   }
    printf ("End of file reached at offset 0x%zx (%zd)\n", filesize, filesize);
    printf ("IFS dissecation complete.\n");
    return (0);

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/ifstool.c – Rev 5 → 6