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

 #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
+#ifndef thread_local
+#define thread_local __declspec(thread) // the thread_local keyword wasn't defined before C++11 and C23
+#endif // !thread_local
 #else // !_MSC_VER
 #include <sys/param.h>
 #include <unistd.h>
+#ifndef thread_local
+#define thread_local __thread // the thread_local keyword wasn't defined before C++11 and C23
+#endif // !thread_local
 #endif // _MSC_VER
 // handy macros that generate a version number in the format "YYYYMMDD" corresponding to the build date. Usage: printf ("version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
 #ifndef VERSION_ARG_YYYYMMDD
                                                      (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 30 ") ? "30" : \
                                                       (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 31 ") ? "31" : "XX"))))))))))))))))))))))))))))))) // compiler will optimize this into a const string, e.g. "14"
 #define VERSION_FMT_YYYYMMDD "%04s%02s%02s"
 #define VERSION_ARG_YYYYMMDD BUILDDATE_YEAR, BUILDDATE_MONTH, BUILDDATE_DAY
 #endif // !VERSION_ARG_YYYYMMDD
+// we don't mind about this macro's efficiency...
+#define __FILENAME__ (strrchr (__FILE__, '\\') ? strrchr (__FILE__, '\\') + 1 : (strrchr (__FILE__, '/') ? strrchr (__FILE__, '/') + 1 : __FILE__))
+// exit less brutally than with abort() if something doesn't go the way we'd like to
+#define WELLMANNERED_ASSERT(is_is_true,...) do { if (!(is_is_true)) { fprintf (stderr, "ifstool: fatal error: assertion within %s() in %s line %d failed: ", __FUNCTION__, __FILENAME__, __LINE__); fprintf (stderr, __VA_ARGS__); fputc ('\n', stderr); exit (1); } } while (0)
+// checked read/write/seek operations
+#define fseek_or_die(fp,pos,mode) do { if (fseek ((fp), (pos), (mode)) != 0) { fprintf (stderr, "ifstool: fatal error: fseek() failure within %s() in %s line %d: errno %d (%s)\n", __FUNCTION__, __FILENAME__, __LINE__, errno, strerror (errno)); exit (1); } } while (0)
+#define fread_or_die(buf,sz,len,fp) do { if (fread ((buf), (sz), (len), (fp)) != (len)) { fprintf (stderr, "ifstool: fatal error: fread() failure within %s() in %s line %d: errno %d (%s)\n", __FUNCTION__, __FILENAME__, __LINE__, errno, strerror (errno)); exit (1); } } while (0)
+#define fwrite_or_die(buf,sz,len,fp) do { if ((fwrite ((buf), (sz), (len), (fp)) != (len)) || (fflush ((fp)) != 0)) { fprintf (stderr, "ifstool: fatal error: fwrite() failure within %s() in %s line %d: errno %d (%s)\n", __FUNCTION__, __FILENAME__, __LINE__, errno, strerror (errno)); exit (1); } } while (0)
 #define ROUND_TO_UPPER_MULTIPLE(val,multiple) ((((val) + (size_t) (multiple) - 1) / (multiple)) * (multiple)) // note that val is being evaluated once, so it can be the result of a function call
 #ifdef _WIN32
 #define IS_DIRSEP(c) (((c) == '/') || ((c) == '\\'))
 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, 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 thread_local uint8_t static_digest[SHA512_DIGEST_LENGTH] = "";
-   static char digest_as_string[2 * SHA512_DIGEST_LENGTH + 1] = "";
+   static thread_local char digest_as_string[2 * SHA512_DIGEST_LENGTH + 1] = "";
    SHA512_CTX ctx;
    size_t byte_index;
    SHA512_Init (&ctx);
    for (i = 0; i < data_len; i++)
+   {
       accumulator[i % 4] = *current_char_ptr;
       if (i % 4 == 3)
          if (is_foreign_endianness)
-            image_cksum += (accumulator[3] <<  0) + (accumulator[2] <<  8) + (accumulator[1] << 16) + (accumulator[0] << 24);
+            image_cksum += (accumulator[3] << 0) + (accumulator[2] << 8) + (accumulator[1] << 16) + (accumulator[0] << 24);
          else
-            image_cksum += (accumulator[0] <<  0) + (accumulator[1] <<  8) + (accumulator[2] << 16) + (accumulator[3] << 24);
+            image_cksum += (accumulator[0] << 0) + (accumulator[1] << 8) + (accumulator[2] << 16) + (accumulator[3] << 24);
       current_char_ptr++;
+   }
    return (is_foreign_endianness ? __builtin_bswap32 (-image_cksum) : -image_cksum);
+}
 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";
+   static thread_local 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 thread_local char *default_bitstrings[8] = { "bit0", "bit1", "bit2", "bit3", "bit4", "bit5", "bit6", "bit7" };
-   static char outstr[8 * 64] = "";
+   static thread_local char outstr[8 * 64] = "";
    outstr[0] = 0;
    for (int i = 0; i < 8; i++)
       if (x & (1 << i))
