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

 // ifstool.c -- portable reimplementation of QNX's mkifs by Pierre-Marie Baty <pm@pmbaty.com>
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <ctype.h>
 #define S_IFLNK 0xa000
 #define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
 #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
 #define strdup(s) _strdup ((s))
+#define strcasecmp(s1,s2) _stricmp ((s1), (s2))
 #define fseek(fp,off,m) _fseeki64 ((fp), (off), (m))
 #define access(p,m) _access ((p), (m))
 #define MAXPATHLEN 1024
 #else // !_MSC_VER
 #include <sys/param.h>
    "\x88\x00" /*size*/ "\x00" /*type*/ "\x00" /*spare*/ "\x00" /*CPU mask*/ "\x00" /*flags*/ "\x00\x00" /*reserved*/ "\x00" /*policy*/ "\x00" /*priority*/ "\02" /*argc*/ "\x02" /*envc*/ "sh\0" /*executable*/ "sh\0" "/proc/boot/startup.sh\0" /*argv*/ "PATH=/sbin:/usr/sbin:/bin:/usr/bin:/proc/boot\0" "LD_LIBRARY_PATH=/proc/boot:/lib:/lib/dll:/usr/lib\0" /*envp*/ \
    /* display_msg "Startup complete */ \
    "\x18\x00" /*size*/ "\x03" /*type*/ "\x00" /*spare*/ "Startup complete\n\0" "\x00\00" /*padding*/ \
    /* trailer */ \
    "\x00\x00\x00\x00"
-#define INITIAL_STARTUP_SCRIPT_LEN (sizeof (INITIAL_STARTUP_SCRIPT) - 1)
-typedef struct fsentry_s
+typedef struct __attribute__((packed)) fsentry_s
+{
    struct __attribute__((packed)) fsentry_header_s
+   {
       uint16_t size; // size of dirent
       uint16_t extattr_offset; // if zero, no extattr data
       uint32_t mode; // mode and perms of entry
       uint32_t gid;
       uint32_t uid;
       uint32_t mtime;
    } header;
-   union fsentry_specific_u
+   union __attribute__((packed)) fsentry_specific_u
+   {
-      struct fsentry_file_s // when (mode & S_IFMT) == S_IFREG
+      struct __attribute__((packed)) fsentry_file_s // when (mode & S_IFMT) == S_IFREG
+      {
          uint32_t offset; // offset from header
          uint32_t size;
          char *path; // null terminated path (no leading slash)
          char *UNSAVED_databuf; // file data blob buffer (NOT SAVED IN THE IFS)
       } file;
-      struct fsentry_dir_s // when (mode & S_IFMT) == S_IFDIR
+      struct __attribute__((packed)) fsentry_dir_s // when (mode & S_IFMT) == S_IFDIR
+      {
          char *path; // null terminated path (no leading slash)
       } dir;
-      struct fsentry_symlink_s // when (mode & S_IFMT) == S_IFLNK
+      struct __attribute__((packed)) fsentry_symlink_s // when (mode & S_IFMT) == S_IFLNK
+      {
          uint16_t sym_offset; // offset to 'contents' from 'path'
          uint16_t sym_size; // strlen (contents)
          char *path; // null terminated path (no leading slash)
          char *contents; // null terminated symlink contents
       } symlink;
-      struct fsentry_device_s // when (mode & S_IFMT) == S_IF<CHR|BLK|FIFO|NAM|SOCK>
+      struct __attribute__((packed)) fsentry_device_s // when (mode & S_IFMT) == S_IF<CHR|BLK|FIFO|NAM|SOCK>
+      {
          uint32_t dev;
          uint32_t rdev;
          char *path; // null terminated path (no leading slash)
       } device;
 typedef struct __attribute__((packed)) startup_trailer_s
+{
    uint32_t cksum; // checksum from start of header to start of trailer
-} startup_trailer_t;
+} startup_trailer_v1_t;
 // NOTE: The checksums in this trailer will only be valid prior to entering startup.
 // Because the startup binary is executed in-place, its data segment will change once the program is running.
 // Hence, any checksum validation would need to be done by the boot loader / IFS.
 typedef struct __attribute__((packed)) image_trailer_v1_s
+{
    uint32_t cksum; // checksum from start of header to start of trailer
-} image_trailer_v1_t;
+} image_trailer_v1_t; // NOTE: this is the same structure as startup_trailer_v1_t
 // NOTE: the checksums in this trailer will only be valid until the first non-startup bootstrap binary (e.g., startup-verifier, procnto, ...) is invoked.
 // Because bootstrap binaries execute in-place, their data segments will change once the programs are running.
 // Hence, any checksum validation would need to be done either by the boot loader / IFS or by the startup.
 typedef struct __attribute__((packed)) image_trailer_v2_s
