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

 static int fsentry_compare_pathnames_cb (const void *a, const void *b)
+{
    // qsort() callback that compares two imagefs filesystem entries and sort them alphabetically by pathname
-   fsentry_t *entry_a = (fsentry_t *) a;
+   const fsentry_t *entry_a = (const fsentry_t *) a;
-   fsentry_t *entry_b = (fsentry_t *) b;
+   const fsentry_t *entry_b = (const fsentry_t *) b;
    const char *pathname_a = (S_ISDIR (entry_a->header.mode) ? entry_a->u.dir.path : (S_ISREG (entry_a->header.mode) ? entry_a->u.file.path : (S_ISLNK (entry_a->header.mode) ? entry_a->u.symlink.path : entry_a->u.device.path)));
    const char *pathname_b = (S_ISDIR (entry_b->header.mode) ? entry_b->u.dir.path : (S_ISREG (entry_b->header.mode) ? entry_b->u.file.path : (S_ISLNK (entry_b->header.mode) ? entry_b->u.symlink.path : entry_b->u.device.path)));
    return (strcmp (pathname_a, pathname_b));
+}
 static int fsentry_compare_sizes_cb (const void *a, const void *b)
+{
-   // qsort() callback that compares two imagefs filesystem entries and sort them alphabetically by pathname
+   // qsort() callback that compares two imagefs filesystem entries and sort them by increasing data size
-   fsentry_t *entry_a = (fsentry_t *) a;
+   const fsentry_t *entry_a = (const fsentry_t *) a;
-   fsentry_t *entry_b = (fsentry_t *) b;
+   const fsentry_t *entry_b = (const fsentry_t *) b;
    const int32_t size_a = (S_ISREG (entry_a->header.mode) ? entry_a->u.file.size : 0); // only files (i.e. entries wearing the S_IFREG flag) have a separate data block
    const int32_t size_b = (S_ISREG (entry_b->header.mode) ? entry_b->u.file.size : 0); // only files (i.e. entries wearing the S_IFREG flag) have a separate data block
    return ((int) size_b - (int) size_a);
+}
    startup_trailer_v2_t *startup_trailer_v2 = NULL;
    image_header_t *image_header = NULL;
    size_t imageheader_offset = 0;
    image_trailer_v1_t *image_trailer_v1 = NULL;
    image_trailer_v2_t *image_trailer_v2 = NULL;
+   size_t imagetrailer_offset = 0;
+   fsentry_t **fsentries = NULL; // mallocated
+   size_t fsentry_count = 0;
    fsentry_t *current_fsentry = NULL;
    char recorded_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
    char computed_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
    size_t startupfile_blobsize = 0;
+   void *reallocated_ptr;
    size_t bootfile_blobsize = 0;
    size_t current_offset;
+   size_t fsentry_index;
+   size_t nearest_distance;
+   size_t nearest_index;
    size_t byte_index;
    uint32_t recorded_checksum;
    uint32_t computed_checksum;
    uint8_t *filedata;
    size_t filesize;
             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);
+         }
-         current_offset += (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? sizeof (image_trailer_v2_t) : sizeof (image_trailer_v1_t)); // now reach the next segment
+         current_offset += (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? sizeof (startup_trailer_v2_t) : sizeof (startup_trailer_v1_t)); // now reach the next segment
+      }
       // else does an image header start here ?
       else if ((current_offset + sizeof (image_header_t) < filesize) && (memcmp (&filedata[current_offset], "imagefs", 7) == 0))
+      {
             break;
+         }
          // locate the image trailer at the right offset
          if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)
+         {
-            image_trailer_v2 = (image_trailer_v2_t *) &filedata[current_offset + image_header->image_size - sizeof (image_trailer_v2_t)];
+            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v2_t);
+            image_trailer_v2 = (image_trailer_v2_t *) &filedata[imagetrailer_offset];
+         }
          else // old V1 trailer
+         {
-            image_trailer_v1 = (image_trailer_v1_t *) &filedata[current_offset + image_header->image_size - sizeof (image_trailer_v1_t)];
+            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v1_t);
+            image_trailer_v1 = (image_trailer_v1_t *) &filedata[imagetrailer_offset];
+         }
          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 extra 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%d 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);