+      {
 static char *read_filecontents (const char *pathname, const char *search_path, uint8_t **databuf, size_t *datalen)
+{
    // locates pathname among MKIFS_PATH, and places its contents in a buffer (caller frees). Returns resolved pathname (static buffer) or NULL.
-   /*thread_local*/ static char final_pathname[MAXPATHLEN];
+   static thread_local char final_pathname[MAXPATHLEN];
    const char *nextsep;
    const char *token;
    FILE *fp;
    if (IS_DIRSEP (pathname[0]) || (isalpha (pathname[0]) && (pathname[1] == ':') && IS_DIRSEP (pathname[2])))
       strcpy (final_pathname, pathname); // in this case, it MUST exist at its designated location (either absolute or relative to the current working directory)
    else // the path is relative, search it among the search paths we have
+   {
       // construct a potential final path using each element of the search path
-      token = search_path;
+      token = (*search_path != 0 ? search_path : NULL);
-      nextsep = &token[strcspn (token, PATH_SEP_STR)];
+      nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP_STR)] : NULL);
       while (token != NULL)
+      {
          sprintf (final_pathname, "%.*s/%s", (int) (nextsep - token), token, pathname);
          if (access (final_pathname, 0) == 0)
             break; // if a file can indeed be found at this location, stop searching
    fseek (blob_fp, 0, SEEK_SET);
    fread (blob_buffer, 1, blob_size, blob_fp);
    fclose (blob_fp);
    ret = (int) fwrite (blob_buffer, 1, blob_size, fp);
+   fflush (fp); // force flush to disk, because the C stream API is *buffered*
    free (blob_buffer);
    return (ret);
+}
    size_t datalen;
    size_t count;
    count = 0;
    if (fp != NULL)
-      fwrite (&fsentry->header, sizeof (fsentry->header), 1, fp); // write the entry header (PACKED STRUCT)
+      fwrite_or_die (&fsentry->header, 1, sizeof (fsentry->header), fp); // write the entry header (PACKED STRUCT)
    count += sizeof (fsentry->header);
    if (S_ISREG (fsentry->header.mode))
+   {
       if (fp != NULL)
+      {
-         fwrite (&fsentry->u.file.offset, sizeof (uint32_t), 1, fp); // write offset
+         fwrite_or_die (&fsentry->u.file.offset, 1, sizeof (uint32_t), fp); // write offset
-         fwrite (&fsentry->u.file.size,   sizeof (uint32_t), 1, fp); // write size
+         fwrite_or_die (&fsentry->u.file.size,   1, sizeof (uint32_t), fp); // write size
+      }
       count += 2 * sizeof (uint32_t);
       datalen = strlen (fsentry->u.file.path) + 1;
       if (fp != NULL)
-         fwrite (fsentry->u.file.path, (size_t) datalen, 1, fp); // write null-terminated path (no leading slash)
+         fwrite_or_die (fsentry->u.file.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
       count += datalen;
+   }
    else if (S_ISDIR (fsentry->header.mode))
+   {
       datalen = strlen (fsentry->u.dir.path) + 1;
       if (fp != NULL)
-         fwrite (fsentry->u.dir.path, (size_t) datalen, 1, fp); // write null-terminated path (no leading slash)
+         fwrite_or_die (fsentry->u.dir.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
       count += datalen;
+   }
    else if (S_ISLNK (fsentry->header.mode))
+   {
       if (fp != NULL)
+      {
-         fwrite (&fsentry->u.symlink.sym_offset, sizeof (uint16_t), 1, fp); // write offset
+         fwrite_or_die (&fsentry->u.symlink.sym_offset, 1, sizeof (uint16_t), fp); // write offset
-         fwrite (&fsentry->u.symlink.sym_size,   sizeof (uint16_t), 1, fp); // write size
+         fwrite_or_die (&fsentry->u.symlink.sym_size,   1, sizeof (uint16_t), fp); // write size
+      }
       count += 2 * sizeof (uint16_t);
       datalen = strlen (fsentry->u.symlink.path) + 1;
       if (fp != NULL)
-         fwrite (fsentry->u.symlink.path, (size_t) datalen, 1, fp); // write null-terminated path (no leading slash)
+         fwrite_or_die (fsentry->u.symlink.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
       count += datalen;
       datalen = strlen (fsentry->u.symlink.contents) + 1;
       if (fp != NULL)
-         fwrite (fsentry->u.symlink.contents, (size_t) datalen, 1, fp); // write null-terminated symlink contents
+         fwrite_or_die (fsentry->u.symlink.contents, 1, (size_t) datalen, fp); // write null-terminated symlink contents
       count += datalen;
+   }
    else
+   {
       if (fp != NULL)
+      {
-         fwrite (&fsentry->u.device.dev,  sizeof (uint32_t), 1, fp); // write dev number
+         fwrite_or_die (&fsentry->u.device.dev,  1, sizeof (uint32_t), fp); // write dev number
-         fwrite (&fsentry->u.device.rdev, sizeof (uint32_t), 1, fp); // write rdev number
+         fwrite_or_die (&fsentry->u.device.rdev, 1, sizeof (uint32_t), fp); // write rdev number
+      }
       count += 2 * sizeof (uint32_t);
       datalen = strlen (fsentry->u.device.path) + 1;
       if (fp != NULL)
-         fwrite (fsentry->u.device.path, (size_t) datalen, 1, fp); // write null-terminated path (no leading slash)
+         fwrite_or_die (fsentry->u.device.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
       count += datalen;
+   }
    if (count < fsentry->header.size)
+   {
       if (fp != NULL)
-         fwrite (zeropad_buffer, fsentry->header.size - count, 1, fp); // pad as necessary
+         fwrite_or_die (zeropad_buffer, 1, fsentry->header.size - count, fp); // pad as necessary
       count += fsentry->header.size - count;
+   }
    else if (count > fsentry->header.size)
+   {
       fprintf (stderr, "ERROR: attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.\n", (size_t) fsentry->header.size, count);
+}
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
-   static char candidate_pathname[1024];
+   static thread_local char candidate_pathname[1024];
    static int inode_count = 0; // will be preincremented each time this function is called
    const char *original_stored_pathname = NULL;
    const elf_dynamic_section_entry_t *dynamic_entry; // dynamic section entry
    const elf_section_header_t *shdr_shstr; // section headers strings (containing ELF sections names)
          // HACK: for now just consider the kernel as a binary blob
          // FIXME: reimplement properly
          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; // procnto needs to have these flags stamped on the inode
+         entry_parms->st_mode = S_IFREG | 0700; // procnto requires 0700 permissions
          image_kernel_ino = extra_ino_flags | (inode_count + 1);
+      }
       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
       if (entry_parms->data != NULL)
+      {
          entry_parms->mtime = entry_parms->mtime_for_inline_files;
          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, entry_parms->datalen);
+      }
-/*
-         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
-         }*/
-      else if (buildhost_pathname != NULL) // else entry_datalen == 0, was some sort of pathname supplied ?
+      else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?
+      {
-         resolved_pathname = read_filecontents (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH), &entry_parms->data, &entry_parms->datalen);
+         resolved_pathname = read_filecontents (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH), &entry_parms->data, &entry_parms->datalen); // locate the file
          if (resolved_pathname == NULL)
+         {
             fprintf (stderr, "fatal error: filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s\n", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
-            fprintf (stderr, "             v\n");
-            fprintf (stderr, "%s", current_line);
-            fprintf (stderr, "             ^\n");
             exit (1);
+         }
          stat (resolved_pathname, &stat_buf); // can't fail
          if (entry_parms->mtime == UINT32_MAX)
             entry_parms->mtime = (uint32_t) stat_buf.st_mtime;
          fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->datalen);
-      } // end if "was pathname supplied"
+      }
       // is the file we're storing a dylib and should we check for its canonical name ? FIXME: support for big endian is wrong. We should swap only if endianness is foreign, and also swap all ELF struct members below.
       if ((entry_parms->datalen > 52) // file is big enough to contain an ELF header
           && ((elf = (elf_header_t *) entry_parms->data) != NULL) // cast (necessary true)
           && (memcmp (ELF_HDR_MEMBER (elf, magic), ELF_MAGIC_STR, 4) == 0) // file starts with the ELF magic
+   {
       fsentry->u.file.offset = WILL_BE_FILLED_LATER; // will be filled later in main() when the file's data blob will be written to the output file
       fsentry->u.file.size = (uint32_t) entry_parms->datalen;
       fsentry->u.file.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
       fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->datalen);
-      if (fsentry->u.file.UNSAVED_databuf == NULL)
+      WELLMANNERED_ASSERT (fsentry->u.file.UNSAVED_databuf, "out of memory");
-      {
-         fprintf (stderr, "fatal error: out of memory\n");
-         exit (1);
-      }
       memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data, entry_parms->datalen);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.file.path) + 1, image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = false; // there *IS* data to save