+{
    uint8_t sha512[64]; // SHA512 from start of image header to start of trailer
    uint32_t cksum; // checksum from start of header to start of this member
-} image_trailer_v2_t;
+} image_trailer_v2_t; // NOTE: this is the same structure as startup_trailer_v2_t
 #ifdef _MSC_VER
 #pragma pack(pop)
 #endif // _MSC_VER
    int perms; // file permissions (e.g. 0644)
    int uid; // owner user ID (e.g. 0 = root)
    int gid; // owner group ID (e.g. 0 = root)
    int st_mode; // entry type (e.g. S_IFREG for files) and permissions
    char prefix[MAXPATHLEN]; // install path (e.g. "proc/boot")
-   bool should_compile_contents_as_startup_script;
+   bool is_compiled_bootscript; // entry has [+script] attribute
    char search[10 * MAXPATHLEN]; // binary search path (the default one will be constructed at startup)
+   uint8_t *precompiled_data;
+   size_t precompiled_datalen;
 } parms_t;
 // global variables
 static char line_buffer[4096]; // scrap buffer for the IFS build file parser
 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 int update_checksum_int32s (const int32_t start_value, const int32_t *data, const size_t len); // update the sum of an array of 32-bit signed integers
+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 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
 static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp); // writes the given filesystem entry into fp (without its contents)
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, const char *stored_pathname, parms_t *entry_parms, const uint8_t *data, const size_t entry_datalen); // stack up a new filesystem entry
 static int fsentry_compare_pathnames_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by pathnames
 static int fsentry_compare_sizes_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by size
+static int dump_ifs_info (const char *ifs_pathname); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
 static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data)
+{
    // logical functions used in SHA-384 and SHA-512
    #undef SHA512_SHORT_BLOCK_LENGTH
    return;
+}
-static uint8_t *SHA512 (void *data, size_t data_len, uint8_t *digest)
+static uint8_t *SHA512 (void *data, size_t data_len, uint8_t *digest_or_NULL)
+{
-   // computes the SHA-512 hash of a block of data in one pass and write it to digest
+   // computes the SHA-512 hash of a block of data in one pass and write it to digest, or to a static buffer if NULL
+   // returns the STRING REPRESENTATION of digest in a statically-allocated string
+   static uint8_t static_digest[SHA512_DIGEST_LENGTH] = "";
+   static char digest_as_string[2 * SHA512_DIGEST_LENGTH + 1] = "";
    SHA512_CTX ctx;
+   size_t byte_index;
    SHA512_Init (&ctx);
    SHA512_Update (&ctx, data, data_len);
+   if (digest_or_NULL == NULL)
+      digest_or_NULL = static_digest;
-   SHA512_Final (digest, &ctx);
+   SHA512_Final (digest_or_NULL, &ctx);
+   for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
+      sprintf (&digest_as_string[2 * byte_index], "%02x", digest_or_NULL[byte_index]);
-   return (digest);
+   return (digest_as_string);
+}
-static int update_checksum_int32s (const int32_t start_value, const int32_t *data, const size_t len)
+static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t len)
+{
    // compute the sum of an array of 32-bit signed integers
-   size_t byte_index;
+   const int32_t *values_array = data;
    int32_t sum = start_value;
-   for (byte_index = 0; byte_index < len; byte_index += sizeof (int32_t))
+   for (size_t value_index = 0; value_index < len / sizeof (int32_t); value_index++)
-      sum += *data++;
+      sum += values_array[value_index];
    return (sum);
+}
 static long long read_integer (const char *str)
       else if ((*endptr == 'm') || (*endptr == 'M')) ret *= (size_t) 1024 * 1024;
       else if ((*endptr == 'g') || (*endptr == 'G')) ret *= (size_t) 1024 * 1024 * 1024;
       else if ((*endptr == 't') || (*endptr == 'T')) ret *= (size_t) 1024 * 1024 * 1024 * 1024; // future-proof enough, I suppose?
+   }
    return (ret);
+}
+static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...)
+{
+   // this function logs hexadecimal data to an opened file pointer (or to stdout/stderr)
+   va_list argptr;
+   size_t index;
+   int i;
+   // concatenate all the arguments in one string and write it to the file
+   va_start (argptr, fmt);
+   vfprintf (fp, fmt, argptr);
+   va_end (argptr);
+   // for each row of howmany_columns bytes of data...
+   for (index = 0; index < data_size; index += howmany_columns)
+   {
+      fprintf (fp, "    %05zu  ", index); // print array address of row
+      for (i = 0; i < howmany_columns; i++)
+         if (index + i < data_size)
+            fprintf (fp, " %02X", data[index + i]); // if row contains data, print data as hex bytes
+         else
+            fprintf (fp, "   "); // else fill the space with blanks
+      fprintf (fp, "   ");
+      for (i = 0; i < howmany_columns; i++)
+         if (index + i < data_size)
+            fputc ((data[index + i] >= 32) && (data[index + i] < 127) ? data[index + i] : '.', fp); // now if row contains data, print data as ASCII
+         else
+            fputc (' ', fp); // else fill the space with blanks
+      fputc ('\n', fp);
+   }
+   return; // and return
+}
+static char *binary (const uint8_t x, char char_for_zero, char char_for_one)
+{
+   // returns the binary representation of x as a string
+   static char outstr[9] = "00000000";
+   for (int i = 0; i < 8; i++)
+      outstr[i] = (x & (0x80 >> i) ? char_for_one : char_for_zero);
+   return (outstr);
+}
+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 char *default_bitstrings[8] = { "bit0", "bit1", "bit2", "bit3", "bit4", "bit5", "bit6", "bit7" };
+   static char outstr[8 * 64] = "";
+   outstr[0] = 0;
+   for (int i = 0; i < 8; i++)
+      if (x & (1 << i))
+      {
+         if (outstr[0] != 0)
+            strcat (outstr, "|");
+         strcat (outstr, ((bitwise_stringdescs != NULL) && (*bitwise_stringdescs[i] != 0) ? bitwise_stringdescs[i] : default_bitstrings[i]));
+      }
+   return (outstr);
+}
 static int fwrite_filecontents (const char *pathname, FILE *fp)
