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

 #include <unistd.h>
 #include <utime.h>
 #endif // _MSC_VER
 // own includes
+#include "ucl/ucl.h"
+#include "minilzo.h"
 #include "buffer.h"
 #include "sha512.h"
 #include "ifsfile.h"
 #include "elffile.h"
 #include "utility.h"
 // imported global variables
 extern int verbose_level; // from ifstool.c
 // exported function prototypes
-int dump_ifs_info (const char *ifs_pathname, bool want_everything); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
+int dump_ifs_info (const char *ifs_pathname, bool want_everything, bool hide_filename); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
 int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error
 int dump_file_hex (const char *pathname); // hexdump the content of pathname, returns 0 on success and != 0 on error
 // prototypes of local functions
+      }
    return (outstr);
+}
-int dump_ifs_info (const char *ifs_pathname, bool want_everything)
+int dump_ifs_info (const char *ifs_pathname, bool want_everything, bool hide_filename)
+{
    #define hex_printf(buf,size,...) do { \
       if (want_everything || ((size) <= 16 * 1024)) /* only print when it's not too big (up to 16 kb) */\
          hex_fprintf (stdout, (buf), (size), 16, __VA_ARGS__); /* use 16 columns in hex output to stdout */ \
       else { \
    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;
+   buffer_t decompression_dst;
    char recorded_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
    char computed_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
    size_t startupfile_blobsize = 0;
+   size_t compressed_blocksize;
    void *reallocated_ptr;
    bool is_foreign_endianness;
+   uint8_t *decompressor_out;
+   uint8_t *decompressor_in;
+   size_t decompressor_outlen;
    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;
    buffer_t file;
    time_t mtime;
+   int cf;
    // open and read IFS file
    if (!Buffer_ReadFromFile (&file, ifs_pathname))
       DIE_WITH_EXITCODE (1, "can't open \"%s\" for reading: %s", ifs_pathname, strerror (errno));
    printf ("QNX In-kernel Filesystem analysis produced by ifstool version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
+   if (hide_filename)
+      printf ("IFS file - size 0x%zx (%zd) bytes\n", file.size, file.size);
+   else
-   printf ("IFS file \"%s\" - size 0x%zx (%zd) bytes\n", ifs_pathname, file.size, file.size);
+      printf ("IFS file \"%s\" - size 0x%zx (%zd) bytes\n", ifs_pathname, file.size, file.size);
    // parse file from start to end
    current_offset = 0;
+   cf = STARTUP_HDR_FLAGS1_COMPRESS_NONE;
    for (;;)
+   {
       // does a startup header start here ?
+      if ((current_offset + sizeof (startup_header_t) < file.size)
+          && (startup_header == NULL)
-      if ((current_offset + sizeof (startup_header_t) < file.size) && (memcmp (&file.bytes[current_offset], "\xeb\x7e\xff\x00", 4) == 0))
+          && (memcmp (&file.bytes[current_offset], "\xeb\x7e\xff\x00", 4) == 0))
+      {
          startupheader_offset = current_offset;
          startup_header = (startup_header_t *) &file.bytes[startupheader_offset];
          // layout:
          printf ("\n");
          printf ("Startup header at offset 0x%zx (%zd):\n", current_offset, current_offset);
          printf ("   signature     = %02x %02x %02x %02x - good\n", startup_header->signature[0], startup_header->signature[1], startup_header->signature[2], startup_header->signature[3]);
          printf ("   version       = 0x%04x (%d) - %s\n", startup_header->version, startup_header->version, (startup_header->version == 1 ? "looks good" : "???"));
+         cf = startup_header->flags1 & STARTUP_HDR_FLAGS1_COMPRESS_MASK;
-         printf ("   flags1        = 0x%02x (%s)\n", startup_header->flags1, describe_uint8 (startup_header->flags1, startupheader_flags1_strings));
+         printf ("   flags1        = 0x%02x (%s) - %s\n", startup_header->flags1, describe_uint8 (startup_header->flags1, startupheader_flags1_strings), (cf == STARTUP_HDR_FLAGS1_COMPRESS_NONE ? "uncompressed image" : (cf == STARTUP_HDR_FLAGS1_COMPRESS_ZLIB ? "Zlib-compressed image (non-bootable)" : (cf == STARTUP_HDR_FLAGS1_COMPRESS_LZO ? "LZO-compressed image" : (cf == STARTUP_HDR_FLAGS1_COMPRESS_UCL ? "UCL-compressed image" : "compressed image (unknown algorithm)")))));
          printf ("   flags2        = 0x%02x (%s) - %s\n", startup_header->flags2, BINARY (startup_header->flags2), (startup_header->flags2 == 0 ? "looks good" : "???"));
          printf ("   header_size   = 0x%04x (%d) - %s\n", startup_header->header_size, startup_header->header_size, (startup_header->header_size == sizeof (startup_header_t) ? "looks good" : "BAD"));
          printf ("   machine       = 0x%04x (%d) - %s\n", startup_header->machine, startup_header->machine, (startup_header->machine == ELF_MACHINE_X86_64 ? "x86_64" : (startup_header->machine == ELF_MACHINE_AARCH64 ? "aarch64" : "unknown")));
          printf ("   startup_vaddr = 0x%08x (%d) - virtual address to transfer to after IPL is done\n", startup_header->startup_vaddr, startup_header->startup_vaddr);
          printf ("   paddr_bias    = 0x%08x (%d) - value to add to physical addresses to get an indirectable pointer value\n", startup_header->paddr_bias, startup_header->paddr_bias);
          printf ("   image_paddr   = 0x%08x (%d) - physical address of image\n", startup_header->image_paddr, startup_header->image_paddr);
          printf ("   ram_paddr     = 0x%08x (%d) - physical address of RAM to copy image to (startup_size bytes copied)\n", startup_header->ram_paddr, startup_header->ram_paddr);
          printf ("   ram_size      = 0x%08x (%d) - amount of RAM used by the startup program and executables in the fs\n", startup_header->ram_size, startup_header->ram_size);
          printf ("   startup_size  = 0x%08x (%d) - size of startup (never compressed) - %s\n", startup_header->startup_size, startup_header->startup_size, (current_offset + sizeof (image_header_t) + startup_header->startup_size + (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? sizeof (image_trailer_v2_t) : sizeof (image_trailer_v1_t)) < file.size ? "looks good" : "BAD (IFS file too short)"));
-         printf ("   stored_size   = 0x%08x (%d) - size of entire image - %s\n", startup_header->stored_size, startup_header->stored_size, (startup_header->stored_size == startup_header->ram_size ? "looks good" : "???"));
+         printf ("   stored_size   = 0x%08x (%d) - stored size of image - %s\n", startup_header->stored_size, startup_header->stored_size, (startup_header->stored_size <= startup_header->ram_size ? "looks good" : "???"));
          printf ("   imagefs_paddr = 0x%08x (%d) - set by IPL when startup runs - %s\n", startup_header->imagefs_paddr, startup_header->imagefs_paddr, (startup_header->imagefs_paddr == 0 ? "looks good" : "??? should be zero"));
          printf ("   imagefs_size  = 0x%08x (%d) - size of uncompressed imagefs\n", startup_header->imagefs_size, startup_header->imagefs_size);
          printf ("   preboot_size  = 0x%04x (%d) - size of loaded before header - %s\n", startup_header->preboot_size, startup_header->preboot_size, (startup_header->preboot_size == current_offset ? "looks good" : "???"));
          printf ("   zero0         = 0x%04x (%d) - zeros - %s\n", startup_header->zero0, startup_header->zero0, (startup_header->zero0 == 0 ? "looks good" : "??? should be zero"));
          printf ("   zero[0]       = 0x%08x (%d) - zeros - %s\n", startup_header->zero[0], startup_header->zero[0], (startup_header->zero[0] == 0 ? "looks good" : "??? should be zero"));
          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) < file.size)
+               && (image_header == NULL)
-      else if ((current_offset + sizeof (image_header_t) < file.size) && (memcmp (&file.bytes[current_offset], "imagefs", 7) == 0))
+               && (   ((cf == STARTUP_HDR_FLAGS1_COMPRESS_NONE) && (memcmp (&file.bytes[current_offset], "imagefs", 7) == 0))
+                   || (cf != STARTUP_HDR_FLAGS1_COMPRESS_NONE) && (startup_header->imagefs_size > 0)))
+      {
          imageheader_offset = current_offset;
          image_header = (image_header_t *) &file.bytes[imageheader_offset];
+         // should we decompress it ?
+         if (cf != STARTUP_HDR_FLAGS1_COMPRESS_NONE)
+         {
+            // it appears mkifs compresses data in blocks, prefixed by 2-byte block size in BIG ENDIAN
+            Buffer_InitWithSize (&decompression_dst, startup_header->imagefs_size * 11 / 10); // mallocate and add 10% for safety
+            decompression_dst.size = 0;
+            if (cf == STARTUP_HDR_FLAGS1_COMPRESS_UCL)
+               ASSERT (ucl_init () == UCL_E_OK, "UCL library initialization failed -- please recompile this tool with less aggressive optimizations");
+            else if (cf == STARTUP_HDR_FLAGS1_COMPRESS_LZO)
+               ASSERT (lzo_init () == LZO_E_OK, "LZO library initialization failed -- please recompile this tool with less aggressive optimizations");
+            else if (cf == STARTUP_HDR_FLAGS1_COMPRESS_ZLIB)
+            {
+               LOG_WARNING ("unimplemented compression scheme: zlib (FIXME)");
+               goto endofdata;
+            }
+            else
+            {
+               LOG_WARNING ("unsupported compression flags: 0x%2x", cf);
+               goto endofdata;
+            }
+            // run the compressed payload (the imagefs) through the right decompression algorithm
+            for (;;)
+            {
+               compressed_blocksize = (file.bytes[current_offset + 0] << 8) | (file.bytes[current_offset + 1] << 0); // read block size word (in big engian)
+               current_offset += 2; // skip it
+               if (compressed_blocksize == 0)
+                  break; // a nil block size means end of stream is reached
+               LOG_DEBUG ("about to decompress block of %zd bytes", compressed_blocksize);
+               decompressor_in = &file.bytes[current_offset];
+               decompressor_out = &decompression_dst.bytes[decompression_dst.size];
+               decompressor_outlen = 0;
+               if (cf == STARTUP_HDR_FLAGS1_COMPRESS_UCL)
+               {
+                  // UCL compression. NOTE: the decompressor function used in startup-x86 is "ucl_nrv2b_decompress_8 / ucl_nrv2b_decompress_le16 / ucl_nrv2b_decompress_le32"
+                  static ucl_uint ucl_outlen; // have a different variable because of pointer size mismatch
+                  if (ucl_nrv2b_decompress_8 (decompressor_in, (ucl_uint) compressed_blocksize, decompressor_out, &ucl_outlen, NULL) != UCL_E_OK)
+                  {
+                     LOG_WARNING ("this IFS file is corrupted (UCL decompression failed)");
+                     goto endofdata;
+                  }
+                  decompressor_outlen = ucl_outlen;
+               }
+               else if (cf == STARTUP_HDR_FLAGS1_COMPRESS_LZO)
+               {
+                  // LZO decompression. NOTE: mkifs uses the full LZO package, whereas I use minilzo.
+                  static lzo_uint lzo_outlen; // have a different variable because of pointer size mismatch
+                  if (lzo1x_decompress (decompressor_in, (lzo_uint) compressed_blocksize, decompressor_out, &lzo_outlen, NULL) != LZO_E_OK)
+                  {
+                     LOG_WARNING ("this IFS file is corrupted (UCL decompression failed)");
+                     goto endofdata;
+                  }
+                  decompressor_outlen = lzo_outlen;
+               }
+               else if (cf == STARTUP_HDR_FLAGS1_COMPRESS_ZLIB)
+                  ; // TODO
+               current_offset += compressed_blocksize;
+               decompression_dst.size += decompressor_outlen;
+            }
+            LOG_INFO ("decompressed %zd bytes into %zd bytes\n", file.size - imageheader_offset, decompression_dst.size);
+            // now place the decompressed buffer in the payload at the imagefs offset
+            ASSERT_WITH_ERRNO (Buffer_WriteBufferAt (&file, imageheader_offset, &decompression_dst));
+            current_offset = imageheader_offset; // jump back to where we put the uncompressed data
+            file.size = imageheader_offset + decompression_dst.size; // update IFS data size
+            startup_header = (startup_header_t *) &file.bytes[startupheader_offset]; // fix the pointers that might have changed
+            if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
+               startup_trailer_v2 = (startup_trailer_v2_t *) &file.bytes[startuptrailer_offset];
+            else // old V1 trailer
+               startup_trailer_v1 = (startup_trailer_v1_t *) &file.bytes[startuptrailer_offset];
+            image_header = (image_header_t *) &file.bytes[imageheader_offset]; // fix the pointers that might have changed
+         }
          // layout:
          // [IMAGE HEADER]
          // [image directory entries]
          // [smallest file blobs up to KERNEL]

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/dump.c – Rev 16 → 26