+   }
    else if (S_ISLNK (entry_parms->st_mode))
+   {
       fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname) + 1);
       fsentry->u.symlink.sym_size = (uint16_t) entry_parms->datalen;
       fsentry->u.symlink.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
       fsentry->u.symlink.contents = strdup (entry_parms->data);
-      if (fsentry->u.symlink.contents == NULL)
+      WELLMANNERED_ASSERT (fsentry->u.symlink.contents, "out of memory");
-      {
-         fprintf (stderr, "fatal error: out of memory\n");
-         exit (1);
-      }
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint16_t) + sizeof (uint16_t) + (size_t) fsentry->u.symlink.sym_offset + fsentry->u.symlink.sym_size + 1, image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = true; // no data to save
+   }
    else // necessarily a device node
+   {
       data_len = strlen (processor_base);
       if ((data_len > 2) && ((processor_base[data_len - 2] == 'b') || (processor_base[data_len - 2] == 'l')) && (processor_base[data_len - 1] == 'e'))
          processor_base[data_len - 2] = 0; // if it ends with "le" or "be", strip that too
       MKIFS_PATH = malloc (10 * MAXPATHLEN); // construct a default MKIFS_PATH now
-      if (MKIFS_PATH == NULL)
-      {
-         fprintf (stderr, "fatal error: out of memory\n");
+      WELLMANNERED_ASSERT (MKIFS_PATH, "out of memory");
-         exit (1);
-      }
       sprintf (MKIFS_PATH, "." PATH_SEP_STR "%s/%s/sbin" PATH_SEP_STR "%s/%s/usr/sbin" PATH_SEP_STR "%s/%s/boot/sys" PATH_SEP_STR "%s/%s/boot/sys" PATH_SEP_STR "%s/%s/bin" PATH_SEP_STR "%s/%s/usr/bin" PATH_SEP_STR "%s/%s/lib" PATH_SEP_STR "%s/%s/lib/dll" PATH_SEP_STR "%s/%s/usr/lib", // use a platform-specific character as path separator
                QNX_TARGET, processor,
                QNX_TARGET, processor,
                QNX_TARGET, processor,
                QNX_TARGET, processor_base,
    void *reallocated_ptr;
    struct tm utc_time;
    struct stat stat_buf;
    size_t startuptrailer_offset;
    size_t startupheader_offset;
-   size_t imgtrailer_offset;
+   size_t imagetrailer_offset;
-   size_t imgheader_offset;
+   size_t imageheader_offset;
    size_t imgdir_offset;
    size_t imgdir_size;
    size_t final_size;
    size_t blob_size;
    size_t available_space;
    size_t allocated_size;
    size_t fsentry_index;
    size_t largest_index;
    size_t largest_size;
    size_t curr_offset;
+   uint8_t *blob_data;
+   int32_t checksum;
    char *specifiedpathname_start;
    char *directiveblock_start;
-   char *blob_data;
    char *write_ptr;
    char *line_ptr;
    char *token;
    char *value;
    char *sep;
    //char *ctx;
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
+   bool has_data_already = false;
    bool want_info = false;
    bool want_help = false;
    bool is_foreign_endianness;
    int string_len;
    int read_char;
    while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)
+   {
       if (current_line != NULL)
          free (current_line);
       current_line = strdup (line_buffer);
-      if (current_line == NULL)
-      {
-         fprintf (stderr, "fatal error: out of memory\n");
+      WELLMANNERED_ASSERT (current_line, "out of memory");
-         exit (1);
-      }
       lineno++; // keep track of current line number
       //fprintf (stderr, "read buildfile line %d: {%s}\n", lineno, line_buffer);
       line_ptr = line_buffer;
       while ((*line_ptr != 0) && isspace (*line_ptr))
       // reset entry values
       memcpy (&entry_parms, &default_parms, sizeof (default_parms));
       path_in_ifs[0] = 0;
       path_on_buildhost[0] = 0;
+      has_data_already = false;
       //fprintf (stderr, "parsing buildfile line %d: [%s]\n", lineno, line_ptr);
       // does this line start with an attribute block ?
       if (*line_ptr == '[')
                   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);
+               }
                bootfile_size = stat_buf.st_size; // save preboot file size
                fprintf (stderr, "info: processor \"%s\" bootfile \"%s\"\n", image_processor, bootfile_pathname);