+{
    void *reallocated_ptr;
    char processor_base[16];
    struct stat stat_buf;
    uint8_t *data_buffer = NULL;
    size_t data_len = 0;
-   uint32_t mtime = 0;
+   uint32_t mtime = (uint32_t) time (NULL);
    uint32_t extra_ino_flags = 0;
    fsentry_t *fsentry;
    char *token;
    FILE *fp;
+      {
          if (strcmp (stored_pathname, "proc/boot/boot") == 0) // is it the kernel ?
+         {
             // HACK: for now just consider the kernel as a binary blob
             // FIXME: reimplement properly
-            if (stat ("procnto-smp-instr.bin", &stat_buf) != 0)
-            {
-               fprintf (stderr, "fatal error: unable to read procnto-smp-instr.bin\n");
-               exit (1);
-            }
-            data_len = stat_buf.st_size;
+            data_len = entry_datalen;
-            mtime = (uint32_t) time (NULL);
             data_buffer = malloc (data_len);
             if (data_buffer == NULL)
+            {
                fprintf (stderr, "fatal error: out of memory\n");
                exit (1);
+            }
-            fp = fopen ("procnto-smp-instr.bin", "rb");
-            fread (data_buffer, 1, data_len, fp);
+            memcpy (data_buffer, entry_data, data_len);
-            fclose (fp);
-            sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix);
+            sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix); // fix the entry name
             stored_pathname = candidate_pathname;
-            extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE;
+            extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
             image_kernel_ino = extra_ino_flags | (inode_count + 1);
+         }
-         else if (entry_parms->should_compile_contents_as_startup_script) // should we compile this contents as a startup script ?
+         else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?
+            image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
+         // should we substitute precompiled data to this data blob ?
+         if ((entry_parms->precompiled_data != NULL) && (entry_parms->precompiled_datalen > 0))
+         {
-            // HACK: for now just use a precompiled script
+            data_len = entry_parms->precompiled_datalen;
-            // FIXME: replace this with a true compilation with the rules defined above
-            data_buffer = malloc (INITIAL_STARTUP_SCRIPT_LEN);
+            data_buffer = malloc (data_len);
             if (data_buffer == NULL)
+            {
                fprintf (stderr, "fatal error: out of memory\n");
                exit (1);
+            }
-            memcpy (data_buffer, INITIAL_STARTUP_SCRIPT, INITIAL_STARTUP_SCRIPT_LEN);
+            memcpy (data_buffer, entry_parms->precompiled_data, data_len);
-            data_len = INITIAL_STARTUP_SCRIPT_LEN;
-            image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
+         }
-         else // else it's an explicit blob of some other sort
+         else // else use the supplied data blob
+         {
             data_len = entry_datalen;
-            mtime = (uint32_t) time (NULL);
             data_buffer = malloc (data_len);
             if (data_buffer == NULL)
+            {
                fprintf (stderr, "fatal error: out of memory\n");
                exit (1);
+            }
             memcpy (data_buffer, entry_data, data_len);
+         }
+/*
+         else if (entry_parms->should_compile_contents_as_startup_script) // should we compile this contents as a startup script ?
+         {
+            // HACK: for now just use a precompiled script
+            // FIXME: replace this with a true compilation with the rules defined above
+            data_buffer = malloc (INITIAL_STARTUP_SCRIPT_LEN);
+            if (data_buffer == NULL)
+            {
+               fprintf (stderr, "fatal error: out of memory\n");
+               exit (1);
+            }
+            memcpy (data_buffer, INITIAL_STARTUP_SCRIPT, INITIAL_STARTUP_SCRIPT_LEN);
+            data_len = INITIAL_STARTUP_SCRIPT_LEN;
+            image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
+         }*/
          fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)\n", extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, data_len);
+      }
       else if ((entry_data != NULL) && (entry_data[0] != 0)) // else entry_datalen == 0, was some sort of pathname supplied ?
+      {
+      }
+   }
    else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?