+         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)
+         {
             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
+            // stack up the filesystem entry pointers in an array while we read them
+            reallocated_ptr = realloc (fsentries, (fsentry_count + 1) * sizeof (fsentry_t *));
+            if (reallocated_ptr == NULL)
+            {
+               fprintf (stderr, "fatal error: out of memory\n");
+               exit (1);
+            }
+            fsentries = reallocated_ptr;
+            fsentries[fsentry_count] = current_fsentry;
+            fsentry_count++;
             printf ("\n");
             printf ("Filesystem entry at offset 0x%zx (%zd) - last one at 0x%zd (%zd):\n", current_offset, current_offset, imageheader_offset + image_header->hdr_dir_size, imageheader_offset + image_header->hdr_dir_size);
             printf ("   size           = 0x%04x (%d) - size of dirent - %s\n", current_fsentry->header.size, current_fsentry->header.size, (current_offset + current_fsentry->header.size < filesize ? "looks good" : "BAD"));
             printf ("   extattr_offset = 0x%04x (%d) - %s\n", current_fsentry->header.extattr_offset, current_fsentry->header.extattr_offset, (current_fsentry->header.extattr_offset == 0 ? "no extattr" : "has extattr"));
             if (S_ISDIR (current_fsentry->header.mode))
                printf ("   [DIRECTORY] path = \"%s\"\n", (char *) &current_fsentry->u.dir.path); // convert from pointer to char array
             else if (S_ISREG (current_fsentry->header.mode))
+            {
                printf ("   [FILE] offset = 0x%08x (%d) - %s\n", current_fsentry->u.file.offset, current_fsentry->u.file.offset, (imageheader_offset + current_fsentry->u.file.offset < filesize ? "looks good" : "BAD (IFS file too short)"));
-               printf ("   [FILE] size   = 0x%08x (%d) - %s\n", current_fsentry->u.file.offset, current_fsentry->u.file.offset, (imageheader_offset + current_fsentry->u.file.offset + current_fsentry->u.file.size < filesize ? "looks good" : "BAD (IFS file too short)"));
+               printf ("   [FILE] size   = 0x%08x (%d) - %s\n", current_fsentry->u.file.size, current_fsentry->u.file.size, (imageheader_offset + current_fsentry->u.file.offset + current_fsentry->u.file.size < filesize ? "looks good" : "BAD (IFS file too short)"));
                printf ("   [FILE] path   = \"%s\"\n", (char *) &current_fsentry->u.file.path); // convert from pointer to char array
+            }
             else if (S_ISLNK (current_fsentry->header.mode))
+            {
                printf ("   [SYMLINK] sym_offset = 0x%04x (%d) - %s\n", current_fsentry->u.symlink.sym_offset, current_fsentry->u.symlink.sym_offset, (sizeof (current_fsentry->header) + 2 * sizeof (uint16_t) + current_fsentry->u.symlink.sym_offset <= current_fsentry->header.size ? "looks good" : "BAD (dirent too short)"));
-               printf ("   [SYMLINK] sym_size   = 0x%04x (%d) - %s\n", current_fsentry->u.symlink.sym_offset, current_fsentry->u.symlink.sym_offset, (sizeof (current_fsentry->header) + 2 * sizeof (uint16_t) + current_fsentry->u.symlink.sym_offset + current_fsentry->u.symlink.sym_size <= current_fsentry->header.size ? "looks good" : "BAD (dirent too short)"));
+               printf ("   [SYMLINK] sym_size   = 0x%04x (%d) - %s\n", current_fsentry->u.symlink.sym_size, current_fsentry->u.symlink.sym_size, (sizeof (current_fsentry->header) + 2 * sizeof (uint16_t) + current_fsentry->u.symlink.sym_offset + current_fsentry->u.symlink.sym_size <= current_fsentry->header.size ? "looks good" : "BAD (dirent too short)"));
                printf ("   [SYMLINK] path       = \"%s\"\n", (char *) &current_fsentry->u.symlink.path); // convert from pointer to char array
                printf ("   [SYMLINK] contents   = \"%s\"\n", ((char *) &current_fsentry->u.symlink.path) + current_fsentry->u.symlink.sym_offset); // convert from pointer to char array
+            }
             else // can only be a device
+            {
                printf ("   [DEVICE] path = \"%s\"\n", (char *) &current_fsentry->u.device.path); // convert from pointer to char array
+            }
             current_offset += current_fsentry->header.size;
+         }
-         if (imageheader_offset + image_header->hdr_dir_size - current_offset < sizeof (current_fsentry->header))
+         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" "%d 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)
+         {
+            while (current_offset < imagetrailer_offset) // and parse data up to the trailer
+            {
+               nearest_distance = SIZE_MAX;
+               nearest_index = SIZE_MAX;
+               for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+                  if (S_ISREG (fsentries[fsentry_index]->header.mode) // if this directory entry a file (i.e. it has a data blob)...
+                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset >= current_offset) // ... AND its data blob is still ahead of our current pointer ...
+                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset < nearest_distance)) // ... AND it's the closest to us we've found so far
+                  {
+                     nearest_distance = imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset; // then remember it
+                     nearest_index = fsentry_index;
+                  }
+               if (nearest_index == SIZE_MAX)
+                  break; // found no file ahead, which means we've parsed the whole file data area, so stop the loop so as to proceed to the image trailer
+               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)
-            // now jump at the first
+                  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);
+               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 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 ("   checksum %d\n", update_checksum32 (0, (uint32_t *) &filedata[current_offset], current_fsentry->u.file.size));
+               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);
+         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_checksum32 (0, (uint32_t *) image_header, sizeof (image_header) + image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH);
+            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_checksum32 (0, (uint32_t *) image_header, sizeof (image_header) + image_header->image_size - sizeof (image_trailer_v1_t));
+            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);
+         }
-         exit (0);
+         current_offset += (image_header->flags & IMAGE_FLAGS_TRAILER_V2 ? sizeof (image_trailer_v2_t) : sizeof (image_trailer_v1_t)); // now reach the next segment (typically end of file)
+      }
       // else it has to be a boot blob, of which we don't know the size, except that it has to fit in 0xffff bytes and be immediately followed by a startup header
       else
+      {
          current_offset = byte_index; // now reach the next segment
+      }
+   }
-   printf ("End of identifiable data reached.\n");
+   // at this point there's nothing left we're able to parse
    if (current_offset < filesize)
+   {
+      printf ("End of identifiable data reached.\n");
-      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" "%d extra bytes at offset %zx (%zd):\n", filesize - current_offset, current_offset, current_offset);
-   printf ("End of file reached at offset 0x%zx (%zd).\n", filesize, filesize);
+   }
+   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 2 → 3