-               if (stat (kernelfile_pathname, &stat_buf) != 0)
+               if (read_filecontents (kernelfile_pathname, ".", &entry_parms.data, &entry_parms.datalen) == NULL)
+               {
                   fprintf (stderr, "fatal error: unable to read precompiled kernel file \"%s\" specified in --kernelfile argument\n", kernelfile_pathname);
                   exit (1);
+               }
-               entry_parms.data = malloc (stat_buf.st_size);
+               has_data_already = true; // remember we already have data
-               if (entry_parms.data == NULL)
-               {
-                  fprintf (stderr, "fatal error: out of memory\n");
-                  exit (1);
-               }
-               fp = fopen (kernelfile_pathname, "rb");
-               fread (entry_parms.data, 1, stat_buf.st_size, fp);
-               fclose (fp);
-               entry_parms.datalen = stat_buf.st_size;
+            }
             else if (strncmp (token, "mtime=", 6) == 0) { REACH_TOKEN_VALUE (); if (strcmp (value, "*") == 0) entry_parms.mtime = UINT32_MAX; else {
                   // value *must* be "YYYY-MM-DD-HH:MM:SS" by specification
                   memset (&utc_time, 0, sizeof (utc_time));
                   if (sscanf (value, "%u-%u-%u-%u:%u:%u", &utc_time.tm_year, &utc_time.tm_mon, &utc_time.tm_mday, &utc_time.tm_hour, &utc_time.tm_min, &utc_time.tm_sec) != 6)
+               }
+            }
             else if (strcmp (token, "+script")     == 0) {
                entry_parms.is_compiled_bootscript = true;
                entry_parms.data = malloc (sizeof (INITIAL_STARTUP_SCRIPT) - 1);
-               if (entry_parms.data == NULL)
-               {
-                  fprintf (stderr, "fatal error: out of memory\n");
+               WELLMANNERED_ASSERT (entry_parms.data, "out of memory");
-                  exit (1);
-               }
                memcpy (entry_parms.data, INITIAL_STARTUP_SCRIPT, sizeof (INITIAL_STARTUP_SCRIPT) - 1); // FIXME: HACK until the script compiler is implemented
                entry_parms.datalen = sizeof (INITIAL_STARTUP_SCRIPT) - 1;
+               has_data_already = true; // remember we already have data
+            }
             else if (strcmp (token, "-script")     == 0) entry_parms.is_compiled_bootscript = false;
             else if (strcmp (token, "+followlink") == 0) entry_parms.should_follow_symlinks = true;
             else if (strcmp (token, "-followlink") == 0) entry_parms.should_follow_symlinks = false;
             else if (strcmp (token, "+autolink")   == 0) entry_parms.should_autosymlink_dylib = true;
                if (read_char == EOF)