+   {
       data_len = strlen (entry_data);
-      mtime = (uint32_t) time (NULL);
       data_buffer = malloc (data_len + 1);
       if (data_buffer == NULL)
+      {
          fprintf (stderr, "fatal error: out of memory\n");
+{
    // program entrypoint
    #define PAD_OUTFILE_TO(val) do { curr_offset = ftell (fp); while (curr_offset < (val)) { putc (0, fp); curr_offset++; } } while (0)
-   startup_header_t startup_header = { 0 }; // output IFS's startup header
+   static startup_header_t startup_header = { 0 }; // output IFS's startup header
-   startup_trailer_v2_t startup_trailer = { 0 }; // output IFS's startup trailer (version 2, with SHA-512 checksum and int32 checksum)
+   static startup_trailer_v2_t startup_trailer = { 0 }; // output IFS's startup trailer (version 2, with SHA-512 checksum and int32 checksum)
-   image_header_t image_header = { 0 }; // output IFS's imagefs header
+   static image_header_t image_header = { 0 }; // output IFS's imagefs header
-   image_trailer_v2_t image_trailer = { 0 }; // output IFS's imagefs trailer (version 2, with SHA-512 checksum and int32 checksum)
+   static image_trailer_v2_t image_trailer = { 0 }; // output IFS's imagefs trailer (version 2, with SHA-512 checksum and int32 checksum)
-   fsentry_t *fsentries = NULL; // output IFS's filesystem entries
+   static fsentry_t *fsentries = NULL; // output IFS's filesystem entries
-   size_t fsentry_count = 0; // number of entries in the IFS filesystem
+   static size_t fsentry_count = 0; // number of entries in the IFS filesystem
-   parms_t default_parms = { 0755, 0644, 0, 0, S_IFREG, "/proc/boot", false, "" }; // default parameters for a filesystem entry
+   static parms_t default_parms = { 0755, 0644, 0, 0, S_IFREG, "/proc/boot", false, "", NULL, 0 }; // default parameters for a filesystem entry
-   parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
+   static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
    // bootable IFS support
    char *bootfile_pathname = NULL;           // HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS
+   size_t bootfile_size = 0;                 // HACK: size of the bootcode binary blob file to put at the start of a bootable IFS
    char *startupfile_pathname = NULL;        // HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS
    size_t startupfile_ep_from_imagebase = 0; // HACK: startup code entrypoint offset from image base for a bootable IFS
    char *kernelfile_pathname = NULL;         // HACK: pathname to precompiled kernel file blob to put in a bootable IFS
    size_t kernelfile_offset = 0;             // HACK: kernel file offset in bootable IFS
    char path_in_ifs[MAXPATHLEN];
-   char image_bootfile[MAXPATHLEN];
-   size_t image_bootfilesize = 0;
    char *ifs_pathname = NULL;
    void *reallocated_ptr;
    struct stat stat_buf;
    size_t startuptrailer_offset;
    size_t startupheader_offset;
       else if (ifs_pathname == NULL)
          ifs_pathname = argv[arg_index];
+   }
    // do we not have enough information to run ?
-   if (want_help || (ifs_pathname == NULL) || (!want_info && (buildfile_pathname == NULL)))
+   if (want_help || (buildfile_pathname == NULL) || (!want_info && (ifs_pathname == NULL)))
+   {
       if (want_help)
          fprintf (stdout, "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");
       else
          fprintf (stderr, "error: missing parameters\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] <buildfile> <outfile>\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool --info <ifs file>\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool --help\n");
       exit (want_help ? 0 : 1);
+   }
+   // do we want info about a particular IFS ? if so, dump it
+   if (want_info)
+      exit (dump_ifs_info (buildfile_pathname)); // NOTE: the first argument after --info is actually the IFS file, not a build file, but the arguments are collected in this order
    // make sure we have ${QNX_TARGET} pointing somewhere
    QNX_TARGET = getenv ("QNX_TARGET");
    if (QNX_TARGET == NULL)
+   {
                   *sep = 0;
                   strcpy (image_processor, value); // save processor
                   value = sep + 1;
+               }
                //sprintf (image_bootfile, "%s/%s/boot/sys/%s.boot", QNX_TARGET, image_processor, value); // save preboot file name (FIXME: we should search in MKIFS_PATH instead of this. Not important.)
-               strcpy (image_bootfile, bootfile_pathname); // FIXME: HACK
+               //strcpy (image_bootfile, bootfile_pathname); // FIXME: HACK
-               if (stat (image_bootfile, &stat_buf) != 0)
+               if (stat (bootfile_pathname, &stat_buf) != 0)
+               {
-                  fprintf (stderr, "error: unable to stat the boot file \"%s\" specified in \"%s\" line %d: %s\n", image_bootfile, buildfile_pathname, lineno, strerror (errno));
+                  fprintf (stderr, "error: unable to stat the boot file \"%s\" specified in \"%s\" line %d: %s\n", bootfile_pathname, buildfile_pathname, lineno, strerror (errno));
                   exit (1);
+               }
-               image_bootfilesize = stat_buf.st_size; // save preboot file size
+               bootfile_size = stat_buf.st_size; // save preboot file size
-               fprintf (stderr, "info: processor \"%s\" bootfile \"%s\"\n", image_processor, image_bootfile);
+               fprintf (stderr, "info: processor \"%s\" bootfile \"%s\"\n", image_processor, bootfile_pathname);
+               if (stat (kernelfile_pathname, &stat_buf) != 0)
+               {
+                  fprintf (stderr, "fatal error: unable to read precompiled kernel file \"%s\" specified in --kernelfile argument\n", kernelfile_pathname);
+                  exit (1);
+               }
+               entry_parms.precompiled_data = malloc (stat_buf.st_size);
+               if (entry_parms.precompiled_data == NULL)
+               {
+                  fprintf (stderr, "fatal error: out of memory\n");
+                  exit (1);
+               }
+               fp = fopen ("procnto-smp-instr.bin", "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) {
+               entry_parms.is_compiled_bootscript = true;
+               entry_parms.precompiled_data = INITIAL_STARTUP_SCRIPT; // HACK until the script compiler is implemented
+               entry_parms.precompiled_datalen = sizeof (INITIAL_STARTUP_SCRIPT) - 1;
+            }
-            else if (strcmp (token, "+script") == 0) entry_parms.should_compile_contents_as_startup_script = true;
             else fprintf (stderr, "warning: unimplemented attribute in \"%s\" line %d: '%s'\n", buildfile_pathname, lineno, token);
             #undef REACH_TOKEN_VALUE
             token = strtok (NULL, RECORD_SEP_STR); // proceed to next attribute token
+         }
             APPLY_DEFAULT_ATTR_NUM (perms,   "file permissions",      "0%o");
             APPLY_DEFAULT_ATTR_NUM (uid,     "owner ID",              "%d");
             APPLY_DEFAULT_ATTR_NUM (gid,     "group ID",              "%d");
             APPLY_DEFAULT_ATTR_NUM (st_mode, "inode type",            "0%o");
             APPLY_DEFAULT_ATTR_STR (prefix,  "prefix",                "\"%s\"");
-            APPLY_DEFAULT_ATTR_NUM (should_compile_contents_as_startup_script, "compiled script state", "%d");
+            APPLY_DEFAULT_ATTR_NUM (is_compiled_bootscript, "compiled script state", "%d");
             #undef APPLY_DEFAULT_ATTR_STR
             #undef APPLY_DEFAULT_ATTR_NUM
             continue; // end of line reached, proceed to the next line
+         }
          // end of attributes parsing