+               {
                   fprintf (stderr, "fatal error: syntax error in \"%s\" line %d: unterminated contents block (end of file reached)\n", buildfile_pathname, lineno);
                   exit (1); // invalid contents block
+               }
-               else if (read_char == '\\')
+               else if ((read_char == '\\') && !is_escaped_char)
                   is_escaped_char = true; // remember the next char is escaped
                else if ((read_char == '}') && !is_escaped_char)
                   break; // found an unescaped closing bracked, stop parsing
                else
+               {
                   is_escaped_char = false; // any other char, meaning the next one will not be escaped
-                  if (entry_parms.data == NULL) // only store the contents if we do NOT know the data yet
+                  if (!has_data_already) // only store the contents if we do NOT know the data yet
+                  {
                      if (entry_parms.datalen == allocated_size) // reallocate in 4 kb blocks
+                     {
                         reallocated_ptr = realloc (entry_parms.data, allocated_size + 4096);
-                        if (reallocated_ptr == NULL)
-                        {
-                           fprintf (stderr, "fatal error: out of memory\n");
+                        WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-                           exit (1);
-                        }
                         entry_parms.data = reallocated_ptr;
                         allocated_size += 4096;
+                     }
                      entry_parms.data[entry_parms.datalen++] = read_char;
+                  }
                   if (read_char == '\n')
-                     lineno++;
+                     lineno++; // update line counter as we parse the inline content
+               }
-            }
+            } // end for
+            has_data_already = true; // remember we have data now
+         }
          else // not a content definition between { brackets }, must be either a pathname on the build host, or the target of a symlink
+         {
             is_quoted_context = (*line_ptr == '"');
             if (is_quoted_context)
             if (is_quoted_context && (*line_ptr == '"'))
                line_ptr++; // skip a possible final quote
             if (S_ISLNK (entry_parms.st_mode)) // are we storing a symlink ?
+            {
-               entry_parms.datalen = strlen (specifiedpathname_start); // if so, store the symlink target as the dirent's blob data
+               entry_parms.data = strdup (specifiedpathname_start); // if so, store the symlink target as the dirent's blob data
-               entry_parms.data = strdup (specifiedpathname_start);
+               WELLMANNERED_ASSERT (entry_parms.data, "out of memory");
-               if (entry_parms.data == NULL)
+               entry_parms.datalen = strlen (specifiedpathname_start);
-               {
-                  fprintf (stderr, "fatal error: out of memory\n");
+               has_data_already = true; // remember we have data now
-                  exit (1);
-               }
+            }
             else // it's a build host filesystem path
                strcpy (path_on_buildhost, line_ptr); // the path on the build host is given after the equal sign
+         }
+      }
       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   = 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) 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
+      fwrite_or_die (&startup_header, 1, sizeof (startup_header), 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
       // # $ x86_64-pc-nto-qnx8.0.0-ld --sysroot=${QNX_TARGET}/x86_64/ -T${QNX_TARGET}/x86_64/lib/nto.link --section-start .text=0x1401030 --no-relax ${QNX_TARGET}/x86_64/boot/sys/startup-x86 -o startup.bin.UNSTRIPPED
       // ######################################################################################################################################################################################################################################
       fwrite_filecontents (startupfile_pathname, fp); // write startup code from blob file
       PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
       startuptrailer_offset = ftell (fp); // save startup trailer offset
-      fwrite (&startup_trailer, sizeof (startup_trailer), 1, fp); // write startup trailer
+      fwrite_or_die (&startup_trailer, 1, sizeof (startup_trailer), fp); // write startup trailer
       PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+   }
-   imgheader_offset = ftell (fp); // save image header offset
+   imageheader_offset = ftell (fp); // save image header offset
    memset (&image_header, 0, sizeof (image_header)); // prepare image header
    memcpy (&image_header.signature, "imagefs", 7); // image filesystem signature, i.e. "imagefs"
    image_header.flags         = IMAGE_FLAGS_TRAILER_V2 | IMAGE_FLAGS_SORTED | IMAGE_FLAGS_INO_BITS; // endian neutral flags, 0x1c (IMAGE_FLAGS_TRAILER_V2 | IMAGE_FLAGS_SORTED | IMAGE_FLAGS_INO_BITS)
    image_header.image_size    = WILL_BE_FILLED_LATER; // size from header to end of trailer (here 0xca6fe0 or 13 266 912)
    image_header.hdr_dir_size  = WILL_BE_FILLED_LATER; // size from header to last dirent (here 0x12b8 or 4792)
    image_header.dir_offset    = sizeof (image_header); // offset from header to first dirent (here 0x5c or 92)
    image_header.boot_ino[0]   = image_kernel_ino; // inode of files for bootstrap p[ro?]g[ra?]ms (here 0xa0000002, 0, 0, 0)
    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
+   fwrite_or_die (&image_header, 1, sizeof (image_header), fp); // write image header
    PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
    // write image directory (with the wrong file offsets)
-   if (image_header.flags & IMAGE_FLAGS_SORTED)
-      qsort (&fsentries[1], fsentry_count - 1, sizeof (fsentry_t), fsentry_compare_pathnames_cb); // sort the filesystem entries by pathname
    imgdir_offset = ftell (fp);
    imgdir_size = 0; // measure image dir size on the fly
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
       imgdir_size += fwrite_fsentry (&fsentries[fsentry_index], fp); // NOTE: padding is handled in this function
-   imgdir_size += fwrite ("\0\0\0\0", 1, 4, fp); // there seems to be 4 bytes of padding after the image directory
+   fwrite_or_die ("\0\0\0\0", 1, 4, fp); // there seems to be 4 bytes of padding after the image directory
+   imgdir_size += 4;
    // is it a bootable image with a kernel file ?
    if ((startupfile_pathname != NULL) && (kernelfile_pathname != NULL))
+   {
       // start by writing the startup script data blob, if we have one
       for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
          if (fsentries[fsentry_index].header.ino == image_bootscript_ino)
-            break; // locate it
+            break; // locate the startup script directory entry
       if (fsentry_index < fsentry_count) // found it ?
+      {
          curr_offset = ftell (fp);
          if (curr_offset + fsentries[fsentry_index].u.file.size >= kernelfile_offset)
+         {
             fprintf (stderr, "error: the compiled startup script is too big (%zd bytes, max is %zd) to fit at current offset %zd\n", (size_t) fsentries[fsentry_index].u.file.size, kernelfile_offset - curr_offset, curr_offset);
             exit (1);
+         }
-         fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imgheader_offset); // save file data blob offset in file structure
+         fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
-         fwrite (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
+         fwrite_or_die (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
-//            PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
          fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
       // now write the filesystem entries that may fit before the kernel
       for (;;)
          curr_offset = ftell (fp); // see where we are
          available_space = kernelfile_offset - curr_offset; // measure the available space
          // look for the biggest one that can fit
          largest_index = 0;
-         largest_size = SIZE_MAX;
+         largest_size = 0;
          for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
+         {
             if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written || (fsentries[fsentry_index].u.file.size > available_space))
                continue; // skip all entries that don't have a separate data block, those who were written already and those that wouldn't fit
             if (fsentries[fsentry_index].u.file.size > largest_size)
+            {
                largest_size = fsentries[fsentry_index].u.file.size;
                largest_index = fsentry_index;
+            }
+         }
-         if (largest_size == SIZE_MAX)
+         if (largest_size == 0)
             break; // found none ? if so, stop searching
-         fsentries[largest_index].u.file.offset = (uint32_t) (curr_offset - imgheader_offset); // save file data blob offset in file structure
+         fsentries[largest_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
-         fwrite (fsentries[largest_index].u.file.UNSAVED_databuf, 1, fsentries[largest_index].u.file.size, fp); // write file data blob
+         fwrite_or_die (fsentries[largest_index].u.file.UNSAVED_databuf, 1, fsentries[largest_index].u.file.size, fp); // write file data blob
-//         PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
          fsentries[largest_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
       PAD_OUTFILE_TO (kernelfile_offset); // reach the kernel offset
+      // now write the QNX kernel
+      for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
+         if (fsentries[fsentry_index].header.ino == image_kernel_ino)
+            break; // locate the kernel directory entry (can't fail)
+      curr_offset = ftell (fp); // see where we are
+      fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
       // ######################################################################################################################################################################################################################################
       // # FIXME: figure out how to re-create it: linker call involved
       // # $ x86_64-pc-nto-qnx8.0.0-ld --sysroot=${QNX_TARGET}/x86_64/ -T${QNX_TARGET}/x86_64/lib/nto.link --section-start .text=0xffff800000001000 --no-relax ${QNX_TARGET}/x86_64/boot/sys/procnto-smp-instr -o procnto-smp-instr.sym.UNSTRIPPED
       // ######################################################################################################################################################################################################################################
       fwrite_filecontents (kernelfile_pathname, fp); // write kernel from blob file
       PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+      fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+   }
-   // then write all the other files
+   // then write all the other files by increasing inode number: ELF files first
    for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
+   {
-      if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written)
+      if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written // filter out anything that's not a file, and anything that's been already written
+          || (fsentries[fsentry_index].u.file.size < 4) || (memcmp (fsentries[fsentry_index].u.file.UNSAVED_databuf, ELF_MAGIC_STR, 4) != 0)) // filter out anything that's not an ELF file
          continue; // skip all entries that don't have a separate data block and those who were written already
       curr_offset = ftell (fp);
-      fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imgheader_offset); // save file data blob offset in file structure
+      fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
-      fwrite (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
+      fwrite_or_die (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
-//      PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
       fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+   }
+   for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++) // other files (non-ELF, e.g. scripts and data files) last
+   {
+      if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written) // filter out anything that's not a file, and anything that's been already written
+         continue; // skip all entries that don't have a separate data block and those who were written already
+      curr_offset = ftell (fp);
+      fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
+      fwrite_or_die (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
+      fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+   }
+   PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
    // finally, write trailer (including empty checksum)
-   imgtrailer_offset = ftell (fp); // save image trailer offset
+   imagetrailer_offset = ftell (fp); // save image trailer offset
-   fwrite (&image_trailer, sizeof (image_trailer), 1, fp); // write image trailer
+   fwrite_or_die (&image_trailer, 1, sizeof (image_trailer), fp); // write image trailer
    PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
    // if we need to pad it to a specific length, do so
    PAD_OUTFILE_TO (image_totalsize);
    final_size = ftell (fp);
    // do we have a startup file ? if so, this is a bootable image
    if (startupfile_pathname != NULL)
+   {
       // rewrite startup header with final values
-      fseek (fp, startupheader_offset, SEEK_SET);
+      fseek_or_die (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.startup_size = (uint32_t) (imageheader_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.imagefs_size = (uint32_t) (final_size - imageheader_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.ram_size = (uint32_t) final_size; // FIXME: this is necessarily less, but should we really bother calculating the right size ?
-      startup_header.stored_size = startup_header.ram_size;
+      startup_header.stored_size = (uint32_t) final_size;
-      fwrite (&startup_header, sizeof (startup_header), 1, fp); // write startup header
+      fwrite_or_die (&startup_header, 1, sizeof (startup_header), fp); // write startup header
+   }
+   // rewrite image header with final values
+   fseek_or_die (fp, imageheader_offset, SEEK_SET);
+   image_header.image_size = (uint32_t) (final_size - imageheader_offset); // size of uncompressed imagefs
+   image_header.hdr_dir_size = sizeof (image_header) + (uint32_t) imgdir_size; // size from start of image header to last dirent
+   fwrite_or_die (&image_header, 1, sizeof (image_header), fp); // write image header
+   // rewrite image directory with final offset values
+   fseek_or_die (fp, imgdir_offset, SEEK_SET);
+   if (image_header.flags & IMAGE_FLAGS_SORTED)
+      qsort (&fsentries[1], fsentry_count - 1, sizeof (fsentry_t), fsentry_compare_pathnames_cb); // sort the filesystem entries by pathname
+   for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+      fwrite_fsentry (&fsentries[fsentry_index], fp);
+   fclose (fp); // ensure everything is flushed
+   // ALL CHECKSUMS AT THE VERY END
+   blob_data = NULL;
+   read_filecontents (ifs_pathname, ".", &blob_data, &blob_size);
+   WELLMANNERED_ASSERT (blob_data, "failed to open IFS file for checksumming: %s", strerror (errno));
+   // do we have a startup file ? if so, this is a bootable image
+   if (startupfile_pathname != NULL)
+   {
       // compute SHA-512 checksum and V1 checksum of startup block
-      blob_size = startuptrailer_offset - startupheader_offset;
-      blob_data = malloc (blob_size + sizeof (startup_trailer));
-      if (blob_data == NULL)
-      {
-         fprintf (stderr, "fatal error: out of memory\n");
-         exit (1);
-      }
-      fseek (fp, startupheader_offset, SEEK_SET);
-      fread (blob_data, 1, blob_size, fp);
-      SHA512 (blob_data, blob_size, 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
-      fseek (fp, startupheader_offset, SEEK_SET);
-      fread (blob_data, 1, blob_size + SHA512_DIGEST_LENGTH, fp);
-      startup_trailer.cksum = update_checksum (blob_data, blob_size + SHA512_DIGEST_LENGTH, is_foreign_endianness); // compute old checksum
-      free (blob_data);
-      // rewrite startup trailer with final values
+      SHA512 (&blob_data[startupheader_offset], startuptrailer_offset - startupheader_offset, &blob_data[startuptrailer_offset]); // compute SHA512 checksum and write it in place in blob data
-      fseek (fp, startuptrailer_offset, SEEK_SET);
+      checksum = update_checksum (&blob_data[startupheader_offset], startuptrailer_offset + SHA512_DIGEST_LENGTH - startupheader_offset, is_foreign_endianness); // compute old checksum
-      fwrite (&startup_trailer, sizeof (startup_trailer), 1, fp); // write startup trailer
+      memcpy (&blob_data[startuptrailer_offset + SHA512_DIGEST_LENGTH], &checksum, 4); // and write it in place
+   }
-   // rewrite image header with final values
-   fseek (fp, imgheader_offset, SEEK_SET);
-   image_header.image_size = (uint32_t) (final_size - imgheader_offset); // size of uncompressed imagefs
-   image_header.hdr_dir_size = sizeof (image_header) + (uint32_t) imgdir_size; // size from start of image header to last dirent
-   fwrite (&image_header, sizeof (image_header), 1, fp); // write image header
-   // rewrite image directory with final offset values
-   fseek (fp, imgdir_offset, SEEK_SET);
-   for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-      fwrite_fsentry (&fsentries[fsentry_index], fp);
    // compute SHA-512 checksum and V1 checksum of image block
-   blob_size = imgtrailer_offset - imgheader_offset;
-   blob_data = malloc (blob_size + sizeof (image_trailer));
-   if (blob_data == NULL)
-   {
-      fprintf (stderr, "fatal error: out of memory\n");
-      exit (1);
-   }
-   fseek (fp, imgheader_offset, SEEK_SET);
-   fread (blob_data, 1, blob_size, fp);
-   SHA512 (blob_data, blob_size, image_trailer.sha512); // compute SHA512 checksum
    if (   ( (image_header.flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
        || (!(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
-   fseek (fp, imgheader_offset, SEEK_SET);
-   fread (blob_data, 1, blob_size + SHA512_DIGEST_LENGTH, fp);
-   image_trailer.cksum = update_checksum (blob_data, blob_size, is_foreign_endianness); // compute old checksum
-   free (blob_data);
-   // rewrite image trailer with final checksum values
+   SHA512 (&blob_data[imageheader_offset], imagetrailer_offset - imageheader_offset, &blob_data[imagetrailer_offset]); // compute SHA512 checksum and write it in place in blob data
-   fseek (fp, imgtrailer_offset, SEEK_SET);
+   checksum = update_checksum (&blob_data[imageheader_offset], imagetrailer_offset + SHA512_DIGEST_LENGTH - imageheader_offset, is_foreign_endianness); // compute old checksum
-   fwrite (&image_trailer, sizeof (image_trailer), 1, fp); // write image trailer
+   memcpy (&blob_data[imagetrailer_offset + SHA512_DIGEST_LENGTH], &checksum, 4); // and write it in place
-   // finished, close IFS file and exit with a success code
+   // now rewrite IFS with the correct checksums
+   fp = fopen (ifs_pathname, "wb");
+   WELLMANNERED_ASSERT (fp, "failed to reopen IFS file for checksumming: %s", strerror (errno));
+   fwrite_or_die (blob_data, 1, blob_size, fp);
    fclose (fp);
+   free (blob_data);
+   // finished, exit with a success code
    fprintf (stdout, "Success\n");
    exit (0);
+}
       "", // bit 6
       "", // bit 7
    };
    startup_header_t *startup_header = NULL;
+   size_t startupheader_offset = 0;
    startup_trailer_v1_t *startup_trailer_v1 = NULL;
    startup_trailer_v2_t *startup_trailer_v2 = NULL;
+   size_t startuptrailer_offset = 0;
    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;
    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 (read_filecontents (ifs_pathname, ".", &filedata, &filesize) == NULL)
-   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 ("QNX In-kernel Filesystem analysis produced by ifstool version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
    printf ("IFS file \"%s\" - size 0x%zx (%zd) bytes\n", ifs_pathname, filesize, filesize);
    // parse file from start to end
    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))
+      {
+         startupheader_offset = current_offset;
-         startup_header = (startup_header_t *) &filedata[current_offset];
+         startup_header = (startup_header_t *) &filedata[startupheader_offset];
          // layout:
          // [STARTUP HEADER]
          // (startup file blob)
          // [STARTUP TRAILER v1 or v2]
             is_foreign_endianness = false; // else this header is for the same endianness as us
          // 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)];
+            startuptrailer_offset = current_offset + startup_header->startup_size - sizeof (startup_trailer_v2_t);
+            startup_trailer_v2 = (startup_trailer_v2_t *) &filedata[startuptrailer_offset];
             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)];
+            startuptrailer_offset = current_offset + startup_header->startup_size - sizeof (startup_trailer_v1_t);
+            startup_trailer_v1 = (startup_trailer_v1_t *) &filedata[startuptrailer_offset];
             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 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));
+            strcpy (computed_sha512, SHA512 (startup_header, startuptrailer_offset - startupheader_offset, NULL));
             recorded_checksum = startup_trailer_v2->cksum;
-            computed_checksum = update_checksum (startup_header, sizeof (startup_header_t) + startupfile_blobsize + SHA512_DIGEST_LENGTH, is_foreign_endianness);
+            computed_checksum = update_checksum (startup_header, startuptrailer_offset + SHA512_DIGEST_LENGTH - startupheader_offset, is_foreign_endianness);
-            printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
+            printf ("    sha512([0x%zx-0x%zx[) = %s - %s\n", startupheader_offset, startuptrailer_offset, 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"));
+            printf ("    cksum([0x%zx-0x%zx[) = 0x%08x (%d) - %s\n", startupheader_offset, startuptrailer_offset + SHA512_DIGEST_LENGTH, 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_checksum (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"));
+            printf ("    cksum([0x%zx-0x%zx[) = 0x%08x (%d) - %s\n", startupheader_offset, startuptrailer_offset, 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 (startup_trailer_v2_t) : sizeof (startup_trailer_v1_t)); // now reach the next segment
             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");
+            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-               exit (1);
-            }
             fsentries = reallocated_ptr;
             fsentries[fsentry_count] = current_fsentry;
             fsentry_count++;
             printf ("\n");
                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);
                if (current_offset + 4 < filesize)
+               {
-                  if ((current_fsentry->u.file.size < 1024) && (current_offset + current_fsentry->u.file.size < filesize))
+                  if ((current_fsentry->u.file.size < 16 * 1024) && (current_offset + current_fsentry->u.file.size < filesize))
                      hex_printf (&filedata[current_offset], current_fsentry->u.file.size, "   data:\n");
                   else
                      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], ELF_MAGIC_STR, 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "data file")));
+               }
                if (current_offset + current_fsentry->u.file.size < filesize)
          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));
+            strcpy (computed_sha512, SHA512 (image_header, imagetrailer_offset - imageheader_offset, NULL));
             recorded_checksum = image_trailer_v2->cksum;
-            computed_checksum = update_checksum (image_header, image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH, is_foreign_endianness);
+            computed_checksum = update_checksum (image_header, imagetrailer_offset + SHA512_DIGEST_LENGTH - imageheader_offset, is_foreign_endianness);
-            printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
+            printf ("    sha512([0x%zx-0x%zx[) = %s - %s\n", imageheader_offset, imagetrailer_offset, 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"));
+            printf ("    cksum([0x%zx-0x%zx[) = 0x%08x (%d) - %s\n", imageheader_offset, imagetrailer_offset + SHA512_DIGEST_LENGTH, 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_checksum (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"));
+            printf ("    cksum([0x%zx-0x%zx[) = 0x%08x (%d) - %s\n", imageheader_offset, imagetrailer_offset, 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 += (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)

Subversion Repositories QNX 8.QNX8 IFS tool

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