+   {
       fprintf (stderr, "error: failed to open \"%s\" for writing (%s)\n", ifs_pathname, strerror (errno));
       exit (1);
+   }
-   // do we have a boot file ? if so, this is a bootable image
+   // do we have a startup file ? if so, this is a bootable image
-   if (image_bootfile[0] != 0)
+   if (startupfile_pathname != NULL)
+   {
       // write boot prefix
-      fwrite_filecontents (image_bootfile, fp);
+      fwrite_filecontents (bootfile_pathname, fp);
       PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
       startupheader_offset = ftell (fp); // save startup header offset
       memset (&startup_header, 0, sizeof (startup_header)); // prepare startup header
       memcpy (startup_header.signature, "\xeb\x7e\xff\x00", 4); // startup header signature, i.e. 0xff7eeb
+      {
          fprintf (stderr, "fatal error: unsupported processor type '%s' found in build file \"%s\"\n", image_processor, buildfile_pathname);
          exit (1);
+      }
       startup_header.startup_vaddr = image_base + (uint32_t) startupfile_ep_from_imagebase; // [I ] Virtual Address to transfer to after IPL is done, here 0x01403008 (appears in "Entry" column for "startup.*")
-      startup_header.image_paddr   = image_base + (uint32_t) image_bootfilesize;            // F[IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)
+      startup_header.image_paddr   = image_base + (uint32_t) bootfile_size;                 // F[IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)
       startup_header.ram_paddr     = startup_header.image_paddr;                            // [IS] Physical address of RAM to copy image to (startup_size bytes copied), here 0x01400f30 (same as above)
       startup_header.ram_size      = WILL_BE_FILLED_LATER;                                  // [ S] Amount of RAM used by the startup program and executables contained in the file system, here 0x00cd6128 i.e. 13 459 752 dec. which is 13 Mb. i.e. IFS file size minus 0x9eee (40686)
       startup_header.startup_size  = WILL_BE_FILLED_LATER;                                  // [I ] Size of startup (never compressed), here 0x02f148 or 192 840 bytes
-      startup_header.stored_size   = startup_header.ram_size;                               // [I ] Size of entire image, here 0x00cd6128 (same as ram_size)
+      startup_header.stored_size   = WILL_BE_FILLED_LATER;                                  // [I ] Size of entire image, here 0x00cd6128 (same as ram_size)
       startup_header.imagefs_size  = WILL_BE_FILLED_LATER;                                  // [ S] Size of uncompressed imagefs, here 0x00ca6fe0 or 13 266 912 bytes
-      startup_header.preboot_size  = (uint16_t) image_bootfilesize;                         // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))
+      startup_header.preboot_size  = (uint16_t) bootfile_size;                              // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))
       fwrite (&startup_header, sizeof (startup_header), 1, fp); // write startup header
       PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
       // ######################################################################################################################################################################################################################################
       // # FIXME: figure out how to re-create it: linker call involved
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
       fwrite_fsentry (&fsentries[fsentry_index], fp);
    PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
    // is it a bootable image with a kernel file ?
-   if ((image_bootfile[0] != 0) && (kernelfile_pathname != NULL))
+   if ((startupfile_pathname != NULL) && (kernelfile_pathname != NULL))
+   {
       // sort the filesystem entries by sizes
       qsort (fsentries, fsentry_count, sizeof (fsentry_t), fsentry_compare_sizes_cb);
       // write as many small files as we can before reaching the kernel offset
+   {
       fprintf (stderr, "error: image file \"%s\" size %zd exceeds max size (%zd)\n", ifs_pathname, final_size, (size_t) image_maxsize);
       exit (1);
+   }
-   // do we have a boot file ? if so, this is a bootable image
+   // do we have a startup file ? if so, this is a bootable image
-   if (image_bootfile[0] == 0)
+   if (startupfile_pathname != NULL)
+   {
       // rewrite startup header with final values
       fseek (fp, startupheader_offset, SEEK_SET);
       startup_header.startup_size = (uint32_t) (imgheader_offset - startupheader_offset); // size of startup header up to image header
       startup_header.imagefs_size = (uint32_t) (final_size - imgheader_offset); // size of uncompressed imagefs
       startup_header.ram_size = (uint32_t) final_size; // FIXME: this is necessarily a bit less, but should we really bother calculating the right size ?
+      startup_header.stored_size = startup_header.ram_size;
       fwrite (&startup_header, sizeof (startup_header), 1, fp); // write startup header
       // compute SHA-512 checksum and V1 checksum of startup block
       blob_datasize = startuptrailer_offset - startupheader_offset;
       blob_data = malloc (blob_datasize);
+      }
       fseek (fp, startupheader_offset, SEEK_SET);
       fread (blob_data, 1, blob_datasize, fp);
       SHA512 (blob_data, blob_datasize, startup_trailer.sha512); // compute SHA512 checksum
       startup_trailer.cksum = 0; // compute old checksum
-      startup_trailer.cksum = update_checksum_int32s (startup_trailer.cksum, (const int32_t *) blob_data, blob_datasize);
+      startup_trailer.cksum = update_checksum32 (startup_trailer.cksum, (const uint32_t *) blob_data, blob_datasize);
-      startup_trailer.cksum = update_checksum_int32s (startup_trailer.cksum, (const int32_t *) startup_trailer.sha512, sizeof (startup_trailer.sha512));
+      startup_trailer.cksum = update_checksum32 (startup_trailer.cksum, (const uint32_t *) startup_trailer.sha512, sizeof (startup_trailer.sha512));
       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
+   }
    fseek (fp, imgheader_offset, SEEK_SET);
    fread (blob_data, 1, blob_datasize, fp);
    SHA512 (blob_data, blob_datasize, image_trailer.sha512); // compute SHA512 checksum
    image_trailer.cksum = 0; // compute old checksum
-   image_trailer.cksum = update_checksum_int32s (image_trailer.cksum, (const int32_t *) blob_data, blob_datasize);
+   image_trailer.cksum = update_checksum32 (image_trailer.cksum, (const uint32_t *) blob_data, blob_datasize);
-   image_trailer.cksum = update_checksum_int32s (image_trailer.cksum, (const int32_t *) image_trailer.sha512, sizeof (image_trailer.sha512));
+   image_trailer.cksum = update_checksum32 (image_trailer.cksum, (const uint32_t *) image_trailer.sha512, sizeof (image_trailer.sha512));
    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
    // finished, close IFS file and exit with a success code
    fclose (fp);
    fprintf (stdout, "Success\n");
    exit (0);
+}
+static int dump_ifs_info (const char *ifs_pathname)
+{
+   #define hex_printf(buf,size,...) hex_fprintf (stdout, (buf), (size), 16, __VA_ARGS__) // use 16 columns in hex output to stdout
+   #define BINARY(x) binary ((x), '-', 'x')
+   static const char *startupheader_flags1_strings[8] = {
+      "VIRTUAL", // bit 0
+      "BIGENDIAN", // bit 1
+      "COMPRESS_BIT1", // bit 2
+      "COMPRESS_BIT2", // bit 3
+      "COMPRESS_BIT3", // bit 4
+      "TRAILER_V2", // bit 5
+      "", // bit 6
+      "", // bit 7
+   };
+   static const char *imageheader_flags_strings[8] = {
+      "BIGENDIAN", // bit 0
+      "READONLY", // bit 1
+      "INO_BITS", // bit 2
+      "SORTED", // bit 3
+      "TRAILER_V2", // bit 4
+      "", // bit 5
+      "", // bit 6
+      "", // bit 7
+   };
+   startup_header_t *startup_header = NULL;
+   startup_trailer_v1_t *startup_trailer_v1 = NULL;
+   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;
+   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;
+   size_t bootfile_blobsize = 0;
+   size_t current_offset;
+   size_t byte_index;
+   uint32_t recorded_checksum;
+   uint32_t computed_checksum;
+   uint8_t *filedata;
+   size_t filesize;
+   time_t mtime;
+   FILE *fp;
+   // open and read IFS file
+   fp = fopen (ifs_pathname, "rb");
+   if (fp == NULL)
+   {
+      fprintf (stderr, "error: can't open \"%s\" for reading: %s\n", ifs_pathname, strerror (errno));
+      return (1);
+   }
+   fseek (fp, 0, SEEK_END);
+   filesize = ftell (fp);
+   filedata = malloc (filesize);
+   if (filedata == NULL)
+   {
+      fprintf (stderr, "fatal error: out of memory\n");
+      exit (1);
+   }
+   fseek (fp, 0, SEEK_SET);
+   fread (filedata, 1, filesize, fp);
+   fclose (fp);
+   printf ("IFS file \"%s\" - size 0x%zx (%zd) bytes\n", ifs_pathname, filesize, filesize);
+   // parse file from start to end
+   current_offset = 0;
+   for (;;)
+   {
+      // does a startup header start here ?
+      if ((current_offset + sizeof (startup_header_t) < filesize) && (memcmp (&filedata[current_offset], "\xeb\x7e\xff\x00", 4) == 0))
+      {
+         startup_header = (startup_header_t *) &filedata[current_offset];
+         // layout:
+         // [STARTUP HEADER]
+         // (startup file blob)
+         // [STARTUP TRAILER v1 or v2]
+         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" : "???"));
+         printf ("   flags1        = 0x%02x (%s)\n", startup_header->flags1, describe_uint8 (startup_header->flags1, startupheader_flags1_strings));
+         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 == STARTUP_HDR_MACHINE_X86_64 ? "x86_64" : (startup_header->machine == STARTUP_HDR_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)) < filesize ? "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 ("   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"));
+         printf ("   addr_off      = 0x%016llx (%lld) - offset for startup_vaddr and [image|ram|imagefs]_paddr - %s\n", startup_header->addr_off, startup_header->addr_off, (startup_header->addr_off == 0 ? "looks good" : "??? should be zero"));
+         hex_printf ((uint8_t *) &startup_header->info[0], sizeof (startup_header->info), "   info[48] =\n");
+         // validate that the file can contain up to the startup trailer
+         if (current_offset + startup_header->startup_size > filesize)
+         {
+            fprintf (stderr, "WARNING: this IFS file is too short (startup trailer would be past end of file)\n");
+            break;
+         }
+         // locate the right startup trailer at the right offset
+         if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
+         {
+            startup_trailer_v2 = (startup_trailer_v2_t *) &filedata[current_offset + startup_header->startup_size - sizeof (startup_trailer_v2_t)];
+            startupfile_blobsize = startup_header->startup_size - sizeof (startup_header_t) - sizeof (startup_trailer_v2_t);
+         }
+         else // old V1 trailer
+         {
+            startup_trailer_v1 = (startup_trailer_v1_t *) &filedata[current_offset + startup_header->startup_size - sizeof (startup_trailer_v1_t)];
+            startupfile_blobsize = startup_header->startup_size - sizeof (startup_header_t) - sizeof (startup_trailer_v1_t);
+         }
+         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, (uint32_t *) &filedata[current_offset], startupfile_blobsize));
+         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, (uint32_t *) startup_header, sizeof (startup_header) + startupfile_blobsize + 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 = startup_trailer_v1->cksum;
+            computed_checksum = update_checksum32 (0, (uint32_t *) startup_header, sizeof (startup_header) + startupfile_blobsize);
+            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
+      }
+      // else does an image header start here ?
+      else if ((current_offset + sizeof (image_header_t) < filesize) && (memcmp (&filedata[current_offset], "imagefs", 7) == 0))
+      {
+         imageheader_offset = current_offset;
+         image_header = (image_header_t *) &filedata[imageheader_offset];
+         // layout:
+         // [IMAGE HEADER]
+         // [image directory entries]
+         // [file blobs up to KERNEL]
+         // [padding]
+         // [KERNEL]
+         // [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);
+         printf ("   flags        = 0x%02x (%s)\n", image_header->flags, describe_uint8 (image_header->flags, imageheader_flags_strings));
+         printf ("   image_size   = 0x%08x (%d) - size from header to end of trailer - %s\n", image_header->image_size, image_header->image_size, (current_offset + image_header->image_size <= filesize ? "looks good" : "BAD (IFS file too short)"));
+         printf ("   hdr_dir_size = 0x%08x (%d) - size from header to last dirent - %s\n", image_header->hdr_dir_size, image_header->hdr_dir_size, (current_offset + image_header->hdr_dir_size < filesize ? "looks good" : "BAD (IFS file too short)"));
+         printf ("   dir_offset   = 0x%08x (%d) - offset from header to first dirent - %s\n", image_header->dir_offset, image_header->dir_offset, (current_offset + image_header->dir_offset >= filesize ? "BAD (IFS file too short)" : (image_header->dir_offset > image_header->hdr_dir_size ? "BAD" : "looks good")));
+         printf ("   boot_ino[4]  = { 0x%08x, 0x%08x, 0x%08x, 0x%08x }\n", image_header->boot_ino[0], image_header->boot_ino[1], image_header->boot_ino[2], image_header->boot_ino[3]);
+         printf ("   script_ino   = 0x%08x (%d) - inode of compiled bootscript\n", image_header->script_ino, image_header->script_ino);
+         printf ("   chain_paddr  = 0x%08x (%d) - offset to next fs signature\n", image_header->chain_paddr, image_header->chain_paddr);
+         hex_printf ((uint8_t *) &image_header->spare[0], sizeof (image_header->spare), "   spare[10] =\n");
+         printf ("   mountflags   = 0x%08x (%s %s %s %s)\n", image_header->mountflags, BINARY (((uint8_t *) &image_header->mountflags)[0]), BINARY (((uint8_t *) &image_header->mountflags)[1]), BINARY (((uint8_t *) &image_header->mountflags)[2]), BINARY (((uint8_t *) &image_header->mountflags)[3]));
+         printf ("   mountpoint   = \"%s\"\n", image_header->mountpoint);
+         // validate that the file can contain up to the image trailer
+         if (current_offset + image_header->image_size > filesize)
+         {
+            fprintf (stderr, "WARNING: this IFS file is too short (image trailer would be past end of file)\n");
+            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)];
+         else // old V1 trailer
+            image_trailer_v1 = (image_trailer_v1_t *) &filedata[current_offset + image_header->image_size - sizeof (image_trailer_v1_t)];
+         current_offset += sizeof (image_header_t); // jump over the image header and reach 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);
+            current_offset += image_header->dir_offset - sizeof (image_header_t);
+         }
+         // dump all directory entries until the last one included
+         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
+            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"));
+            printf ("   ino            = 0x%08x (%d) - inode number (%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 ("   mode           = 0x%08x (%d) - %s (0%o), POSIX permissions 0%o\n", current_fsentry->header.mode, current_fsentry->header.mode, (S_ISDIR (current_fsentry->header.mode) ? "directory" : (S_ISREG (current_fsentry->header.mode) ? "file" : (S_ISLNK (current_fsentry->header.mode) ? "symlink" : "device"))), (current_fsentry->header.mode & 0xF000) >> 12, current_fsentry->header.mode & 0xFFF);
+            printf ("   gid            = 0x%08x (%d) - owner group ID%s\n", current_fsentry->header.gid, current_fsentry->header.gid, (current_fsentry->header.gid == 0 ? " (root)" : ""));
+            printf ("   uid            = 0x%08x (%d) - owner user ID%s\n", current_fsentry->header.uid, current_fsentry->header.uid, (current_fsentry->header.uid == 0 ? " (root)" : ""));
+            mtime = (time_t) current_fsentry->header.mtime;
+            printf ("   mtime          = 0x%08x (%d) - POSIX timestamp: %s", current_fsentry->header.mtime, current_fsentry->header.mtime, asctime (localtime (&mtime))); // NOTE: asctime() provides the newline
+            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] 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] 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] dev  = 0x%08x (%d)\n", current_fsentry->u.device.dev, current_fsentry->u.device.dev);
+               printf ("   [DEVICE] rdev = 0x%08x (%d)\n", current_fsentry->u.device.rdev, current_fsentry->u.device.rdev);
+               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))
+            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);
+            // now jump at the first
+         exit (0);
+      }
+      // 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
+      {
+         // so scan for the first startup header magic and version (which makes us 6 bytes to scan for, i.e. "\xeb\x7e\xff\x00" for the magic and "\x01\x00" (LSB) for the version 1)
+         for (byte_index = current_offset; byte_index < filesize - 6; byte_index++)
+            if (memcmp (&filedata[byte_index], "\xeb\x7e\xff\x00" "\x01\x00", 4 + 2) == 0)
+               break; // stop as soon as we find it
+         if (byte_index >= filesize - 6)
+            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 %d\n", update_checksum32 (0, (uint32_t *) &filedata[current_offset], bootfile_blobsize));
+         current_offset = byte_index; // now reach the next segment
+      }
+   }
+   printf ("End of identifiable data reached.\n");
+   if (current_offset < filesize)
+      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);
+   return (0);
+}

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/ifstool.c – Rev 1 → 2