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

 // TODO: preboot file stripping
 // TODO: startup file stripping
 // TODO: kernel file stripping
 // TODO: boot script compiler
+// standard C includes
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
+#include <limits.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <ctype.h>
 #include <time.h>
-// compiler-specific glue
+// platform-specific includes
 #ifdef _MSC_VER
 #include <io.h>
 #include <direct.h>
 #include <sys/utime.h>
-#include <process.h>
-#define __x86_64__ 1
-#define __ORDER_BIG_ENDIAN__    4321
-#define __ORDER_LITTLE_ENDIAN__ 1234
-#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
-#define __attribute__(x)
-#define __builtin_bswap16(x) _byteswap_ushort ((unsigned short) (x))
-#define __builtin_bswap32(x) _byteswap_ulong ((unsigned long) (x))
-#define __builtin_bswap64(x) _byteswap_uint64 ((unsigned long long) (x))
-#define S_IFIFO 0x1000
-#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 mkdir(p,m) _mkdir ((p))
-#define chmod(p,m) _chmod ((p), (m))
-#define unlink(p) _unlink ((p))
-#define utimbuf __utimbuf32
-#define utime(p,t) _utime32 ((p), (t))
-#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
-#define START_OF_PACKED_STRUCT() __pragma(pack(push)) __pragma(pack(1))
-#define END_OF_PACKED_STRUCT() __pragma(pack(pop))
-#define PACKED(thing) thing
 #else // !_MSC_VER
 #include <sys/param.h>
 #include <unistd.h>
 #include <utime.h>
-#ifndef thread_local
-#define thread_local __thread // the thread_local keyword wasn't defined before C++11 and C23
-#endif // !thread_local
-#define START_OF_PACKED_STRUCT()
-#define END_OF_PACKED_STRUCT()
-#define PACKED(thing) thing __attribute__((packed))
 #endif // _MSC_VER
+// own includes
+#include "buffer.h"
+#include "sha512.h"
+#include "elffile.h"
+#include "ifsfile.h"
+#include "utility.h"
-// 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
-#define BUILDDATE_YEAR  (&__DATE__[7]) // compiler will optimize this into a const string, e.g. "2021"
-#define BUILDDATE_MONTH ( \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Jan ") ? "01" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Feb ") ? "02" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Mar ") ? "03" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Apr ") ? "04" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "May ") ? "05" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Jun ") ? "06" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Jul ") ? "07" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Aug ") ? "08" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Sep ") ? "09" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Oct ") ? "10" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Nov ") ? "11" : \
-   *((uint32_t *) __DATE__) == *((uint32_t *) "Dec ") ? "12" : \
-   "XX" \
-) // compiler will optimize this into a const string, e.g. "11"
-#define BUILDDATE_DAY ( \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  1 ") ? "01" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  2 ") ? "02" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  3 ") ? "03" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  4 ") ? "04" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  5 ") ? "05" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  6 ") ? "06" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  7 ") ? "07" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  8 ") ? "08" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  9 ") ? "09" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 10 ") ? "10" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 11 ") ? "11" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 12 ") ? "12" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 13 ") ? "13" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 14 ") ? "14" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 15 ") ? "15" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 16 ") ? "16" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 17 ") ? "17" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 18 ") ? "18" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 19 ") ? "19" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 20 ") ? "20" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 21 ") ? "21" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 22 ") ? "22" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 23 ") ? "23" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 24 ") ? "24" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 25 ") ? "25" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 26 ") ? "26" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 27 ") ? "27" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 28 ") ? "28" : \
-   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 29 ") ? "29" : \
-   *((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 "%s%s%s"
-#define VERSION_ARG_YYYYMMDD BUILDDATE_YEAR, BUILDDATE_MONTH, BUILDDATE_DAY
-#endif // !VERSION_ARG_YYYYMMDD
-// macro to bring __FILE_NAME__ support to moronic compilers
-#ifndef __FILE_NAME__ // Clang 9+ has the macro, GCC 12+ added it too in 2021, MSVC obviously won't do it. Heh.
-#define __FILE_NAME__ ( \
-   (sizeof (__FILE__) >  2) && ((__FILE__[sizeof (__FILE__) -  2] == '/') || (__FILE__[sizeof (__FILE__) -  2] == '\\')) ? &__FILE__[sizeof (__FILE__) -  1] : \
-   (sizeof (__FILE__) >  3) && ((__FILE__[sizeof (__FILE__) -  3] == '/') || (__FILE__[sizeof (__FILE__) -  3] == '\\')) ? &__FILE__[sizeof (__FILE__) -  2] : \
-   (sizeof (__FILE__) >  4) && ((__FILE__[sizeof (__FILE__) -  4] == '/') || (__FILE__[sizeof (__FILE__) -  4] == '\\')) ? &__FILE__[sizeof (__FILE__) -  3] : \
-   (sizeof (__FILE__) >  5) && ((__FILE__[sizeof (__FILE__) -  5] == '/') || (__FILE__[sizeof (__FILE__) -  5] == '\\')) ? &__FILE__[sizeof (__FILE__) -  4] : \
-   (sizeof (__FILE__) >  6) && ((__FILE__[sizeof (__FILE__) -  6] == '/') || (__FILE__[sizeof (__FILE__) -  6] == '\\')) ? &__FILE__[sizeof (__FILE__) -  5] : \
-   (sizeof (__FILE__) >  7) && ((__FILE__[sizeof (__FILE__) -  7] == '/') || (__FILE__[sizeof (__FILE__) -  7] == '\\')) ? &__FILE__[sizeof (__FILE__) -  6] : \
-   (sizeof (__FILE__) >  8) && ((__FILE__[sizeof (__FILE__) -  8] == '/') || (__FILE__[sizeof (__FILE__) -  8] == '\\')) ? &__FILE__[sizeof (__FILE__) -  7] : \
-   (sizeof (__FILE__) >  9) && ((__FILE__[sizeof (__FILE__) -  9] == '/') || (__FILE__[sizeof (__FILE__) -  9] == '\\')) ? &__FILE__[sizeof (__FILE__) -  8] : \
-   (sizeof (__FILE__) > 10) && ((__FILE__[sizeof (__FILE__) - 10] == '/') || (__FILE__[sizeof (__FILE__) - 10] == '\\')) ? &__FILE__[sizeof (__FILE__) -  9] : \
-   (sizeof (__FILE__) > 11) && ((__FILE__[sizeof (__FILE__) - 11] == '/') || (__FILE__[sizeof (__FILE__) - 11] == '\\')) ? &__FILE__[sizeof (__FILE__) - 10] : \
-   (sizeof (__FILE__) > 12) && ((__FILE__[sizeof (__FILE__) - 12] == '/') || (__FILE__[sizeof (__FILE__) - 12] == '\\')) ? &__FILE__[sizeof (__FILE__) - 11] : \
-   (sizeof (__FILE__) > 13) && ((__FILE__[sizeof (__FILE__) - 13] == '/') || (__FILE__[sizeof (__FILE__) - 13] == '\\')) ? &__FILE__[sizeof (__FILE__) - 12] : \
-   (sizeof (__FILE__) > 14) && ((__FILE__[sizeof (__FILE__) - 14] == '/') || (__FILE__[sizeof (__FILE__) - 14] == '\\')) ? &__FILE__[sizeof (__FILE__) - 13] : \
-   (sizeof (__FILE__) > 15) && ((__FILE__[sizeof (__FILE__) - 15] == '/') || (__FILE__[sizeof (__FILE__) - 15] == '\\')) ? &__FILE__[sizeof (__FILE__) - 14] : \
-   (sizeof (__FILE__) > 16) && ((__FILE__[sizeof (__FILE__) - 16] == '/') || (__FILE__[sizeof (__FILE__) - 16] == '\\')) ? &__FILE__[sizeof (__FILE__) - 15] : \
-   (sizeof (__FILE__) > 17) && ((__FILE__[sizeof (__FILE__) - 17] == '/') || (__FILE__[sizeof (__FILE__) - 17] == '\\')) ? &__FILE__[sizeof (__FILE__) - 16] : \
-   (sizeof (__FILE__) > 18) && ((__FILE__[sizeof (__FILE__) - 18] == '/') || (__FILE__[sizeof (__FILE__) - 18] == '\\')) ? &__FILE__[sizeof (__FILE__) - 17] : \
-   (sizeof (__FILE__) > 19) && ((__FILE__[sizeof (__FILE__) - 19] == '/') || (__FILE__[sizeof (__FILE__) - 19] == '\\')) ? &__FILE__[sizeof (__FILE__) - 18] : \
-   (sizeof (__FILE__) > 20) && ((__FILE__[sizeof (__FILE__) - 20] == '/') || (__FILE__[sizeof (__FILE__) - 20] == '\\')) ? &__FILE__[sizeof (__FILE__) - 19] : \
-   (sizeof (__FILE__) > 21) && ((__FILE__[sizeof (__FILE__) - 21] == '/') || (__FILE__[sizeof (__FILE__) - 21] == '\\')) ? &__FILE__[sizeof (__FILE__) - 20] : \
-   (sizeof (__FILE__) > 22) && ((__FILE__[sizeof (__FILE__) - 22] == '/') || (__FILE__[sizeof (__FILE__) - 22] == '\\')) ? &__FILE__[sizeof (__FILE__) - 21] : \
-   (sizeof (__FILE__) > 23) && ((__FILE__[sizeof (__FILE__) - 23] == '/') || (__FILE__[sizeof (__FILE__) - 23] == '\\')) ? &__FILE__[sizeof (__FILE__) - 22] : \
-   (sizeof (__FILE__) > 24) && ((__FILE__[sizeof (__FILE__) - 24] == '/') || (__FILE__[sizeof (__FILE__) - 24] == '\\')) ? &__FILE__[sizeof (__FILE__) - 23] : \
-   (sizeof (__FILE__) > 25) && ((__FILE__[sizeof (__FILE__) - 25] == '/') || (__FILE__[sizeof (__FILE__) - 25] == '\\')) ? &__FILE__[sizeof (__FILE__) - 24] : \
-   (sizeof (__FILE__) > 26) && ((__FILE__[sizeof (__FILE__) - 26] == '/') || (__FILE__[sizeof (__FILE__) - 26] == '\\')) ? &__FILE__[sizeof (__FILE__) - 25] : \
-   (sizeof (__FILE__) > 27) && ((__FILE__[sizeof (__FILE__) - 27] == '/') || (__FILE__[sizeof (__FILE__) - 27] == '\\')) ? &__FILE__[sizeof (__FILE__) - 26] : \
-   (sizeof (__FILE__) > 28) && ((__FILE__[sizeof (__FILE__) - 28] == '/') || (__FILE__[sizeof (__FILE__) - 28] == '\\')) ? &__FILE__[sizeof (__FILE__) - 27] : \
-   (sizeof (__FILE__) > 29) && ((__FILE__[sizeof (__FILE__) - 29] == '/') || (__FILE__[sizeof (__FILE__) - 29] == '\\')) ? &__FILE__[sizeof (__FILE__) - 28] : \
-   (sizeof (__FILE__) > 30) && ((__FILE__[sizeof (__FILE__) - 30] == '/') || (__FILE__[sizeof (__FILE__) - 30] == '\\')) ? &__FILE__[sizeof (__FILE__) - 29] : \
-   (sizeof (__FILE__) > 31) && ((__FILE__[sizeof (__FILE__) - 31] == '/') || (__FILE__[sizeof (__FILE__) - 31] == '\\')) ? &__FILE__[sizeof (__FILE__) - 30] : \
-   (sizeof (__FILE__) > 32) && ((__FILE__[sizeof (__FILE__) - 32] == '/') || (__FILE__[sizeof (__FILE__) - 32] == '\\')) ? &__FILE__[sizeof (__FILE__) - 31] : \
-   (sizeof (__FILE__) > 33) && ((__FILE__[sizeof (__FILE__) - 33] == '/') || (__FILE__[sizeof (__FILE__) - 33] == '\\')) ? &__FILE__[sizeof (__FILE__) - 32] : \
-   __FILE__) // this *COMPILE-TIME* macro complements the __FILE__ macro defined by the C standard by returning just the filename portion of the full path. Supports filenames up to 32 chars. Expand as necessary.
-#endif // !__FILE_NAME__
-// logging macros
+// compiler-specific glue
-#define LOG(type,lvl,...) do { if ((lvl) <= verbose_level) { fprintf (stderr, "ifstool: %s: ", (type)); if (verbose_level > 1) fprintf (stderr, "%s:%d:%s(): ", __FILE_NAME__, __LINE__, __FUNCTION__); fprintf (stderr, __VA_ARGS__); fputc ('\n', stderr); } } while (0)
+#ifndef _MSC_VER
-#define LOG_ERROR(...)   LOG ("error",   0, __VA_ARGS__)
-#define LOG_WARNING(...) LOG ("warning", 1, __VA_ARGS__)
-#define LOG_INFO(...)    LOG ("info",    2, __VA_ARGS__)
-#define LOG_DEBUG(...)   LOG ("debug",   3, __VA_ARGS__)
+#define sscanf_s sscanf // WARNING: TRUE FOR THIS FILE ONLY!
-// macro to gently exit with an error message
+#endif // !_MSC_VER
-#define DIE_WITH_EXITCODE(exitcode,...) do { LOG_ERROR (__VA_ARGS__); exit ((exitcode)); } while (0)
-// macro to 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)) { LOG ("fatal error", 0, "consistency check failed"); LOG ("fatal error", 0, __VA_ARGS__); exit (1); } } while (0)
-// macros for checked read/write/seek operations
-#define fseek_or_die(fp,pos,mode) WELLMANNERED_ASSERT (fseek ((fp), (pos), (mode)) == 0, "fseek() failed with errno %d (%s)", errno, strerror (errno))
-#define fread_or_die(buf,sz,len,fp) WELLMANNERED_ASSERT (fread ((buf), (sz), (len), (fp)) == (len), "fread() failed with errno %d (%s)", errno, strerror (errno))
-#define fwrite_or_die(buf,sz,len,fp) WELLMANNERED_ASSERT ((fwrite ((buf), (sz), (len), (fp)) == (len)) && (fflush ((fp)) == 0), "flushed fwrite() failed with errno %d (%s)", errno, strerror (errno))
-// macros for accessing ELF files
-#define ELF_MAGIC_STR "\x7f" "ELF"
-#define ELF_ENDIAN_LITTLE 1 // 'endianness' member of an ELF header: ELF file is little endian
-#define ELF_ENDIAN_BIG    2 // 'endianness' member of an ELF header: ELF file is big endian
-#define ELF_MACHINE_X86_64  0x3e // 'instruction_set' member of an ELF header, also used in the IFS startup header: ELF file is for x86_64 processors (62 decimal)
-#define ELF_MACHINE_AARCH64 0xb7 // 'instruction_set' member of an ELF header, also used in the IFS startup header: ELF file is for ARM64 processors (183 decimal)
-#define ELF_SECTIONTYPE_STRINGTABLE 3
-#define ELF_DT_NULL    0 // marks end of dynamic section
-#define ELF_DT_SONAME 14 // canonical name of shared object
-#define ELF_GET_NUMERIC(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \
-   ( \
-      (sizeof ((elfstruct)->u.elf64.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
+// libasan (Address Sanitizer) options: this is not a daemon, so I don't care about leaks: they will be recovered by the OS at program exit
-         (elfstruct)->u.elf64.member /* same endianness, or single byte required: don't swap */ \
-      : /* else */ \
-         (sizeof ((elfstruct)->u.elf64.member) == 8 ? __builtin_bswap64 ((elfstruct)->u.elf64.member) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? __builtin_bswap32 ((elfstruct)->u.elf64.member) : __builtin_bswap16 ((elfstruct)->u.elf64.member))) /* different endianness: swap */ \
+const char *__asan_default_options () { return ("detect_leaks=0"); }
-   ) \
-   : /* else peek at 32-bit ELF */ \
-   ( \
-      (sizeof ((elfstruct)->u.elf32.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
-         (elfstruct)->u.elf32.member /* same endianness, or single byte required: don't swap */ \
-      : /* else */ \
-         (sizeof ((elfstruct)->u.elf32.member) == 4 ? __builtin_bswap32 ((elfstruct)->u.elf32.member) : __builtin_bswap16 ((elfstruct)->u.elf32.member)) /* different endianness: swap */ \
-   ) \
-) // this macro supports 32- and 64-bit ELF files in low and big endianness transparently
-#define ELF_SET_NUMERIC(elfhdr,elfstruct,member,data) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \
-   ((elfstruct)->u.elf64.member = ( \
-      (sizeof ((elfstruct)->u.elf64.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
-         (sizeof ((elfstruct)->u.elf64.member) == 8 ? (uint64_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? (uint32_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 2 ? (uint16_t) ((data)) : (uint8_t) ((data))))) /* same endianness, or single byte required: don't swap */ \
-      : /* else */ \
-         (sizeof ((elfstruct)->u.elf64.member) == 8 ? __builtin_bswap64 ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? __builtin_bswap32 ((data)) : __builtin_bswap16 ((data)))) /* different endianness: swap */ \
-   )) \
-   : /* else poke at 32-bit ELF */ \
-   ((elfstruct)->u.elf32.member = ( \
-      (sizeof ((elfstruct)->u.elf32.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
-         (sizeof ((elfstruct)->u.elf64.member) == 4 ? (uint32_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 2 ? (uint16_t) ((data)) : (uint8_t) ((data)))) /* same endianness, or single byte required: don't swap */ \
-      : /* else */ \
-         (sizeof ((elfstruct)->u.elf32.member) == 4 ? __builtin_bswap32 ((data)) : __builtin_bswap16 ((data))) /* different endianness: swap */ \
-   )) \
-) // this macro supports 32- and 64-bit ELF files in low and big endianness transparently
-#define ELF_GET_STRING(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member) // this macro supports 32- and 64-bit ELF files transparently
-#define ELF_SET_STRING(elfhdr,elfstruct,member,data,len) memcpy (((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member), (data), (len)) // this macro supports 32- and 64-bit ELF files transparently
-#define ELF_STRUCT_SIZE(elfhdr,elfstruct) ((elfhdr)->u.elf.platform_size == 2 ? sizeof ((elfstruct)->u.elf64) : sizeof ((elfstruct)->u.elf32)) // this macro supports 32- and 64-bit ELF files transparently
 // placeholder value
 #define WILL_BE_FILLED_LATER 0xbaadf00d // urgh
-// bitmapped flags used in the flags1 member of the startup header
-#define STARTUP_HDR_FLAGS1_VIRTUAL        (1 << 0)
-#define STARTUP_HDR_FLAGS1_BIGENDIAN      (1 << 1)
-//#define STARTUP_HDR_FLAGS1_COMPRESS_MASK  0x1c
-//#define STARTUP_HDR_FLAGS1_COMPRESS_SHIFT 0x02
-//#define STARTUP_HDR_FLAGS1_COMPRESS_NONE  0x00
-//#define STARTUP_HDR_FLAGS1_COMPRESS_ZLIB  0x04
-//#define STARTUP_HDR_FLAGS1_COMPRESS_LZO   0x08
-//#define STARTUP_HDR_FLAGS1_COMPRESS_UCL   0x0c
-#define STARTUP_HDR_FLAGS1_TRAILER_V2     (1 << 5) // if set, then a struct startup_trailer_v2 follows the startup. If the image is compressed, then the compressed imagefs is followed by a struct image_trailer_v2
-// bitmapped flags used in the flags member of the image header
-#define IMAGE_FLAGS_BIGENDIAN  (1 << 0) // header, trailer, dirents in big-endian format
-#define IMAGE_FLAGS_READONLY   (1 << 1) // do not try to write to image (rom/flash)
-#define IMAGE_FLAGS_INO_BITS   (1 << 2) // inode bits valid
-#define IMAGE_FLAGS_SORTED     (1 << 3) // dirent section is sorted (by pathname)
-#define IMAGE_FLAGS_TRAILER_V2 (1 << 4) // image uses struct image_trailer_v2
-// bitmapped flags superposed to a filesystem entry's inode number
-#define IFS_INO_PROCESSED_ELF 0x80000000
-#define IFS_INO_RUNONCE_ELF   0x40000000
-#define IFS_INO_BOOTSTRAP_EXE 0x20000000
 // miscellaneous macros
 #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) == '\\')) // platform-specific directory separator, Win32 variant
-#define PATH_SEP ';' // platform-specific PATH element separator, Win32 variant
-#define PATH_SEP_STR ";" // platform-specific PATH element separator (as string), Win32 variant
+#define PATH_SEP ";" // platform-specific PATH element separator (as string), Win32 variant
 #else // !_WIN32, thus POSIX
 #define IS_DIRSEP(c) ((c) == '/') // platform-specific directory separator, UNIX variant
-#define PATH_SEP ':' // platform-specific PATH element separator, UNIX variant
-#define PATH_SEP_STR ":" // platform-specific PATH element separator (as string), UNIX variant
+#define PATH_SEP ":" // platform-specific PATH element separator (as string), UNIX variant
 #endif // _WIN32
-#define RECORD_SEP '\x1e' // arbitrarily-chosen ASCII record separator
-#define RECORD_SEP_STR "\x1e" // arbitrarily-chosen ASCII record separator (as string)
+#define RECORD_SEP "\x1e" // arbitrarily-chosen ASCII record separator, as a C string suitable for e.g. strtok()
-// SHA-512 block and digest sizes
-#define SHA512_BLOCK_LENGTH 128 // in bytes
-#define SHA512_DIGEST_LENGTH 64 // in bytes
-// SHA-512 computation context structure type definition
-typedef struct sha512_ctx_s
-{
-   uint64_t state[8];
-   uint64_t bitcount[2];
-   uint8_t buffer[SHA512_BLOCK_LENGTH];
-} SHA512_CTX;
-#if 0 // TODO: startup script compiler. Someday.
-#define SCRIPT_FLAGS_EXTSCHED   0x01
-#define SCRIPT_FLAGS_SESSION    0x02
-#define SCRIPT_FLAGS_SCHED_SET  0x04
-#define SCRIPT_FLAGS_CPU_SET    0x08
-#define SCRIPT_FLAGS_BACKGROUND 0x20
-#define SCRIPT_FLAGS_KDEBUG     0x40
-#define SCRIPT_POLICY_NOCHANGE 0
-#define SCRIPT_POLICY_FIFO     1
-#define SCRIPT_POLICY_RR       2
-#define SCRIPT_POLICY_OTHER    3
-#define SCRIPT_TYPE_EXTERNAL        0
-#define SCRIPT_TYPE_WAITFOR         1
-#define SCRIPT_TYPE_REOPEN          2
-#define SCRIPT_TYPE_DISPLAY_MSG     3
-#define SCRIPT_TYPE_PROCMGR_SYMLINK 4
-#define SCRIPT_TYPE_EXTSCHED_APS    5
-#define SCRIPT_CHECKS_MS 100
-#define SCRIPT_SCHED_EXT_NONE 0
-#define SCRIPT_SCHED_EXT_APS  1
-#define SCRIPT_APS_SYSTEM_PARTITION_ID   0
-#define SCRIPT_APS_SYSTEM_PARTITION_NAME "System"
-#define SCRIPT_APS_PARTITION_NAME_LENGTH 15
-#define SCRIPT_APS_MAX_PARTITIONS        8
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) bootscriptcmd_header_s
-{
-   uint16_t size; // size of cmd entry
-   uint8_t type;
-   uint8_t spare;
-} bootscriptcmd_header_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef union bootscriptcmd_s
-{
-   PACKED (struct) script_external
-   {
-      bootscriptcmd_header_t hdr;
-      uint8_t cpu; // CPU (turn into runmask)
-      uint8_t flags;
-      union script_external_extsched
-      {
-         uint8_t reserved[2];
-         PACKED (struct)
-         {
-            uint8_t id;
-            uint8_t reserved[1];
-         } aps;
-      } extsched; // extended scheduler
-      uint8_t policy; // POLICY_FIFO, POLICY_RR, ...
-      uint8_t priority; // priority to run cmd at
-      uint8_t argc; // # of args
-      uint8_t envc; // # of environment entries
-      char args[0]; // executable, argv, envp (null padded to 32-bit align)
-   } external;
-   PACKED (struct) script_waitfor_reopen
-   {
-      bootscriptcmd_header_t hdr;
-      uint16_t checks;
-      char fname[0]; // char fname[] (null padded to 32-bit align)
-   } waitfor_reopen;
-   PACKED (struct) script_display_msg
-   {
-      bootscriptcmd_header_t hdr;
-      char msg[0]; // char msg[] (null padded to 32-bit align)
-   } display_msg;
-   PACKED (struct) script_procmgr_symlink
-   {
-      bootscriptcmd_header_t hdr;
-      char src_dest[0]; // <src_name>, '\0', <dest_name> '\0' (null padded to 32-bit align)
-   } procmgr_symlink;
-   PACKED (struct) script_extsched_aps
-   {
-      bootscriptcmd_header_t hdr;
-      uint8_t parent;
-      uint8_t budget;
-      uint16_t critical;
-      uint8_t id;
-      char pname[0]; // char pname[] (null padded to 32-bit align)
-   } extsched_aps;
-} bootscriptcmd_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-#endif // 0
 #define INITIAL_STARTUP_SCRIPT \
    /* procmgr_symlink /proc/boot/ldqnx-64.so.2 /usr/lib/ldqnx-64.so.2 */ \
    "\x34\x00" /*size*/ "\x04" /*type*/ "\x00" /*spare*/ "/proc/boot/ldqnx-64.so.2\0" "/usr/lib/ldqnx-64.so.2\0" \
    "\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"
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) fsentry_s
-{
-   PACKED (struct) fsentry_header_s
-   {
-      uint16_t size; // size of dirent
-      uint16_t extattr_offset; // if zero, no extattr data
-      uint32_t ino; // if zero, skip entry
-      uint32_t mode; // mode and perms of entry
-      uint32_t gid;
-      uint32_t uid;
-      uint32_t mtime;
-   } header;
-   PACKED (union) fsentry_specific_u
-   {
-      PACKED (struct) 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;
-      PACKED (struct) fsentry_dir_s // when (mode & S_IFMT) == S_IFDIR
-      {
-         char *path; // null terminated path (no leading slash)
-      } dir;
-      PACKED (struct) 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;
-      PACKED (struct) 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;
-   } u;
-   bool UNSAVED_was_data_written; // whether this entry's data was written to the image (NOT SAVED IN THE IFS)
-} fsentry_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) startup_header_s // size 256 bytes
-{
-   // I - used by the QNX IPL
-   // S - used by the startup program
-   uint8_t signature[4];   // [I ] Header signature, "\xeb\x7e\xff\x00"
-   uint16_t version;       // [I ] Header version, i.e. 1
-   uint8_t flags1;         // [IS] Misc flags, 0x21 (= 0x20 | STARTUP_HDR_FLAGS1_VIRTUAL)
-   uint8_t flags2;         // [  ] No flags defined yet (0)
-   uint16_t header_size;   // [ S] sizeof(struct startup_header), i.e. 256
-   uint16_t machine;       // [IS] Machine type from elfdefinitions.h, i.e. 0x003E --> _ELF_DEFINE_EM(EM_X86_64, 62, "AMD x86-64 architecture")
-   uint32_t startup_vaddr; // [I ] Virtual Address to transfer to after IPL is done, here 0x01403008 (appears in "Entry" column for "startup.*")
-   uint32_t paddr_bias;    // [ S] Value to add to physical address to get a value to put into a pointer and indirected through, here 0 (no indirections)
-   uint32_t image_paddr;   // [IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)
-   uint32_t ram_paddr;     // [IS] Physical address of RAM to copy image to (startup_size bytes copied), here 0x01400f30 (same as above)
-   uint32_t ram_size;      // [ 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
-   uint32_t startup_size;  // [I ] Size of startup (never compressed), here 0x02f148 or 192 840 bytes
-   uint32_t stored_size;   // [I ] Size of entire image, here 0x00cd6128 (same as ram_size)
-   uint32_t imagefs_paddr; // [IS] Set by IPL to where the imagefs is when startup runs (0)
-   uint32_t imagefs_size;  // [ S] Size of uncompressed imagefs, here 0x00ca6fe0 or 13 266 912 bytes
-   uint16_t preboot_size;  // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))
-   uint16_t zero0;         // [  ] Zeros
-   uint32_t zero[1];       // [  ] Zeros
-   uint64_t addr_off;      // [ S] Offset to add to startup_vaddr, image_paddr, ram_paddr, and imagefs_paddr members, here zero (0)
-   uint32_t info[48];      // [IS] Array of startup_info* structures (zero filled)
-} startup_header_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) startup_trailer_s
-{
-   uint32_t cksum; // checksum from start of header to start of trailer
-} startup_trailer_v1_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-// 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.
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) startup_trailer_v2_s
-{
-   uint8_t sha512[64]; // SHA512 from start of header to start of trailer
-   uint32_t cksum; // checksum from start of header to start of this member
-} startup_trailer_v2_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) image_header_s
-{
-   uint8_t signature[7]; // image filesystem signature, i.e. "imagefs"
-   uint8_t flags; // endian neutral flags, 0x1c
-   uint32_t image_size; // size from start of header to end of trailer (here 0xca6fe0 or 13 266 912)
-   uint32_t hdr_dir_size; // size from start of header to last dirent (here 0x12b8 or 4792)
-   uint32_t dir_offset; // offset from start of header to start of first dirent (here 0x5c or 92)
-   uint32_t boot_ino[4]; // inode of files for bootstrap pgms (here 0xa0000002, 0, 0, 0)
-   uint32_t script_ino; // inode of file for script (here 3)
-   uint32_t chain_paddr; // offset to next filesystem signature (0)
-   uint32_t spare[10]; // zerofill
-   uint32_t mountflags; // default _MOUNT_* from sys/iomsg.h (0)
-   char mountpoint[4]; // default mountpoint for image ("/" + "\0\0\0")
-} image_header_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) image_trailer_v1_s
-{
-   uint32_t cksum; // checksum from start of header to start of trailer
-} image_trailer_v1_t; // NOTE: this is the same structure as startup_trailer_v1_t
-END_OF_PACKED_STRUCT () // restore default alignment
-// 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.
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) 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; // NOTE: this is the same structure as startup_trailer_v2_t
-END_OF_PACKED_STRUCT () // restore default alignment
-// Executable and Linkable Format master header structure type definition
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) elf_header_s
-{
-   PACKED (union)
-   {
-      PACKED (struct)
-      {
-         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"
-         uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit
-         uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian
-         uint8_t header_version;               // offset 6: typically 1
-         uint8_t os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS
-         uint8_t spare[8];                     // offset 8: zeroes
-         uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump
-         uint16_t instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V
-         uint32_t elf_version;                 // offset 20: typically 1
-      } elf;
-      PACKED (struct) // size == 52
-      {
-         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"
-         uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit
-         uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian
-         uint8_t header_version;               // offset 6: typically 1
-         uint8_t os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS
-         uint8_t spare[8];                     // offset 8: zeroes
-         uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump
-         uint16_t instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V
-         uint32_t elf_version;                 // offset 20: typically 1
-         uint32_t entrypoint_offset;           // offset 24: offset to program entrypoint
-         uint32_t program_header_table_offset; // offset 28: offset to program header table
-         uint32_t section_header_table_offset; // offset 32: offset to section header table
-         uint32_t flags;                       // offset 36: flags (architecture-dependent, none for x86)
-         uint16_t header_size;                 // offset 40: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF -- DO NOT USE sizeof() ON THE elf_header_s STRUCT BECAUSE OF THE UNION! WRITE THE CORRECT SIZE YOURSELF!
-         uint16_t program_header_item_size;    // offset 42: size of an entry in the program header table
-         uint16_t program_header_table_len;    // offset 44: number of entries in the program header table
-         uint16_t section_header_item_size;    // offset 46: size of an entry in the section header table
-         uint16_t section_header_table_len;    // offset 48: number of entries in the section header table
-         uint16_t section_header_names_idx;    // offset 50: index of the entry in the section header table that contains the section names
-      } elf32; // size == 52
-      PACKED (struct) // size == 64
-      {
-         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"
-         uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit
-         uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian
-         uint8_t header_version;               // offset 6: typically 1
-         uint8_t os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS
-         uint8_t spare[8];                     // offset 8: zeroes
-         uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump
-         uint16_t instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V
-         uint32_t elf_version;                 // offset 20: typically 1
-         uint64_t entrypoint_offset;           // offset 24: program entry offset
-         uint64_t program_header_table_offset; // offset 32: offset to program header table
-         uint64_t section_header_table_offset; // offset 40: offset to section header table
-         uint32_t flags;                       // offset 48: flags (architecture-dependent, none for x86)
-         uint16_t header_size;                 // offset 52: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF
-         uint16_t program_header_item_size;    // offset 54: size of an entry in the program header table
-         uint16_t program_header_table_len;    // offset 56: number of entries in the program header table
-         uint16_t section_header_item_size;    // offset 58: size of an entry in the section header table
-         uint16_t section_header_table_len;    // offset 60: number of entries in the section header table
-         uint16_t section_header_names_idx;    // offset 62: index of the entry in the section header table that contains the section names
-      } elf64; // size == 64
-   } u;
-} elf_header_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-// Executable and Linkable Format program header structure type definition
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) elf_program_header_s
-{
-   PACKED (union)
-   {
-      PACKED (struct)
-      {
-         uint32_t segment_type; // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)
-      } elf;
-      PACKED (struct) // size == 32
-      {
-         uint32_t segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)
-         uint32_t file_offset;    // offset 4: file offset of this segment
-         uint32_t virtual_addr;   // offset 8: virtual address where this segment should be mapped in memory
-         uint32_t physical_addr;  // offset 12: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory
-         uint32_t size_in_file;   // offset 16: size of this segment in the ELF file (may be zero)
-         uint32_t size_in_memory; // offset 20: size of this segment in memory (may be zero)
-         uint32_t segment_flags;  // offset 24: bitmap of segment flags (1: executable, 2: writable, 4: readable)
-         uint32_t alignment;      // offset 28: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)
-      } elf32; // size == 32
-      PACKED (struct) // size == 56
-      {
-         uint32_t segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)
-         uint32_t segment_flags;  // offset 4: bitmap of segment flags (1: executable, 2: writable, 4: readable)
-         uint64_t file_offset;    // offset 8: file offset of this segment
-         uint64_t virtual_addr;   // offset 16: virtual address where this segment should be mapped in memory
-         uint64_t physical_addr;  // offset 24: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory
-         uint64_t size_in_file;   // offset 32: size of this segment in the ELF file (may be zero)
-         uint64_t size_in_memory; // offset 40: size of this segment in memory (may be zero)
-         uint64_t alignment;      // offset 48: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)
-      } elf64; // size == 56
-   } u;
-} elf_program_header_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-// Executable and Linkable Format section header structure type definition
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) elf_section_header_s
-{
-   PACKED (union)
-   {
-      PACKED (struct)
-      {
-         uint32_t name_offset; // offset 0: offset in the string table of the name of this section
-         uint32_t type;        // offset 4: section type (0: unused, 1: program data, 2: symbols table, 3: strings table, 4: relocs with addends, 5: symbols hash table, 6: dyld info, 7: notes, 8: BSS, 9: relocs without addends, 11: dyld symbols table, 14: constructors, 15: destructors, 16, preconstructors, 17: group, 18: extended section indices, 19: number of typedefs ...)
-      } elf;
-      PACKED (struct) // size == 40
-      {
-         uint32_t name_offset;  // offset 0: offset in the string table of the name of this section
-         uint32_t type;         // offset 4: section type (0: unused, 1: program data, 2: symbols table, 3: strings table, 4: relocs with addends, 5: symbols hash table, 6: dyld info, 7: notes, 8: BSS, 9: relocs without addends, 11: dyld symbols table, 14: constructors, 15: destructors, 16, preconstructors, 17: group, 18: extended section indices, 19: number of typedefs ...)
-         uint32_t flags;        // offset 8: bitmapped flags (1: writable, 2: takes RAM, 4: executable, 8: reserved, 16: mergeable, 32: contains C-strings, 64: sh_info contains SHT index, 128: preserve order, 256: OS-specific, 512: group member, 1024: TLS template ...)
-         uint32_t virtual_addr; // offset 12: address in virtual memory where this section may be loaded
-         uint32_t file_offset;  // offset 16: offset of this section in the ELF file
-         uint32_t size;         // offset 20: size of this section
-         uint32_t linked_index; // offset 24: optional section index of an associated section
-         uint32_t info;         // offset 28: optional extra information
-         uint32_t alignment;    // offset 32: required memory alignment (must be a power of 2)
-         uint32_t entry_size;   // offset 36: for table-like sections, size of an element in the table
-      } elf32; // size == 40
-      PACKED (struct) // size == 64
-      {
-         uint32_t name_offset;  // offset 0: offset in the string table of the name of this section
-         uint32_t type;         // offset 4: section type (0: unused, 1: program data, 2: symbols table, 3: strings table, 4: relocs with addends, 5: symbols hash table, 6: dyld info, 7: notes, 8: BSS, 9: relocs without addends, 11: dyld symbols table, 14: constructors, 15: destructors, 16, preconstructors, 17: group, 18: extended section indices, 19: number of typedefs ...)
-         uint64_t flags;        // offset 8: bitmapped flags (1: writable, 2: takes RAM, 4: executable, 8: reserved, 16: mergeable, 32: contains C-strings, 64: sh_info contains SHT index, 128: preserve order, 256: OS-specific, 512: group member, 1024: TLS template ...)
-         uint64_t virtual_addr; // offset 16: address in virtual memory where this section may be loaded
-         uint64_t file_offset;  // offset 24: offset of this section in the ELF file
-         uint64_t size;         // offset 32: size of this section
-         uint32_t linked_index; // offset 40: optional section index of an associated section
-         uint32_t info;         // offset 44: optional extra information
-         uint64_t alignment;    // offset 48: required memory alignment (must be a power of 2)
-         uint64_t entry_size;   // offset 56: for table-like sections, size of an element in the table
-      } elf64; // size == 64
-   } u;
-} elf_section_header_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-// Executable and Linkable Format dynamic section entry structure type definition
-START_OF_PACKED_STRUCT () // we need byte-alignment for this struct
-typedef PACKED (struct) elf_dynamic_section_entry_s
-{
-   PACKED (union)
-   {
-      PACKED (struct) // size == 8
-      {
-         int32_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)
-         uint32_t value; // value (as integer, or as pointed address)
-      } elf32; // size == 8
-      PACKED (struct) // size == 16
-      {
-         int64_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)
-         uint64_t value; // value (as integer, or as pointed address)
-      } elf64; // size == 16
-   } u;
-} elf_dynamic_section_entry_t;
-END_OF_PACKED_STRUCT () // restore default alignment
-// generic buffer structure type definition
-typedef struct buffer_s
-{
-   uint8_t *bytes; // mallocated data
-   size_t len; // length of allocated data
-} buffer_t;
 // IFS directory entry insertion parameters structure type definition
 typedef struct parms_s
+{
    bool should_keep_ld_output; // whether to keep .sym files produced by ld calls, togglable by the [+keeplinked] attribute
    bool is_compiled_bootscript; // entry has [+script] attribute
    int extra_ino_flags; // bitmap of extra inode flags (IFS_INO_xxx)
    char search[10 * MAXPATHLEN]; // binary search path (the default one will be constructed at startup)
-   buffer_t data;
+   buffer_t data; // the resolved file's own data bytes
 } parms_t;
-// global variables
+// exported globals
+int verbose_level = 1; // verbosity level, can be increased with multiple -v[...] flags
+// global variables used in this module only
 static char line_buffer[4096]; // scrap buffer for the IFS build file parser
 static uint32_t image_base = 4 * 1024 * 1024; // default image base, as per QNX docs -- can be changed with the [image=XXXX] attribute in the IFS build file
 static uint32_t image_end = UINT32_MAX; // default image end (no limit)
 static uint32_t image_maxsize = UINT32_MAX; // default image max size (no limit)
 static uint32_t image_totalsize = 0; // image total size, measured once all the blocks have been written to the output IFS file
 #elif defined(__aarch64__)
 static char image_processor[16] = "aarch64le"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
 #else // unknown platform
 #error Please port ifstool to this platform
 #endif
-static int verbose_level = 1; // verbosity level, can be increased with multiple -v[...] flags
 static char *buildfile_pathname = NULL; // pathname of IFS build file
 static char *current_line = NULL; // copy of current line in IFS build file
 static int lineno = 0; // current line number in IFS build file
 static char *QNX_TARGET = NULL; // value of the $QNX_TARGET environment variable
 static char *MKIFS_PATH = NULL; // value of the $MKIFS_PATH environment variable (may contain references to $QNX_TARGET). Initialized by this program if empty.
 static size_t bootfile_size = 0;                 // HACK: size of the bootcode binary blob file to put at the start of a bootable IFS
 static char *startupfile_pathname = NULL;        // HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS
 static size_t startupfile_ep_from_imagebase = 0; // HACK: startup code entrypoint offset from image base for a bootable IFS
 static char *kernelfile_pathname = NULL;         // HACK: pathname to precompiled kernel file blob to put in a bootable IFS
 static size_t kernelfile_offset = 0;             // HACK: kernel file offset in bootable IFS
+// exported function prototypes
+int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer
 // prototypes of local functions
-static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data); // used internally in SHA512_Update() and SHA512_Final()
-static void SHA512_Init (SHA512_CTX *context);
-static void SHA512_Update (SHA512_CTX *context, void *data, size_t len);
-static void SHA512_Final (uint8_t digest[SHA512_DIGEST_LENGTH], SHA512_CTX *context);
-static uint8_t *SHA512 (void *data, size_t data_len, uint8_t *digest); // computes a SHA-512 in one pass (shortcut for SHA512_Init(), SHA512_Update() N times and SHA512_Final())
-static int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer
 static long long read_integer (const char *str); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)
-static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...); // hexdump-style formatted output to a file stream (which may be stdout/stderr)
-static char *binary (const uint8_t x, char char_for_zero, char char_for_one); // returns the binary representation of byte 'x' as a string
-static char *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8]); // returns the ORed description of byte 'x' according to the description strings for each bit
-static char *read_filecontents (const char *pathname, const char *search_path, buffer_t *outbuf); // locates pathname among MKIFS_PATH, reads it, places its contents in a buffer (caller frees) and returns a pointer to the resolved pathname (static string)
+static char *resolve_pathname (const char *pathname, const char *search_path); // locates pathname among MKIFS_PATH and returns a pointer to the resolved pathname (static string)
-static int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp
-static int relative_offset_of_in (const char *name, const buffer_t *stringbuf); // returns the relative offset of a particular string in a string table
 static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file
+static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs_data, const size_t write_offset, const fsentry_t *fsentry); // writes the given filesystem entry (without its contents) to the IFS buffer
-static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp); // writes the given filesystem entry into fp (without its contents)
+static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer
+static int Buffer_StripELFFile (buffer_t *file, const char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // 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 void update_MKIFS_PATH (const char *processor);
-static int dump_ifs_info (const char *ifs_pathname, bool want_everything); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
-static int create_intermediate_dirs (const char *file_pathname); // creates all intermediate directories to file_pathname so that fopen(file_pathname, "w") doesn't fail
-static int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error
-static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data)
-{
-   // logical functions used in SHA-384 and SHA-512
-   #define S64(b,x)      (((x) >> (b)) | ((x) << (64 - (b)))) // 64-bit rotate right
-   #define Ch(x,y,z)     (((x) & (y)) ^ ((~(x)) & (z)))
-   #define Maj(x,y,z)    (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
-   #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
-   #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
-   #define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ ((x) >> 7))
-   #define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ ((x) >> 6))
-   // hash constant words K for SHA-384 and SHA-512
-   static const uint64_t K512[80] = {
-x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
-xd807aa98a3030242ULL, 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
-xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
-x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
-x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
-xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
-x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
-x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
-xca273eceea26619cULL, 0xd186b8c721c0c207ULL, 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
-x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
-   };
-   uint64_t     a, b, c, d, e, f, g, h, s0, s1;
-   uint64_t     T1, T2, *W512 = (uint64_t *) context->buffer;
-   int j;
-   // initialize registers with the prev. intermediate value
-   a = context->state[0]; b = context->state[1]; c = context->state[2]; d = context->state[3]; e = context->state[4]; f = context->state[5]; g = context->state[6]; h = context->state[7];
-   for (j = 0; j < 16; j++)
-   {
-#if __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__
-      W512[j] = __builtin_bswap64 (*data); // convert to host byte order
-#elif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-      W512[j] = *data;
-#else // __BYTE_ORDER__ == ???
-#error Please port this SHA-512 code to your exotic endianness platform. What are you compiling this on? PDP? Honeywell?
-#endif // __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__
-      // apply the SHA-512 compression function to update a..h
-      T1 = h + Sigma1_512 (e) + Ch (e, f, g) + K512[j] + W512[j];
-      T2 = Sigma0_512 (a) + Maj (a, b, c);
-      // update registers
-      h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2;
-      data++;
-   }
-   for (; j < 80; j++)
-   {
-      // part of the message block expansion
-      s0 = W512[(j + 1) & 0x0f];
-      s0 = sigma0_512 (s0);
-      s1 = W512[(j + 14) & 0x0f];
-      s1 = sigma1_512 (s1);
-      // apply the SHA-512 compression function to update a..h
-      T1 = h + Sigma1_512 (e) + Ch (e, f, g) + K512[j] + (W512[j & 0x0f] += s1 + W512[(j + 9) & 0x0f] + s0);
-      T2 = Sigma0_512 (a) + Maj (a, b, c);
-      // update registers
+// imported function prototypes
-      h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2;
-   }
-   // compute the current intermediate hash value
-   context->state[0] += a; context->state[1] += b; context->state[2] += c; context->state[3] += d; context->state[4] += e; context->state[5] += f; context->state[6] += g; context->state[7] += h;
+extern int dump_ifs_info (const char *ifs_pathname, bool want_everything); // [implemented in ifsdump.c] dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
-   // clean up
-   a = b = c = d = e = f = g = h = T1 = T2 = 0;
-   #undef sigma1_512
-   #undef sigma0_512
-   #undef Sigma1_512
-   #undef Sigma0_512
-   #undef Maj
-   #undef Ch
-   #undef S64
-   return;
-}
-static void SHA512_Init (SHA512_CTX *context)
-{
-   // initial hash value H for SHA-512
-   static const uint64_t sha512_initial_hash_value[8] = {
-x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
-   };
-   memcpy (context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
-   memset (context->buffer, 0, SHA512_BLOCK_LENGTH);
-   context->bitcount[0] = context->bitcount[1] = 0;
-}
-void SHA512_Update (SHA512_CTX *context, void *datain, size_t len)
-{
-   #define ADDINC128(w,n) do { \
-           (w)[0] += (uint64_t) (n); \
-           if ((w)[0] < (n)) \
-                   (w)[1]++; \
-   } while (0) // macro for incrementally adding the unsigned 64-bit integer n to the unsigned 128-bit integer (represented using a two-element array of 64-bit words
+extern int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // [implemented in ifsdump.c] dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error
-   size_t freespace, usedspace;
-   const uint8_t *data = (const uint8_t *) datain;
-   if (len == 0)
-      return; // calling with empty data is valid - we do nothing
-   usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
-   if (usedspace > 0)
-   {
-      // calculate how much free space is available in the buffer
-      freespace = SHA512_BLOCK_LENGTH - usedspace;
-      if (len >= freespace)
-      {
-         // fill the buffer completely and process it
-         memcpy (&context->buffer[usedspace], data, freespace);
-         ADDINC128 (context->bitcount, freespace << 3);
-         len -= freespace;
-         data += freespace;
-         sha512_private_transform (context, (uint64_t *) context->buffer);
-      }
-      else
-      {
-         // the buffer is not full yet
-         memcpy (&context->buffer[usedspace], data, len);
-         ADDINC128 (context->bitcount, len << 3);
-         // clean up
-         usedspace = freespace = 0;
-         return;
-      }
-   }
-   while (len >= SHA512_BLOCK_LENGTH)
-   {
-      // process as many complete blocks as we can
-      sha512_private_transform (context, (uint64_t *) data);
-      ADDINC128 (context->bitcount, SHA512_BLOCK_LENGTH << 3);
-      len -= SHA512_BLOCK_LENGTH;
-      data += SHA512_BLOCK_LENGTH;
-   }
-   if (len > 0)
-   {
-      // save leftovers
-      memcpy (context->buffer, data, len);
-      ADDINC128 (context->bitcount, len << 3);
-   }
-   // clean up
-   usedspace = freespace = 0;
-   #undef ADDINC128
-   return;
-}
-static void SHA512_Final (uint8_t digest[SHA512_DIGEST_LENGTH], SHA512_CTX *context)
-{
-   #define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16)
-   size_t usedspace;
-   union { uint8_t *as_bytes; uint64_t *as_uint64s; } cast_var = { NULL };
-   // if no digest buffer is passed, don't bother finalizing the computation
-   if (digest != NULL)
-   {
-      usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
-#if __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__
-      context->bitcount[0] = __builtin_bswap64 (context->bitcount[0]); // convert from host byte order
-      context->bitcount[1] = __builtin_bswap64 (context->bitcount[1]); // convert from host byte order
-#endif // __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__
-      if (usedspace > 0)
-      {
-         // begin padding with a 1 bit
-         context->buffer[usedspace++] = 0x80;
-         if (usedspace <= SHA512_SHORT_BLOCK_LENGTH)
-            memset (&context->buffer[usedspace], 0, SHA512_SHORT_BLOCK_LENGTH - usedspace); // set-up for the last transform
-         else
-         {
-            if (usedspace < SHA512_BLOCK_LENGTH)
-               memset (&context->buffer[usedspace], 0, SHA512_BLOCK_LENGTH - usedspace);
-            sha512_private_transform (context, (uint64_t *) context->buffer); // do second-to-last transform
-            memset (context->buffer, 0, SHA512_BLOCK_LENGTH - 2); // and set-up for the last transform
-         }
-      }
-      else // usedspace == 0
-      {
-         memset (context->buffer, 0, SHA512_SHORT_BLOCK_LENGTH); // prepare for final transform
-         *context->buffer = 0x80; // begin padding with a 1 bit
-      }
-      // store the length of input data (in bits)
-      cast_var.as_bytes = context->buffer;
-      cast_var.as_uint64s[SHA512_SHORT_BLOCK_LENGTH / 8 + 0] = context->bitcount[1];
-      cast_var.as_uint64s[SHA512_SHORT_BLOCK_LENGTH / 8 + 1] = context->bitcount[0];
-      // final transform
-      sha512_private_transform (context, (uint64_t *) context->buffer);
-      // save the hash data for output
-#if __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__
-      for (int j = 0; j < 8; j++)
-         context->state[j] = __builtin_bswap64 (context->state[j]); // convert to host byte order
-#endif // __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__
-      memcpy (digest, context->state, SHA512_DIGEST_LENGTH);
-   }
-   // zero out state data
-   memset (context, 0, sizeof (SHA512_CTX));
-   #undef SHA512_SHORT_BLOCK_LENGTH
-   return;
-}
-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
+extern int dump_file_hex (const char *pathname); // [implemented in ifsdump.c] dumps the contents of pathname to stdout in mixed hexadecimal + ASCII (hex editor) format
-   // returns the STRING REPRESENTATION of digest in a statically-allocated string
-   static thread_local uint8_t static_digest[SHA512_DIGEST_LENGTH] = "";
-   static thread_local 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_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_as_string);
-}
-static int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness)
+int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness)
+{
    // computes the checksum of an IFS image or startup section, i.e. from the start of the header to the end of the trailer minus the last 4 bytes where the checksum is stored
    uint8_t accumulator[4] = { 0, 0, 0, 0 };
    const char *current_char_ptr;
+   }
    return (ret);
+}
-static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...)
+static char *resolve_pathname (const char *pathname, const char *search_path)
+{
-   // this function logs hexadecimal data to an opened file pointer (or to stdout/stderr)
+   // locates pathname among search path and returns resolved pathname (static buffer) or NULL.
-   va_list argptr;
+   static thread_local char *resolved_pathname = NULL;
-   size_t index;
-   int i;
-   // concatenate all the arguments in one string and write it to the file
-   va_start (argptr, fmt);
+   struct stat stat_buf;
-   vfprintf (fp, fmt, argptr);
+   const char *nextsep;
-   va_end (argptr);
+   const char *token;
-   // for each row of howmany_columns bytes of data...
+   // initial allocation (per thread)
-   for (index = 0; index < data_size; index += howmany_columns)
+   if (resolved_pathname == NULL)
+   {
-      fprintf (fp, "    %05zu  ", index); // print array address of row
-      for (i = 0; i < howmany_columns; i++)
+      resolved_pathname = malloc (MAXPATHLEN);
-         if (index + i < data_size)
+      ASSERT_WITH_ERRNO (resolved_pathname);
-            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 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 thread_local char *default_bitstrings[8] = { "bit0", "bit1", "bit2", "bit3", "bit4", "bit5", "bit6", "bit7" };
-   static thread_local 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 char *read_filecontents (const char *pathname, const char *search_path, buffer_t *outbuf)
-{
-   // locates pathname among MKIFS_PATH, and places its contents in a buffer (caller frees). Returns resolved pathname (static buffer) or NULL.
-   static thread_local char resolved_pathname[MAXPATHLEN];
-   const char *nextsep;
-   const char *token;
-   FILE *fp;
    // is it an absolute pathname (POSIX and Windows variants) ?
    if (IS_DIRSEP (pathname[0]) || (isalpha (pathname[0]) && (pathname[1] == ':') && IS_DIRSEP (pathname[2])))
-      strcpy (resolved_pathname, pathname); // in this case, it MUST exist at its designated location (either absolute or relative to the current working directory)
+      strcpy_s (resolved_pathname, MAXPATHLEN, 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 != 0 ? search_path : NULL);
-      nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP_STR)] : NULL);
+      nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
       while (token != NULL)
+      {
-         sprintf (resolved_pathname, "%.*s/%s", (int) (nextsep - token), token, pathname);
+         sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s", (int) (nextsep - token), token, pathname);
-         if (access (resolved_pathname, 0) == 0)
+         if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))
-            break; // if a file can indeed be found at this location, stop searching
+            return (resolved_pathname); // if a file can indeed be found at this location, stop searching
          token = (*nextsep != 0 ? nextsep + 1 : NULL);
-         nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP_STR)] : NULL);
+         nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
-      }
-      // have we exhausted all possibilities ?
-      if (token == NULL)
-      {
-         errno = ENOENT;
-         return (NULL); // file not found, return with ENOENT
+      }
+   }
-   // now open and read the file
+   errno = ENOENT; // we exhausted all possibilities
-   fp = fopen (resolved_pathname, "rb");
-   if (fp == NULL)
-      return (NULL); // unexistent file (errno is set to ENOENT)
+   return (NULL); // file not found, return with ENOENT
+}
+static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs, const size_t write_offset, const fsentry_t *fsentry)
+{
+   // writes a directory entry in the image filesystem buffer pointed to by ifs at write_offset (or fakes so if ifs is NULL)
-   // if we don't want its contents, close it and return the resolved pathname
+   // and return the number of bytes written (or that would have been written)
+   static const uint8_t zeropad_buffer[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+   size_t datalen;
+   size_t count;
+   count = 0;
-   if (outbuf == NULL)
+   if (ifs != NULL)
+      ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->header, sizeof (fsentry->header))); // write the entry header (PACKED STRUCT)
+   count += sizeof (fsentry->header);
+   if (S_ISREG (fsentry->header.mode))
+   {
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.file.offset, sizeof (uint32_t))); // write offset
+      count += sizeof (uint32_t);
-      fclose (fp);
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.file.size,   sizeof (uint32_t))); // write size
-      return (resolved_pathname);
+      count += sizeof (uint32_t);
+      datalen = strlen (fsentry->u.file.path) + 1;
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.file.path, datalen)); // write null-terminated path (no leading slash)
+      count += datalen;
+   }
-   // the user supplied a data buffer: read the file contents
-   fseek (fp, 0, SEEK_END);
-   outbuf->len = ftell (fp); // measure file length
-   fseek (fp, 0, SEEK_SET);
-   outbuf->bytes = malloc (outbuf->len);
-   if (outbuf->bytes == NULL)
+   else if (S_ISDIR (fsentry->header.mode))
+   {
-      fclose (fp);
+      datalen = strlen (fsentry->u.dir.path) + 1;
-      outbuf->len = 0;
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.dir.path, datalen)); // write null-terminated path (no leading slash)
-      return (NULL); // out of memory (errno is set to ENOMEM)
+      count += datalen;
+   }
-   if (fread (outbuf->bytes, 1, outbuf->len, fp) != outbuf->len) // read the file in whole
+   else if (S_ISLNK (fsentry->header.mode))
+   {
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.symlink.sym_offset, sizeof (uint16_t))); // write offset
+      count += sizeof (uint16_t);
-      fclose (fp);
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.symlink.sym_size,   sizeof (uint16_t))); // write size
+      count += sizeof (uint16_t);
+      datalen = strlen (fsentry->u.symlink.path) + 1;
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.symlink.path, datalen)); // write null-terminated path (no leading slash)
+      count += datalen;
+      datalen = strlen (fsentry->u.symlink.contents) + 1;
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.symlink.contents, datalen)); // write null-terminated symlink contents
-      outbuf->len = 0;
+      count += datalen;
+   }
+   else
+   {
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.device.dev,  sizeof (uint32_t))); // write dev number
+      count += sizeof (uint32_t);
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.device.rdev, sizeof (uint32_t))); // write rdev number
+      count += sizeof (uint32_t);
-      return (NULL); // short read (errno is set)
+      datalen = strlen (fsentry->u.device.path) + 1;
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.device.path, datalen)); // write null-terminated path (no leading slash)
+      count += datalen;
+   }
-   fclose (fp); // close the file
-   return (resolved_pathname); // file was read successfully and its content put in databuf with size datalen
+   ASSERT (count <= fsentry->header.size, "attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.", (size_t) fsentry->header.size, count);
+   if (count < fsentry->header.size)
+   {
+      if (ifs != NULL)
+         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, zeropad_buffer, fsentry->header.size - count)); // pad as necessary
+      count += fsentry->header.size - count;
+   }
+   return (count);
+}
-static int fwrite_filecontents (const char *pathname, FILE *fp)
+static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, fsentry_t *fsentry)
+{
-   // dumps the binary contents of pathname to fp
+   // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer
+   elf_program_header_t *phdr;
+   elf_header_t *elf;
-   uint8_t *blob_buffer;
+   size_t corrective_offset;
+   //size_t segment_type;
-   size_t blob_size;
+   size_t segment_size;
+   size_t table_index;
-   FILE *blob_fp;
+   size_t table_count;
-   int ret;
+   size_t data_offset;
-   blob_fp = fopen (pathname, "rb");
+   ASSERT (S_ISREG (fsentry->header.mode), "function called for invalid dirent"); // consistency check
-   if (blob_fp == NULL)
-      return (-1); // errno is set
+   data_offset = ifs_data->size; // see where we are
+   // is the file we're storing a preprocessed ELF file ?
-   fseek (blob_fp, 0, SEEK_END);
+   if ((fsentry->header.ino & IFS_INO_PROCESSED_ELF)
-   blob_size = ftell (blob_fp);
+#ifndef PROCNTO_WIP
-   blob_buffer = malloc (blob_size);
+      && (strstr (fsentry->u.file.path, "/procnto-smp-instr") == NULL)
-   if (blob_buffer == NULL)
+#endif // !PROCNTO_WIP
+       )
+   {
-      fclose (blob_fp);
-      return (-1); // errno is set to ENOMEM
-   }
-   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);
+      elf = (elf_header_t *) fsentry->u.file.UNSAVED_databuf; // quick access to ELF header
-   fflush (fp); // force flush to disk, because the C stream API is *buffered*
+      table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
-   free (blob_buffer);
+      for (table_index = 0; table_index < table_count; table_index++)
-   return (ret);
+      {
-}
+         phdr = (elf_program_header_t *) &fsentry->u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+         //segment_type = ELF_GET_NUMERIC (elf, phdr, segment_type); // get segment type
+         //if (!((segment_type >= 2) && (segment_type <= 7) || ((segment_type >= 0x6474e550) && (segment_type <= 0x6474e552)) || (segment_type == 0x70000001)))
+         //   continue; // NOTE: only certain segments types must be corrected
-static int relative_offset_of_in (const char *name, const buffer_t *stringbuf)
+         corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);
-{
-   int name_len = (int) strlen (name) + 1;
-   WELLMANNERED_ASSERT (name_len < stringbuf->len, "bad call (name longer than string table)");
+         segment_size = ELF_GET_NUMERIC (elf, phdr, size_in_memory); // get this ELF segment's occupied size in memory
-   for (int idx = 0; idx <= stringbuf->len - name_len; idx++)
+         if (segment_size != 0) // only patch the physical address of segments that have an actual size in memory
-      if (memcmp (&stringbuf->bytes[idx], name, name_len) == 0)
+            ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + data_offset - corrective_offset); // patch the physical address member of the program header table (NOTE: data_offset is the location where the file data is about to be written)
-         return (idx);
+      }
+   }
-   WELLMANNERED_ASSERT (false, "bad call (name '%s' not found in string table)", name);
+   ASSERT_WITH_ERRNO (Buffer_Append (ifs_data, fsentry->u.file.UNSAVED_databuf, fsentry->u.file.size)); // write file data blob
-   return (0);
+   return (ifs_data->size - data_offset); // return the number of bytes written
+}
-static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name)
+static inline size_t Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (buffer_t *buffer, const char *str)
+{
-   elf_section_header_t *shdr_shstrtab; // section header of the section header strings table
+   // helper function used in add_fsentry(): locates or appends str to buffer and returns its relative offset in the buffer
-   elf_section_header_t *shdr;
-   size_t table_count;
-   size_t table_index;
-   char *shstrtab; // section header strings table
-   char *name;
-   shdr_shstrtab = (elf_section_header_t *) ((uint8_t *) elf + ELF_GET_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, section_header_item_size) * ELF_GET_NUMERIC (elf, elf, section_header_names_idx)); // quick access to section header for the section that contains the section names
+   size_t str_len_including_terminator = strlen (str) + 1;
-   shstrtab = ((uint8_t *) elf + ELF_GET_NUMERIC (elf, shdr_shstrtab, file_offset)); // locate the start of the strings table that contains the section names
+   void *occurrence = Buffer_FindFirst (buffer, str, str_len_including_terminator);
-   // cycle through the sections table
+   if (occurrence == NULL)
-   table_count = ELF_GET_NUMERIC (elf, elf, section_header_table_len);
-   for (table_index = 0; table_index < table_count; table_index++)
+   {
-      shdr = (elf_section_header_t *) ((uint8_t *) elf + ELF_GET_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, section_header_item_size) * table_index); // quick access to section header
+      ASSERT_WITH_ERRNO (Buffer_Append (buffer, str, str_len_including_terminator));
-      name = &shstrtab[ELF_GET_NUMERIC (elf, shdr, name_offset)]; // peek at its name
+      occurrence = Buffer_FindFirst (buffer, str, str_len_including_terminator);
-      if (strcmp (name, section_name) == 0)
+      ASSERT_WITH_ERRNO (occurrence);
-         return (shdr); // if found, return a pointer to this section header
+   }
-   return (NULL); // section not found
+   return (Buffer_OffsetOf (buffer, occurrence)); // can't fail
+}
-static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp)
+static int Buffer_StripELFFile (buffer_t *file, const char *indicative_pathname)
+{
+   // NOTE: for each ELF file, mkifs
+   // -> alters the program header table and offsets each p_addr (physical address) member by <image_base> plus the current file offset (this cannot be done right now, will need to be done once they are known)
-   // writes a directory entry in the image filesystem file pointed to by fp (or fakes so if fp is NULL)
+   // -> throws away and reconstructs the sections table by keeping only the sections that are in the program header, and writes the section table at the start of the first thrown-away section
-   // and return the number of bytes written (or that would have been written)
+   // FIXME: what if a thrown away section is located between two program segments ? are they collapsed, moving the segments beyond it one slot down ?
+   // reconstructed ELF:
+   // ==== START OF FILE ====
+   // ELF header
+   // program header table
+   //  (same sections, just p_addr offset changed)
+   // section data 5 (named ".note.gnu.build-id")
+   //  "............GNU....ZY.....c.o..l"
+   // PROGRAM
+   // sections table
+   // + section 1: ALL ZEROES
-   static const uint8_t zeropad_buffer[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+   // + section 2: fileoffs 0x21a8 size 0xfd --> "QNX_info" --> QNX binary description: "NAME=pci_debug2.so.3.0\nDESCRIPTION=PCI Server System Debug Module\nDATE=2023/11/19-10:01:13-EST\nSTATE=lookup\nHOST=docker-n1.bts.rim.net\nUSER=builder\nVERSION=QNXOS_main\nTAGID=QNXOS_800-135\nPACKAGE=com.qnx.qnx800.target.pci.debug/3.0.0.00135T202311191043L\n"
+   // + section 3: fileoffs 0x22a5 size 0x1c --> ".gnu_debuglink" --> indicates the debug file and its checksum: "pci_debug2.so.3.0.sym" "\0\0\0" "VX2p"
+   // + section 4: fileoffs 0x22c1 size 0x2ad --> "QNX_usage" --> HELP TEXT: "\n-------------------------------------------------------------------------------\n%C\n\nThis module implements debug logging for all PCI server modules. It is\nincluded by setting the environment variable PCI_DEBUG_MODULE and uses\nthe slogger2 APIs.\nNOTE:.On systems which support slogger2, you are encouraged to use this module.instead of pci_debug.so...Release History.---------------..3.0 - This module is functionally equivalent to the previous 2.x version.      however it is incompatible with all pre v3.x PCI components..2.1 - fixes a bug whereby if slogger2 is not running and the PCI_DEBUG_MODULE.      environment variable is set, the client will SIGSEGV..2.0 - initial release.."
+   // + section 5: fileoffs 0x190 size 0x32 --> ".note.gnu.build-id" --> GNU build ID
+   // + section 6: fileoffs 0x256e size 0x40 --> ".shstrtab" --> sections names strings table
+   // section data 2 (named "QNX_info")
+   //  (QNX binary description)
+   // section data 3 (named ".gnu_debuglink")
+   //  (debug file)
+   // section data 4 (named "QNX_usage")
+   //  (help text)
+   // section data 6 (named ".shstrtab")
+   //  "\0"
+   //  ".shstrtab\0"
+   //  "QNX_info\0"
+   //  ".gnu_debuglink\0"
+   //  "QNX_usage\0"
+   //  ".note.gnu.build-id\0"
+   // ==== END OF FILE ====
+   #define ELFHDR ((elf_header_t *) file->bytes) // this convenient definition will make sure the ELF header points at the right location, even after entry_parms.data->byte is reallocated
+   #define ADD_SECTION(section_name,section_ptr) do { \
+      void *reallocated_ptr = realloc (elf_sections, (elf_section_count + 1) * sizeof (elf_section_t)); \
+      ASSERT_WITH_ERRNO (reallocated_ptr); \
+      elf_sections = reallocated_ptr; \
+      elf_sections[elf_section_count].name = (section_name); \
+      Buffer_Initialize (&elf_sections[elf_section_count].data); \
+      *(section_ptr) = &elf_sections[elf_section_count]; \
-   size_t datalen;
+      elf_section_count++; \
-   size_t count;
+   } while (0)
-   count = 0;
-   if (fp != NULL)
-      fwrite_or_die (&fsentry->header, 1, sizeof (fsentry->header), fp); // write the entry header (PACKED STRUCT)
-   count += sizeof (fsentry->header);
+   typedef struct elf_section_s
-   if (S_ISREG (fsentry->header.mode))
+   {
-      if (fp != NULL)
+      const char *name;
+      elf_section_header_t header;
-      {
+      buffer_t data;
+   } elf_section_t;
-         fwrite_or_die (&fsentry->u.file.offset, 1, sizeof (uint32_t), fp); // write offset
+   static const char *saved_sections[] = { "QNX_info", ".gnu_debuglink", "QNX_usage", ".note.gnu.build-id" };
+   const elf_program_header_t *phdr;
+   const elf_section_header_t *shdr;
-         fwrite_or_die (&fsentry->u.file.size,   1, sizeof (uint32_t), fp); // write size
+   elf_section_t *elf_sections = NULL; // mallocated
+   elf_section_t *elf_section = NULL;
-      }
+   size_t elf_section_count = 0;
-      count += 2 * sizeof (uint32_t);
+   size_t new_shdrtable_offset;
+   size_t sectiondata_start;
-      datalen = strlen (fsentry->u.file.path) + 1;
+   size_t sectiondata_size;
+   size_t array_index;
+   size_t table_index;
+   size_t table_count;
-      if (fp != NULL)
+   size_t page_size;
+   // find out the platform page size
+   if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_X86_64)
+      page_size = 4 * 1024; // 4 kb pages on Intel processors
+   else if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_AARCH64)
+      page_size = 16 * 1024; // 16 kb pages on ARM64
+   else
+   {
-         fwrite_or_die (fsentry->u.file.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
+      errno = ENOTSUP; // unsupported architecture: set errno to something meaningful
-      count += datalen;
+      return (0); // and return an error value
+   }
+   // parse the program header table, and measure the farthest offset known by this table where we'll write the reconstructed section headers table
+   new_shdrtable_offset = 0;
+   table_count = ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_len);
-   else if (S_ISDIR (fsentry->header.mode))
+   for (table_index = 0; table_index < table_count; table_index++)
+   {
+      phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // quick access to program header
-      datalen = strlen (fsentry->u.dir.path) + 1;
+      if (ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file) > new_shdrtable_offset)
-      if (fp != NULL)
-         fwrite_or_die (fsentry->u.dir.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
+         new_shdrtable_offset = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // keep track of the farthest offset known by the program headers table
-      count += datalen;
+   }
+   /*
-   else if (S_ISLNK (fsentry->header.mode))
+   size_t new_shdrtable_offset_method2 = 0;
+   for (table_index = 0; table_index < table_count; table_index++)
+   {
+      phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // quick access to program header
+      size_t segment_type = ELF_GET_NUMERIC (ELFHDR, phdr, segment_type); // get segment type
+      if (!((segment_type >= 2) && (segment_type <= 7)))
+         continue; // NOTE: only certain segments types must be corrected
+      if (ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory) > new_shdrtable_offset_method2)
+         new_shdrtable_offset_method2 = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory);
+   }
+   if (new_shdrtable_offset_method2 > new_shdrtable_offset)
+      LOG_DEBUG ("METHOD2: %llx > %llx", new_shdrtable_offset_method2, new_shdrtable_offset);*/
+   //new_shdrtable_offset = ROUND_TO_UPPER_MULTIPLE (new_shdrtable_offset, page_size); // round to page size
-      if (fp != NULL)
+   // re-create the section header table
+   ADD_SECTION (".shstrtab", &elf_section); // the first section will be the section names strings table
+   ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&elf_section->data, "\0")); // initialize an empty section headers strings table
+   ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&elf_section->data, ".shstrtab\0")); // append ".shstrtab" *INCLUDING* its null terminator
+   // go through the saved sections array and see if such an ELF section is present in the ELF file
+   for (array_index = 0; array_index < sizeof (saved_sections) / sizeof (saved_sections[0]); array_index++)
+      if ((shdr = elf_get_section_header_by_name (ELFHDR, saved_sections[array_index])) != NULL) // does this ELF have such a section ?
+      {
+         ADD_SECTION (saved_sections[array_index], &elf_section); // yes, so save it
-         fwrite_or_die (&fsentry->u.symlink.sym_offset, 1, sizeof (uint16_t), fp); // write offset
+         sectiondata_start = ELF_GET_NUMERIC (ELFHDR, shdr, file_offset); // identify section data start offset
+         sectiondata_size = ELF_GET_NUMERIC (ELFHDR, shdr, size); // identify section data length
+         if (sectiondata_start + sectiondata_size >= new_shdrtable_offset) // should this section be moved ?
+            ASSERT_WITH_ERRNO (Buffer_InitWithData (&elf_section->data, &file->bytes[sectiondata_start], sectiondata_size)); // have a copy of this section's data
+         else
+            Buffer_Initialize (&elf_section->data); // this section is located before the place where we'll write the new section headers table, thus it doesn't need to be moved
+         //LOG_DEBUG ("%s: section '%s' start 0x%llx len 0x%llx", indicative_pathname, saved_sections[array_index], (unsigned long long) sectiondata_start, (unsigned long long) sectiondata_size);
+         // prepare this section's "fixed" header
+         memcpy (&elf_section->header, shdr, ELF_STRUCT_SIZE (ELFHDR, shdr)); // have a copy of the old section header first
-         fwrite_or_die (&fsentry->u.symlink.sym_size,   1, sizeof (uint16_t), fp); // write size
+         ELF_SET_NUMERIC (ELFHDR, &elf_section->header, name_offset, Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (&elf_sections[0].data, elf_section->name)); // make sure this section name is in the ELF sections section header strings table and update the relative offset of the section name
+      }
-      count += 2 * sizeof (uint16_t);
-      datalen = strlen (fsentry->u.symlink.path) + 1;
+   // jump over the new section headers table and write the saved sections data after the section headers table
-      if (fp != NULL)
-         fwrite_or_die (fsentry->u.symlink.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
+   file->size = new_shdrtable_offset + (1 + elf_section_count) * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header); // start by truncating the ELF file: assume there are no sections beyond the section headers table until known otherwise
-      count += datalen;
-      datalen = strlen (fsentry->u.symlink.contents) + 1;
+   for (table_index = 1; table_index < elf_section_count; table_index++)
-      if (fp != NULL)
-         fwrite_or_die (fsentry->u.symlink.contents, 1, (size_t) datalen, fp); // write null-terminated symlink contents
-      count += datalen;
-   }
-   else
+   {
+      elf_section = &elf_sections[table_index]; // quick access to ELF section about to be written
-      if (fp != NULL)
+      if (elf_section->data.bytes != NULL) // was this section data backed up waiting to be relocated ?
+      {
-         fwrite_or_die (&fsentry->u.device.dev,  1, sizeof (uint32_t), fp); // write dev number
+         ELF_SET_NUMERIC (ELFHDR, &elf_section->header, file_offset, file->size); // fix section offset
-         fwrite_or_die (&fsentry->u.device.rdev, 1, sizeof (uint32_t), fp); // write rdev number
+         Buffer_AppendBuffer (file, &elf_section->data); // append this section's data to the ELF file
+      }
-      count += 2 * sizeof (uint32_t);
-      datalen = strlen (fsentry->u.device.path) + 1;
-      if (fp != NULL)
-         fwrite_or_die (fsentry->u.device.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)
-      count += datalen;
+   }
+   // write the section header strings table as the last section
+   elf_section = &elf_sections[0]; // quick access to ELF section about to be written
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, name_offset, Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (&elf_sections[0].data, elf_section->name)); // update the relative offset of the section name
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, type, ELF_SECTIONTYPE_STRINGTABLE); // section type (SHT_STRTAB)
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, flags, 0); // section flags (we could set SHF_STRINGS i.e. 0x20 here, but mkifs does not, so mimic that)
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, virtual_addr, 0); // this section does not need to be mapped
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, file_offset, file->size); // fix section offset
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, size, elf_sections[0].data.size); // section size
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, linked_index, 0); // this section is not linked to any other
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, info, 0); // this section has no additional info
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, alignment, 1); // this section is byte-aligned
+   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, entry_size, 0); // this section is not a table, so entry_size is zero
+   Buffer_AppendBuffer (file, &elf_section->data); // append section headers strings table section data to ELF file
-   WELLMANNERED_ASSERT (count <= fsentry->header.size, "attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.", (size_t) fsentry->header.size, count);
-   if (count < fsentry->header.size)
+   // now write the section headers table
-   {
-      if (fp != NULL)
-         fwrite_or_die (zeropad_buffer, 1, fsentry->header.size - count, fp); // pad as necessary
+   memset (&file->bytes[new_shdrtable_offset], 0, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header)); // the first section header is always zerofilled
-      count += fsentry->header.size - count;
+   for (table_index = 1; table_index < elf_section_count; table_index++)
-   }
+      Buffer_WriteAt (file, new_shdrtable_offset + table_index * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header), &elf_sections[table_index].header, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header)); // write each section header
+   Buffer_WriteAt (file, new_shdrtable_offset + table_index * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header), &elf_sections[0].header, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header)); // write the section header names section header last
+   // and finally fix the ELF master header
+   ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_offset, new_shdrtable_offset);
+   ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_len, 1 + elf_section_count); // take in account that the first entry in the section headers table is empty
+   ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_names_idx, elf_section_count); // the section headers strings table is the last section
+   // align size with page size (4096 on x86, 16k on ARM), zerofilling the extra space
+   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (file, ROUND_TO_UPPER_MULTIPLE (file->size, page_size)));
+   // cleanup
+   for (table_index = 0; table_index < elf_section_count; table_index++)
+      Buffer_Forget (&elf_sections[table_index].data); // free all sections' backing buffers
+   #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file
-   return (count);
+   return (1); // success
+}
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
-   #define ADD_NAME_TO_STRINGTABLE(name,strtab) do { \
-      name_len = strlen ((name)) + 1; \
-      reallocated_ptr = realloc ((strtab).bytes, (strtab).len + name_len); \
-      WELLMANNERED_ASSERT (reallocated_ptr, "out of memory"); \
-      (strtab).bytes = reallocated_ptr; \
-      memcpy (&(strtab).bytes[(strtab).len], (name), name_len); \
-      (strtab).len += name_len; \
-   } while (0)
-   #define APPEND_SECTION_DATA(section,sectionhdr_offset) do { \
-      memcpy (&entry_parms->data.bytes[entry_parms->data.len], (section).bytes, (section).len); /* write section in place */ \
-      free ((section).bytes); /* free it */ \
-      new_shdr = (elf_section_header_t *) &new_shtab.bytes[(sectionhdr_offset)]; /* now fix this section header */ \
-      ELF_SET_NUMERIC (elf, new_shdr, file_offset, entry_parms->data.len); /* fix section offset in the new section headers table */ \
-      entry_parms->data.len += (section).len; /* update new ELF file length */ \
-   } while (0)
-   static thread_local char candidate_pathname[MAXPATHLEN];
+   static thread_local char *candidate_pathname = NULL;
    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_dynstr; // dynamic strings
-   const elf_section_header_t *shdr_dynamic; // dynamic section
-   const elf_section_header_t *shdr;
-   elf_section_header_t *new_shdr;
-   size_t new_qnxinfo_shdr_offset;
-   size_t new_debuglink_shdr_offset;
-   size_t new_qnxusage_shdr_offset;
-   size_t new_buildid_shdr_offset;
-   size_t new_shstrtab_shdr_offset;
+   buffer_t *shstrtab = NULL;
-   elf_program_header_t *phdr;
    const char *canonical_dylib_name;
    const char *dynamic_strings; // strings table of the ".dynamic" section
    const char *last_dirsep;
-   elf_header_t *elf;
-   buffer_t new_shtab = { NULL, 0 };
-   buffer_t elfsection_qnxinfo   = { NULL, 0 };
-   buffer_t elfsection_qnxusage  = { NULL, 0 };
-   buffer_t elfsection_debuglink = { NULL, 0 };
-   buffer_t elfsection_buildid   = { NULL, 0 };
-   buffer_t elfsection_shstrtab  = { NULL, 0 };
    char *global_envstring = NULL;
    size_t global_envstring_len = 0;
    char *startup_name = NULL;
    char *procnto_name = NULL;
    char *resolved_pathname;
    void *reallocated_ptr;
    void *old_data;
    struct stat stat_buf;
-   size_t new_shdrtable_offset;
-   size_t end_padding_offset;
-   size_t table_index;
-   size_t table_count;
-   size_t name_len;
    fsentry_t *fsentry;
+   // initial allocation (per thread)
+   if (candidate_pathname == NULL)
+   {
+      candidate_pathname = malloc (MAXPATHLEN);
+      ASSERT_WITH_ERRNO (candidate_pathname);
+   }
    if (S_ISDIR (entry_parms->st_mode)) // are we storing a directory ?
+   {
       LOG_INFO ("directory: ino 0x%x uid %d gid %d mode 0%o path \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname);
+   }
          char *linebit_start;
          char *content_line;
          char *write_ptr;
          char *token;
          char *value;
+         char *ctx;
          bool is_quoted_context;
          bool was_string_split;
          // parse each line of contents
-         WELLMANNERED_ASSERT (entry_parms->data.len > 0, "kernel specification without inline contents");
+         ASSERT (entry_parms->data.len > 0, "kernel specification without inline contents");
-         for (content_line = strtok (entry_parms->data.bytes, "\n"); content_line != NULL; content_line = strtok (NULL, "\n"))
+         for (content_line = strtok_r (entry_parms->data.bytes, "\n", &ctx); content_line != NULL; content_line = strtok_r (NULL, "\n", ctx))
+         {
             while (isspace (*content_line))
                content_line++; // skip leading spaces
             if ((*content_line == '#') || (*content_line == 0))
                continue; // skip comments and empty lines
                while ((*content_line != 0) && !((*content_line == ']') && (content_line[-1] != '\\') && !is_quoted_context))
+               {
                   if (*content_line == '"')
                      is_quoted_context ^= true; // remember when we're between quotes
                   else if (!is_quoted_context && (*content_line == ' '))
-                     *content_line = RECORD_SEP; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
+                     *content_line = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
                   content_line++; // reach the next unescaped closing square bracket
+               }
                if (*content_line != ']')
+               {
                   LOG ("warning", 0, "syntax error in \"%s\" line %d: unterminated attributes block (skipping)", buildfile_pathname, lineno);
                   continue; // invalid attribute block, skip line
+               }
                *content_line = 0; // end the attribute block so that it is a parsable C string
                // now parse the attribute tokens (NOTE: THE LIST OF ALLOWED ATTRIBUTES HERE IS NOT DOCUMENTED)
-               token = strtok (linebit_start, RECORD_SEP_STR);
+               token = strtok_r (linebit_start, RECORD_SEP, &ctx);
                while (token != NULL)
+               {
                   #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)
                   if      (strncmp (token, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->uid     = (int) read_integer (value); }
                   else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->gid     = (int) read_integer (value); }
                   else if (strcmp (token, "-followlink") == 0) entry_parms->should_follow_symlinks = false;
                   else if (strcmp (token, "+keeplinked") == 0) entry_parms->should_keep_ld_output = true;
                   else if (strcmp (token, "-keeplinked") == 0) entry_parms->should_keep_ld_output = false;
                   else LOG_WARNING ("unimplemented bootstrap executable attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, token);
                   #undef REACH_TOKEN_VALUE
-                  token = strtok (NULL, RECORD_SEP_STR); // proceed to next attribute token
+                  token = strtok_r (NULL, RECORD_SEP, &ctx); // proceed to next attribute token
+               }
                content_line++; // reach the next character
                while ((*content_line != 0) && isspace (*content_line))
                   content_line++; // skip leading spaces
          } // end of parsing
          free (entry_parms->data.bytes); // free the inline specification once it's parsed
          entry_parms->data.bytes = NULL;
          entry_parms->data.len = 0;
-         WELLMANNERED_ASSERT (startup_name && *startup_name, "the QNX startup executable (startup-*) is missing in this bootstrap inline specification");
+         ASSERT (startup_name && *startup_name, "the QNX startup executable (startup-*) is missing in this bootstrap inline specification");
-         WELLMANNERED_ASSERT (procnto_name && *procnto_name, "the QNX kernel (procnto-*) is missing in this bootstrap inline specification");
+         ASSERT (procnto_name && *procnto_name, "the QNX kernel (procnto-*) is missing in this bootstrap inline specification");
          // now we know which startup and procnto executables to use
          LOG_DEBUG ("Startup: %s", startup_name);
          LOG_DEBUG ("Kernel: %s", procnto_name);
 #elif defined(__QNXNTO__)
          sprintf (linker_pathname, "%s/../../host/qnx8/x86_64/usr/bin/%s-ld", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
 #else // wtf are you building this on?
 #error Please port the GNU linker x86_64-pc-nto-qnx8.0.0-ld and aarch64-unknown-nto-qnx8.0.0-ld to your host architecture first before compiling ifstool.
 #endif
-         WELLMANNERED_ASSERT (access (linker_pathname, 0) == 0, "host cross-linker for QNX8 \"%s\" not found", linker_pathname);
+         ASSERT (access (linker_pathname, 0) == 0, "host cross-linker for QNX8 \"%s\" not found", linker_pathname);
          sprintf (linker_sysroot_arg, "--sysroot=%s/%s/", QNX_TARGET, image_processor);
          sprintf (linker_script_pathname_arg, "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);
-         resolved_pathname = read_filecontents (procnto_name, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH), NULL); // locate the procnto kernel location, but do not load it
+         resolved_pathname = resolve_pathname (procnto_name, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH)); // locate the procnto kernel location
-         WELLMANNERED_ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_name);
+         ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_name);
          strcpy (procnto_buildhost_pathname, resolved_pathname);
          sprintf (procnto_sym_filename, "%s.sym", procnto_name);
          const char *linker_argv[] = // construct the linker invokation argv
             for (table_index = 0; table_index < sizeof (linker_argv) / sizeof (linker_argv[0]) - 1; table_index++)
                fprintf (stderr, " '%s'", linker_argv[table_index]);
             fputc ('\n', stderr);
+         }
          _spawnv (_P_WAIT, linker_pathname, linker_argv); // spawn the linker and produce a stripped procnto (wait for completion)
-         resolved_pathname = read_filecontents (procnto_sym_filename, ".", &entry_parms->data); // locate the output file and load it
+         if (!Buffer_ReadFromFile (&entry_parms->data, procnto_sym_filename)) // load the output file
-         if (resolved_pathname == NULL)
             DIE_WITH_EXITCODE (1, "the host cross-linker failed to produce a readable stripped \"%s\" kernel: %s", procnto_sym_filename, strerror (errno));
          if (!entry_parms->should_keep_ld_output)
             unlink (procnto_sym_filename); // remove the linker output file if we want to
 #else // !PROCNTO_WIP
          /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
          /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
          /* HACK */
-         /* HACK */ sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix); // HACK: fix the entry name
+         /* HACK */ sprintf_s (candidate_pathname, MAXPATHLEN, "%s/procnto-smp-instr", entry_parms->prefix); // HACK: fix the entry name
          /* HACK */ stored_pathname = candidate_pathname;
          /* HACK */ entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
          /* HACK */ entry_parms->st_mode = S_IFREG | 0700; // procnto requires 0700 permissions
          /* HACK */ image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
          /* HACK */ free (entry_parms->data.bytes); // discard inline contents
-         /* HACK */ entry_parms->data.bytes = NULL;
-         /* HACK */ entry_parms->data.len = 0;
+         /* HACK */ Buffer_Initialize (&entry_parms->data);
-         /* HACK */ if (read_filecontents (kernelfile_pathname, ".", &entry_parms->data) == NULL) // read kernel file as a precompiled binary blob
+         /* HACK */ if (!Buffer_ReadFromFile (&entry_parms->data, kernelfile_pathname)) // read kernel file as a precompiled binary blob
          /* HACK */ {
          /* HACK */    fprintf (stderr, "fatal error: unable to read precompiled kernel file \"%s\" specified in --kernelfile argument\n", kernelfile_pathname);
          /* HACK */    exit (1);
          /* HACK */ }
          /* HACK */
       // do we already know the data for this data blob ?
       if (entry_parms->data.bytes != NULL)
+      {
          entry_parms->mtime = entry_parms->mtime_for_inline_files; // if so, set it a mtime equal to the mtime to use for inline files
-         LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)", entry_parms->extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.len);
+         LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)", entry_parms->extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.size);
+      }
       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); // locate the file
+         resolved_pathname = resolve_pathname (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH)); // locate the file
          if (resolved_pathname == NULL)
             DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
+         if (!Buffer_ReadFromFile (&entry_parms->data, resolved_pathname))
+            DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d can't be read: %s", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
-         stat (resolved_pathname, &stat_buf); // can't fail
+         stat (resolved_pathname, &stat_buf); // can't fail, since we could read it
          if (entry_parms->mtime == UINT32_MAX)
             entry_parms->mtime = (uint32_t) stat_buf.st_mtime;
-         LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->data.len);
+         LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->data.size);
+      }
       // is the file we're storing an ELF file ?
+      #define ELFHDR ((elf_header_t *) entry_parms->data.bytes) // this convenient definition will make sure the ELF header points at the right location, even after entry_parms.data->byte is reallocated
-      if ((entry_parms->data.len > 52) // file is big enough to contain an ELF header
+      if ((entry_parms->data.size > 52) // file is big enough to contain an ELF header
-          && ((elf = (elf_header_t *) entry_parms->data.bytes) != NULL) // cast (necessary true)
-          && (memcmp (ELF_GET_STRING (elf, elf, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic
+          && (memcmp (ELF_GET_STRING (ELFHDR, ELFHDR, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic
+      {
          // is the file we're storing a relocatable executable (i.e. a dynamic library) and should we check for its canonical name ?
-         if ((ELF_GET_NUMERIC (elf, elf, type) == 3) && entry_parms->should_autosymlink_dylib)
+         if ((ELF_GET_NUMERIC (ELFHDR, ELFHDR, type) == ELF_TYPE_DYNAMICLIB) && entry_parms->should_autosymlink_dylib)
+         {
-            // we need to find the SONAME of this library
-            canonical_dylib_name = NULL;
             // locate the sections we need (the dynamic section and its strings table)
-            shdr_dynamic = elf_get_section_header_by_name (elf, ".dynamic");
+            const elf_section_header_t *shdr_dynamic = elf_get_section_header_by_name (ELFHDR, ".dynamic");
-            shdr_dynstr = elf_get_section_header_by_name (elf, ".dynstr");
+            const elf_section_header_t *shdr_dynstr = elf_get_section_header_by_name (ELFHDR, ".dynstr");
             // make sure we have both the dynamic section header and its own strings table header
             if ((shdr_dynamic != NULL) && (shdr_dynstr != NULL))
+            {
-               dynamic_strings = (char *) &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, shdr_dynstr, file_offset)]; // quick access to dynamic sections strings table
+               dynamic_strings = (char *) &entry_parms->data.bytes[ELF_GET_NUMERIC (ELFHDR, shdr_dynstr, file_offset)]; // quick access to dynamic sections strings table
                // walk through the dynamic section, look for the DT_SONAME entry
+               canonical_dylib_name = NULL; // assume none until told otherwise
-               for (dynamic_entry = (elf_dynamic_section_entry_t *) &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, shdr_dynamic, file_offset)];
+               for (elf_dynamic_section_entry_t *dynamic_entry = (elf_dynamic_section_entry_t *) &entry_parms->data.bytes[ELF_GET_NUMERIC (ELFHDR, shdr_dynamic, file_offset)];
-                    (ELF_GET_NUMERIC (elf, dynamic_entry, tag) != ELF_DT_NULL);
+                    (ELF_GET_NUMERIC (ELFHDR, dynamic_entry, tag) != ELF_DT_NULL);
-                    dynamic_entry = (elf_dynamic_section_entry_t *) ((uint8_t *) dynamic_entry + ELF_STRUCT_SIZE (elf, dynamic_entry)))
+                    dynamic_entry = (elf_dynamic_section_entry_t *) ((uint8_t *) dynamic_entry + ELF_STRUCT_SIZE (ELFHDR, dynamic_entry)))
-                  if (ELF_GET_NUMERIC (elf, dynamic_entry, tag) == ELF_DT_SONAME)
+                  if (ELF_GET_NUMERIC (ELFHDR, dynamic_entry, tag) == ELF_DT_SONAME)
+                  {
-                     canonical_dylib_name = dynamic_strings + ELF_GET_NUMERIC (elf, dynamic_entry, value);
+                     canonical_dylib_name = dynamic_strings + ELF_GET_NUMERIC (ELFHDR, dynamic_entry, value);
                      break;
+                  }
                // do we have it ?
                if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0))
+               {
-                  sprintf (candidate_pathname, "%s/%s", entry_parms->prefix, canonical_dylib_name);
+                  sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", entry_parms->prefix, canonical_dylib_name);
                   if (strcmp (candidate_pathname, stored_pathname) != 0) // claimed dylib name differs from passed name ?
+                  {
                      original_stored_pathname = stored_pathname; // if so, remember to create a symlink here
                      stored_pathname = candidate_pathname;
+                  }
          } // end if the file we're storing is a dylib
          // now strip this ELF file if necessary
          if (!(entry_parms->extra_ino_flags & IFS_INO_PROCESSED_ELF))
+         {
-            // NOTE: for each ELF file, mkifs
-            // -> alters the program header table and offsets each p_addr (physical address) member by <image_base> plus the current file offset (this cannot be done right now, will need to be done once they are known)
-            // -> throws away and reconstructs the sections table by keeping only the sections that are in the program header, and writes the section table at the start of the first thrown-away section
-            // FIXME: what if a thrown away section is located between two program segments ? are they collapsed, moving the segments beyond it one slot down ?
-            // reconstructed ELF:
-            // ==== START OF FILE ====
-            // ELF header
-            // program header table
-            //  (same sections, just p_addr offset changed)
-            // section data 5 (named ".note.gnu.build-id")
-            //  "............GNU....ZY.....c.o..l"
-            // PROGRAM
-            // sections table
-            // + section 1: ALL ZEROES
-            // + section 2: fileoffs 0x21a8 size 0xfd --> "QNX_info" --> QNX binary description: "NAME=pci_debug2.so.3.0\nDESCRIPTION=PCI Server System Debug Module\nDATE=2023/11/19-10:01:13-EST\nSTATE=lookup\nHOST=docker-n1.bts.rim.net\nUSER=builder\nVERSION=QNXOS_main\nTAGID=QNXOS_800-135\nPACKAGE=com.qnx.qnx800.target.pci.debug/3.0.0.00135T202311191043L\n"
+            Buffer_StripELFFile (&entry_parms->data, stored_pathname); // strip the ELF file à la mkifs
-            // + section 3: fileoffs 0x22a5 size 0x1c --> ".gnu_debuglink" --> indicates the debug file and its checksum: "pci_debug2.so.3.0.sym" "\0\0\0" "VX2p"
-            // + section 4: fileoffs 0x22c1 size 0x2ad --> "QNX_usage" --> HELP TEXT: "\n-------------------------------------------------------------------------------\n%C\n\nThis module implements debug logging for all PCI server modules. It is\nincluded by setting the environment variable PCI_DEBUG_MODULE and uses\nthe slogger2 APIs.\nNOTE:.On systems which support slogger2, you are encouraged to use this module.instead of pci_debug.so...Release History.---------------..3.0 - This module is functionally equivalent to the previous 2.x version.      however it is incompatible with all pre v3.x PCI components..2.1 - fixes a bug whereby if slogger2 is not running and the PCI_DEBUG_MODULE.      environment variable is set, the client will SIGSEGV..2.0 - initial release.."
-            // + section 5: fileoffs 0x190 size 0x32 --> ".note.gnu.build-id" --> GNU build ID
-            // + section 6: fileoffs 0x256e size 0x40 --> ".shstrtab" --> sections names strings table
-            // section data 2 (named "QNX_info")
-            //  (QNX binary description)
-            // section data 3 (named ".gnu_debuglink")
-            //  (debug file)
-            // section data 4 (named "QNX_usage")
-            //  (help text)
-            // section data 6 (named ".shstrtab")
-            //  "\0"
-            //  ".shstrtab\0"
-            //  "QNX_info\0"
-            //  ".gnu_debuglink\0"
-            //  "QNX_usage\0"
-            //  ".note.gnu.build-id\0"
-            // ==== END OF FILE ====
-            // parse the program header table, and measure the farthest offset known by this table where we'll write the reconstructed section headers table
-            new_shdrtable_offset = 0;
-            table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len);
-            for (table_index = 0; table_index < table_count; table_index++)
-            {
-               phdr = (elf_program_header_t *) &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
-               if (ELF_GET_NUMERIC (elf, phdr, file_offset) + ELF_GET_NUMERIC (elf, phdr, size_in_file) > new_shdrtable_offset)
-                  new_shdrtable_offset = ELF_GET_NUMERIC (elf, phdr, file_offset) + ELF_GET_NUMERIC (elf, phdr, size_in_file);
-            }
-            // re-create the section header table
-            elfsection_shstrtab.bytes = malloc (1); // initialize an empty section headers strings table
-            WELLMANNERED_ASSERT (elfsection_shstrtab.bytes, "out of memory");
-            elfsection_shstrtab.bytes[0] = 0;
-            elfsection_shstrtab.len = 1;
-            ADD_NAME_TO_STRINGTABLE (".shstrtab", elfsection_shstrtab);
-            new_shtab.bytes = malloc (ELF_STRUCT_SIZE (elf, shdr)); // prepare a section headers table with just the default entry
-            WELLMANNERED_ASSERT (new_shtab.bytes, "out of memory");
-            memset (new_shtab.bytes, 0, ELF_STRUCT_SIZE (elf, shdr)); // the first section header is always zerofilled
-            new_shtab.len = ELF_STRUCT_SIZE (elf, shdr); // and remember how big the section headers table is now
-            if ((shdr = elf_get_section_header_by_name (elf, "QNX_info")) != NULL)
-            {
-               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
-               {
-                  elfsection_qnxinfo.len = ELF_GET_NUMERIC (elf, shdr, size);
-                  elfsection_qnxinfo.bytes = malloc (elfsection_qnxinfo.len);
-                  WELLMANNERED_ASSERT (elfsection_qnxinfo.bytes, "out of memory");
-                  memcpy (elfsection_qnxinfo.bytes, &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_qnxinfo.len);
-               }
-               reallocated_ptr = realloc (new_shtab.bytes, new_shtab.len + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
-               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-               new_shtab.bytes = reallocated_ptr; // reallocation succeeded, save the new pointer
-               new_qnxinfo_shdr_offset = new_shtab.len; // remember the new offset of this section header
-               new_shtab.len += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
-               new_shdr = (elf_section_header_t *) &new_shtab.bytes[new_qnxinfo_shdr_offset]; // now populate this section header
-               ADD_NAME_TO_STRINGTABLE ("QNX_info", elfsection_shstrtab);
-               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in ("QNX_info", &elfsection_shstrtab)); // update the relative offset of the section name
-               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
-               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
-               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
-               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
-               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
-               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (which should be zero anyway)
-               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
-               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
-               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
-            }
-            if ((shdr = elf_get_section_header_by_name (elf, ".gnu_debuglink")) != NULL)
-            {
-               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
-               {
-                  elfsection_debuglink.len = ELF_GET_NUMERIC (elf, shdr, size);
-                  elfsection_debuglink.bytes = malloc (elfsection_debuglink.len);
-                  WELLMANNERED_ASSERT (elfsection_debuglink.bytes, "out of memory");
-                  memcpy (elfsection_debuglink.bytes, &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_debuglink.len);
-               }
-               reallocated_ptr = realloc (new_shtab.bytes, new_shtab.len + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
-               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-               new_shtab.bytes = reallocated_ptr; // reallocation succeeded, save the new pointer
-               new_debuglink_shdr_offset = new_shtab.len; // remember the new offset of this section header
-               new_shtab.len += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
-               new_shdr = (elf_section_header_t *) &new_shtab.bytes[new_debuglink_shdr_offset]; // now populate this section header
-               ADD_NAME_TO_STRINGTABLE (".gnu_debuglink", elfsection_shstrtab);
-               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in (".gnu_debuglink", &elfsection_shstrtab)); // update the relative offset of the section name
-               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
-               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
-               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
-               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
-               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
-               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (which should be zero anyway)
-               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
-               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
-               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
-            }
-            if ((shdr = elf_get_section_header_by_name (elf, "QNX_usage")) != NULL)
-            {
-               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
-               {
-                  elfsection_qnxusage.len = ELF_GET_NUMERIC (elf, shdr, size);
-                  elfsection_qnxusage.bytes = malloc (elfsection_qnxusage.len);
-                  WELLMANNERED_ASSERT (elfsection_qnxusage.bytes, "out of memory");
-                  memcpy (elfsection_qnxusage.bytes, &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_qnxusage.len);
-               }
-               reallocated_ptr = realloc (new_shtab.bytes, new_shtab.len + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
-               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-               new_shtab.bytes = reallocated_ptr; // reallocation succeeded, save the new pointer
-               new_qnxusage_shdr_offset = new_shtab.len; // remember the new offset of this section header
-               new_shtab.len += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
-               new_shdr = (elf_section_header_t *) &new_shtab.bytes[new_qnxusage_shdr_offset]; // now populate this section header
-               ADD_NAME_TO_STRINGTABLE ("QNX_usage", elfsection_shstrtab);
-               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in ("QNX_usage", &elfsection_shstrtab)); // update the relative offset of the section name
-               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
-               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
-               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
-               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
-               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
-               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (which should be zero anyway)
-               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
-               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
-               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
-            }
-            if ((shdr = elf_get_section_header_by_name (elf, ".note.gnu.build-id")) != NULL)
-            {
-               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
-               {
-                  elfsection_buildid.len = ELF_GET_NUMERIC (elf, shdr, size);
-                  elfsection_buildid.bytes = malloc (elfsection_buildid.len);
-                  WELLMANNERED_ASSERT (elfsection_buildid.bytes, "out of memory");
-                  memcpy (elfsection_buildid.bytes, &entry_parms->data.bytes[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_buildid.len);
-               }
-               reallocated_ptr = realloc (new_shtab.bytes, new_shtab.len + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
-               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-               new_shtab.bytes = reallocated_ptr; // reallocation succeeded, save the new pointer
-               new_buildid_shdr_offset = new_shtab.len; // remember the new offset of this section header
-               new_shtab.len += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
-               new_shdr = (elf_section_header_t *) &new_shtab.bytes[new_buildid_shdr_offset]; // now populate this section header
-               ADD_NAME_TO_STRINGTABLE (".note.gnu.build-id", elfsection_shstrtab);
-               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in (".note.gnu.build-id", &elfsection_shstrtab)); // update the relative offset of the section name
-               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
-               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
-               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
-               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
-               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
-               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (which should be zero anyway)
-               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
-               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
-               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
-            }
-            reallocated_ptr = realloc (new_shtab.bytes, new_shtab.len + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
-            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-            new_shtab.bytes = reallocated_ptr; // reallocation succeeded, save the new pointer
-            new_shstrtab_shdr_offset = new_shtab.len; // remember the new offset of this section header
-            new_shtab.len += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
-            new_shdr = (elf_section_header_t *) &new_shtab.bytes[new_shstrtab_shdr_offset]; // now populate this section header
-            ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in (".shstrtab", &elfsection_shstrtab)); // update the relative offset of the section name
-            ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_SECTIONTYPE_STRINGTABLE); // section type (SHT_STRTAB)
-            ELF_SET_NUMERIC (elf, new_shdr, flags,        0); // section flags (we could set SHF_STRINGS i.e. 0x20 here, but mkifs does not, so mimic that)
-            ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, 0); // this section does not need to be mapped
-            ELF_SET_NUMERIC (elf, new_shdr, file_offset, WILL_BE_FILLED_LATER); // will be filled once we know it
-            ELF_SET_NUMERIC (elf, new_shdr, size,         elfsection_shstrtab.len); // section size
-            ELF_SET_NUMERIC (elf, new_shdr, linked_index, 0); // this section is not linked to any other
-            ELF_SET_NUMERIC (elf, new_shdr, info,         0); // this section has no additional info
-            ELF_SET_NUMERIC (elf, new_shdr, alignment,    1); // this section is byte-aligned
-            ELF_SET_NUMERIC (elf, new_shdr, entry_size,   0); // this section is not a table, so entry_size is zero
-            // jump over the new section headers table and write the sections that need to be relocated after the section headers table
-            entry_parms->data.len = new_shdrtable_offset + new_shtab.len; // assume there are no sections beyond the section headers table until known otherwise
-            if (elfsection_qnxinfo.bytes != NULL)
-               APPEND_SECTION_DATA (elfsection_qnxinfo, new_qnxinfo_shdr_offset); // write "QNX_info" section data if we have such a section
-            if (elfsection_debuglink.bytes != NULL)
-               APPEND_SECTION_DATA (elfsection_debuglink, new_debuglink_shdr_offset); // write ".gnu_debuglink" section data if we have such a section
-            if (elfsection_qnxusage.bytes != NULL)
-               APPEND_SECTION_DATA (elfsection_qnxusage, new_qnxusage_shdr_offset); // write "QNX_usage" section data if we have such a section
-            if (elfsection_buildid.bytes != NULL)
-               APPEND_SECTION_DATA (elfsection_buildid, new_buildid_shdr_offset); // write ".note.gnu.build-id" section data if we have such a section
-            APPEND_SECTION_DATA (elfsection_shstrtab, new_shstrtab_shdr_offset); // write the section header strings table as the last section
-            // now write the section headers table
-            memcpy (&entry_parms->data.bytes[new_shdrtable_offset], new_shtab.bytes, new_shtab.len);
-            free (new_shtab.bytes); // free it
-            // and finally fix the ELF header
-            ELF_SET_NUMERIC (elf, elf, section_header_table_offset, new_shdrtable_offset);
-            ELF_SET_NUMERIC (elf, elf, section_header_table_len, new_shtab.len / ELF_STRUCT_SIZE (elf, shdr));
-            ELF_SET_NUMERIC (elf, elf, section_header_names_idx, new_shtab.len / ELF_STRUCT_SIZE (elf, shdr) - 1); // the section headers strings table is the last section
-            // align size with page size (4096 on x86, 16k on ARM)
-            end_padding_offset = entry_parms->data.len;
-            if (ELF_GET_NUMERIC (elf, elf, instruction_set) == ELF_MACHINE_X86_64)
-               entry_parms->data.len = ROUND_TO_UPPER_MULTIPLE (end_padding_offset, 4 * 1024); // 4 kb pages on Intel processors
-            else if (ELF_GET_NUMERIC (elf, elf, instruction_set) == ELF_MACHINE_AARCH64)
-               entry_parms->data.len = ROUND_TO_UPPER_MULTIPLE (end_padding_offset, 16 * 1024); // 16 kb pages on ARM64
-            else
-               DIE_WITH_EXITCODE (1, "this ELF file \"%s\" does not belong to an architecture supported by ifstool (neither x86_64, nor aarch64)", stored_pathname);
-            memset (&entry_parms->data.bytes[end_padding_offset], 0, entry_parms->data.len - end_padding_offset); // zerofill
             entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
          } // end if the file is not yet a processed ELF
       } // end if the file we're storing is an ELF file
+      #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file
+   }
    else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?
       LOG_INFO ("symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);
    else // we must be storing a FIFO
+   {
       LOG_INFO ("fifo: ino 0x%x uid %d gid %d mode 0%o path \"%s\" dev:rdev %s)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);
+   }
    // grow filesystem entries array to hold one more slot
    reallocated_ptr = realloc (*fsentries, (*fsentry_count + 1) * sizeof (fsentry_t)); // attempt to reallocate
-   WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+   ASSERT_WITH_ERRNO (reallocated_ptr);
    *fsentries = reallocated_ptr; // save reallocated pointer
    fsentry = &(*fsentries)[*fsentry_count]; // quick access to fs entry slot
-   //fsentry->header.size = 0; // will be filled once we know it
    fsentry->header.extattr_offset = 0;
    fsentry->header.ino = entry_parms->extra_ino_flags | (++inode_count);
    fsentry->header.mode = entry_parms->st_mode;
    fsentry->header.gid = entry_parms->gid;
    fsentry->header.uid = entry_parms->uid;
    fsentry->header.mtime = (entry_parms->mtime == UINT32_MAX ? (uint32_t) time (NULL) : entry_parms->mtime);
    if (S_ISDIR (entry_parms->st_mode))
+   {
       fsentry->u.dir.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + strlen (fsentry->u.dir.path) + 1, image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = true; // no data to save
+   }
    else if (S_ISREG (entry_parms->st_mode))
+   {
       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->data.len;
+      fsentry->u.file.size = (uint32_t) entry_parms->data.size;
       fsentry->u.file.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
-      fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->data.len);
+      fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->data.size);
-      WELLMANNERED_ASSERT (fsentry->u.file.UNSAVED_databuf, "out of memory");
+      ASSERT_WITH_ERRNO (fsentry->u.file.UNSAVED_databuf);
-      memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data.bytes, entry_parms->data.len);
+      memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data.bytes, entry_parms->data.size);
       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->data.len;
+      fsentry->u.symlink.sym_size = (uint16_t) entry_parms->data.size;
       fsentry->u.symlink.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
       fsentry->u.symlink.contents = strdup (entry_parms->data.bytes);
-      WELLMANNERED_ASSERT (fsentry->u.symlink.contents, "out of memory");
+      ASSERT_WITH_ERRNO (fsentry->u.symlink.contents);
       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
+   {
       fsentry->u.device.dev  = strtol (entry_parms->data.bytes, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
       fsentry->u.device.rdev = strtol (strchr (entry_parms->data.bytes, ':') + 1, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
       fsentry->u.device.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.device.path), image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = true; // no data to save
+   }
    (*fsentry_count)++;
       entry_parms->st_mode = S_IFLNK | 0777; // NOTE: mkifs stores symlink permissions as rwxrwxrwx !
       entry_parms->extra_ino_flags = (fsentry->header.ino & (IFS_INO_PROCESSED_ELF | IFS_INO_RUNONCE_ELF | IFS_INO_BOOTSTRAP_EXE)); // preserve target's inode flags
       last_dirsep = strrchr (stored_pathname, '/');
       old_data = entry_parms->data.bytes; // backup previous data pointer
       entry_parms->data.bytes = (uint8_t *) (last_dirsep == NULL ? stored_pathname : last_dirsep + 1); // store symlink target in dirent data
-      entry_parms->data.len = strlen (entry_parms->data.bytes);
+      entry_parms->data.size = strlen (entry_parms->data.bytes);
       add_fsentry (fsentries, fsentry_count, entry_parms, original_stored_pathname, NULL);
       entry_parms->data.bytes = old_data; // restore previous data pointer so that it can be freed normally
+   }
    return (*fsentry_count);
    else // envvar not present
+   {
       if (MKIFS_PATH != NULL)
          free (MKIFS_PATH); // free any MKIFS_PATH that we constructed earlier
-      strcpy (processor_base, processor); // construct PROCESSOR_BASE
+      strcpy_s (processor_base, sizeof (processor_base), processor); // construct PROCESSOR_BASE
       token = strchr (processor_base, '-');
       if (token != NULL)
          *token = 0; // split anything from the first dash onwards
       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
+      ASSERT_WITH_ERRNO (MKIFS_PATH);
-      WELLMANNERED_ASSERT (MKIFS_PATH, "out of memory");
+      sprintf_s (MKIFS_PATH, 10 * MAXPATHLEN,
-      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
+                 "." PATH_SEP "%s/%s/sbin" PATH_SEP "%s/%s/usr/sbin" PATH_SEP "%s/%s/boot/sys" PATH_SEP "%s/%s/boot/sys" PATH_SEP "%s/%s/bin" PATH_SEP "%s/%s/usr/bin" PATH_SEP "%s/%s/lib" PATH_SEP "%s/%s/lib/dll" PATH_SEP "%s/%s/usr/lib", // use a platform-specific character as path separator
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor_base,
+                 QNX_TARGET, processor_base,
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor,
+                 QNX_TARGET, processor,
-               QNX_TARGET, processor);
+                 QNX_TARGET, processor);
+   }
    return;
+}
 int main (int argc, char **argv)
+{
    // program entrypoint
+   typedef struct ifs_offsets_s
+   {
+      size_t startupheader;
+      size_t startuptrailer;
+      size_t imageheader;
+      size_t imagedir;
+      size_t imagetrailer;
+   } ifs_offsets_t;
+   typedef struct ifs_s
+   {
+      buffer_t data;
+      ifs_offsets_t offsets;
-   #define PAD_OUTFILE_TO(val) do { curr_offset = ftell (fp); while (curr_offset < (val)) { putc (0, fp); curr_offset++; } } while (0)
+      size_t final_size; // final size: not known (because not set) until everything has been written
+   } ifs_t;
    static startup_header_t startup_header = { 0 }; // output IFS's startup header
    static startup_trailer_v2_t startup_trailer = { 0 }; // output IFS's startup trailer (version 2, with SHA-512 checksum and int32 checksum)
    static image_header_t image_header = { 0 }; // output IFS's imagefs header
    static image_trailer_v2_t image_trailer = { 0 }; // output IFS's imagefs trailer (version 2, with SHA-512 checksum and int32 checksum)
    char path_on_buildhost[MAXPATHLEN] = "";
    char path_in_ifs[MAXPATHLEN] = "";
    char *ifs_pathname = NULL;
    void *reallocated_ptr;
-   const elf_header_t *elf;
-   elf_program_header_t *phdr;
    struct tm utc_time;
    struct stat stat_buf;
-   size_t startuptrailer_offset;
-   size_t startupheader_offset;
-   size_t imagetrailer_offset;
-   size_t imageheader_offset;
-   size_t corrective_offset;
-   size_t imgdir_offset;
    size_t imgdir_size;
-   size_t final_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;
-   size_t table_index;
-   size_t table_count;
+   ifs_t ifs = { 0 };
-   buffer_t blob;
    int32_t checksum;
+   char *first_pathname = NULL;
+   char *second_pathname = NULL;
    char *specifiedpathname_start;
    char *directiveblock_start;
    char *write_ptr;
    char *line_ptr;
-   char *outdir = ".";
    char *token;
    char *value;
    char *sep;
-   //char *ctx;
+   char *ctx;
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
    bool should_discard_inline_contents = false;
    bool want_info = false;
    bool want_everything = false;
    bool want_help = false;
    bool want_dump = false;
+   bool want_strip = false;
    bool want_hexdump = false;
    bool is_foreign_endianness;
    int string_len;
    int read_char;
    FILE *buildfile_fp;
-   FILE *fp;
    // parse arguments
    for (arg_index = 1; arg_index < argc; arg_index++)
+   {
       if ((strcmp (argv[arg_index], "--bootfile") == 0) && (arg_index + 1 < argc)) // --bootfile path/to/blob.bin
+      {
          default_parms.mtime = 0; // *all* files should have a mtime set to zero
          default_parms.mtime_for_inline_files = 0;
+      }
       else if ((strcmp (argv[arg_index], "--outdir") == 0) && (arg_index + 1 < argc)) // --outdir path
+         second_pathname = argv[++arg_index];
+      else if ((strcmp (argv[arg_index], "--outfile") == 0) && (arg_index + 1 < argc)) // --outfile pathname
-         outdir = argv[++arg_index];
+         second_pathname = argv[++arg_index];
       else if (strcmp (argv[arg_index], "--info") == 0)
          want_info = true;
       else if (strcmp (argv[arg_index], "--dump") == 0)
          want_dump = true;
       else if (strcmp (argv[arg_index], "--hexdump") == 0) // voluntarily undocumented
          want_hexdump = true;
+      else if (strcmp (argv[arg_index], "--strip") == 0)
+         want_strip = true;
       else if (strcmp (argv[arg_index], "--everything") == 0)
          want_everything = true;
       else if (strncmp (argv[arg_index], "-v", 2) == 0) // -v[....]
          verbose_level += (int) strlen (argv[arg_index] + 1); // increase verbosity by the number of characters in this flag
       else if ((strcmp (argv[arg_index], "-?") == 0) || (strcmp (argv[arg_index], "--help") == 0))
          want_help = true;
-      else if (buildfile_pathname == NULL)
+      else if (first_pathname == NULL)
-         buildfile_pathname = argv[arg_index];
+         first_pathname = argv[arg_index];
-      else if (ifs_pathname == NULL)
+      else if (second_pathname == NULL)
-         ifs_pathname = argv[arg_index];
+         second_pathname = argv[arg_index];
+      else
+         DIE_WITH_EXITCODE (1, "unrecognized option: '%s'", argv[arg_index]);
+   }
    // do we not have enough information to run ?
-   if (want_help || (buildfile_pathname == NULL) || (!want_info && !want_dump && !want_hexdump && (ifs_pathname == NULL)))
+   if (want_help || (first_pathname == NULL) || (!want_info && !want_dump && !want_hexdump && !want_strip && (second_pathname == NULL)))
+   {
-      fp = (want_help ? stdout : stderr); // select the right output channel
+      FILE *out = (want_help ? stdout : stderr); // select the right output channel
-      fprintf (fp, "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");
+      fprintf (out, "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");
-      fprintf (fp, "          version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
+      fprintf (out, "          version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
       if (!want_help)
-         fprintf (fp, "error: missing parameters\n");
+         fprintf (out, "error: missing parameters\n");
-      fprintf (fp, "usage:\n");
+      fprintf (out, "usage:\n");
-      fprintf (fp, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-n[n]] <buildfile> <outfile>\n");
+      fprintf (out, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-n[n]] [-v[...]] <buildfile> <outfile>\n");
-      fprintf (fp, "    ifstool --info [--everything] <ifs file>\n");
+      fprintf (out, "    ifstool --info [--everything] <ifs file>\n");
-      fprintf (fp, "    ifstool --dump [--outdir <path>] <ifs file>\n");
+      fprintf (out, "    ifstool --dump [--outdir <path>] <ifs file>\n");
+      fprintf (out, "    ifstool --strip [--outfile <pathname>] <ELF file>\n");
-      fprintf (fp, "    ifstool --help\n");
+      fprintf (out, "    ifstool --help\n");
-      fprintf (fp, "NOTE: the compilation feature requires predigested boot, startup and kernel files produced by mkifs.\n");
+      fprintf (out, "NOTE: the compilation feature requires predigested boot, startup and kernel files produced by mkifs.\n");
       exit (want_help ? 0 : 1);
+   }
    // do we want info about a particular IFS ? if so, dissecate it
    if (want_info)
-      exit (dump_ifs_info (buildfile_pathname, want_everything)); // NOTE: the first argument after --info is actually the IFS file, not a build file, but the arguments are collected in this order
+      exit (dump_ifs_info (first_pathname, want_everything));
    // else do we want to dump its contents ? if so, do so
    else if (want_dump)
-      exit (dump_ifs_contents (buildfile_pathname, outdir)); // NOTE: the first argument after --info is actually the IFS file, not a build file, but the arguments are collected in this order
+      exit (dump_ifs_contents (first_pathname, (second_pathname != NULL ? second_pathname : ".")));
    // else do we want to hex dump a file ? (this is voluntarily undocumented)
    else if (want_hexdump)
+      exit (dump_file_hex (first_pathname));
+   // else do we want to strip an ELF file ? if so, do so
+   else if (want_strip)
+   {
+      buffer_t file;
-      if (read_filecontents (buildfile_pathname, ".", &blob) == NULL)
+      ASSERT (Buffer_ReadFromFile (&file, first_pathname), "can't open \"%s\" for reading: %s", first_pathname, strerror (errno));
-         DIE_WITH_EXITCODE (1, "can't read \"%s\": %s", buildfile_pathname, strerror (errno));
+      ASSERT (Buffer_StripELFFile (&file, first_pathname), "error stripping \"%s\": %s", first_pathname, strerror (errno));
-      hex_fprintf (stdout, blob.bytes, blob.len, 16, "%s (%zd bytes):\n", buildfile_pathname, blob.len);
+      ASSERT_WITH_ERRNO (Buffer_WriteToFile (&file, (second_pathname != NULL ? second_pathname : "<stdout>")));
       exit (0);
+   }
+   // we want to CREATE an IFS file
+   buildfile_pathname = first_pathname; // assign the pathnames properly
+   ifs_pathname = second_pathname;
    // make sure we have ${QNX_TARGET} pointing somewhere
    QNX_TARGET = getenv ("QNX_TARGET");
    if (QNX_TARGET == NULL)
       DIE_WITH_EXITCODE (1, "the QNX_TARGET environment variable is not set");
    // prepare a default MKIFS_PATH assuming the host processor
    update_MKIFS_PATH (image_processor);
    // open build file
-   buildfile_fp = fopen (buildfile_pathname, "rb");
+   fopen_s (&buildfile_fp, buildfile_pathname, "rb");
    if (buildfile_fp == NULL)
       DIE_WITH_EXITCODE (1, "unable to open build file \"%s\" for reading: %s", buildfile_pathname, strerror (errno));
    // stack up filesystem entries
    memcpy (&entry_parms, &default_parms, sizeof (default_parms));
    while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)
+   {
       if (current_line != NULL)
          free (current_line);
       current_line = strdup (line_buffer);
-      WELLMANNERED_ASSERT (current_line, "out of memory");
+      ASSERT_WITH_ERRNO (current_line);
       lineno++; // keep track of current line number
       line_ptr = line_buffer;
       while ((*line_ptr != 0) && isspace (*line_ptr))
          line_ptr++; // skip leading spaces
          while ((*line_ptr != 0) && !((*line_ptr == ']') && (line_ptr[-1] != '\\') && !is_quoted_context))
+         {
             if (*line_ptr == '"')
                is_quoted_context ^= true; // remember when we're between quotes
             else if (!is_quoted_context && (*line_ptr == ' '))
-               *line_ptr = RECORD_SEP; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
+               *line_ptr = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
             line_ptr++; // reach the next unescaped closing square bracket
+         }
          if (*line_ptr != ']')
+         {
             LOG ("warning", 0, "syntax error in \"%s\" line %d: unterminated attributes block (skipping)", buildfile_pathname, lineno);
+         }
          *line_ptr = 0; // end the attribute block so that it is a parsable C string
          // now parse the attribute tokens
          // DOCUMENTATION: https://www.qnx.com/developers/docs/8.0/com.qnx.doc.neutrino.utilities/topic/m/mkifs.html#mkifs__description
-         token = strtok (directiveblock_start, RECORD_SEP_STR);
+         token = strtok_r (directiveblock_start, RECORD_SEP, &ctx);
          while (token != NULL)
+         {
             // evaluate attribute token
             #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)
             if      (strncmp (token, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.uid     = (int) read_integer (value); }
                else if (strcmp (value, "file") == 0) entry_parms.st_mode = S_IFREG;
                else if (strcmp (value, "link") == 0) entry_parms.st_mode = S_IFLNK;
                else if (strcmp (value, "fifo") == 0) entry_parms.st_mode = S_IFIFO;
                else DIE_WITH_EXITCODE (1, "invalid 'type' attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, value);
+            }
-            else if (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); strcpy (entry_parms.prefix, (*value == '/' ? value + 1 : value)); } // skip possible leading slash in prefix
+            else if (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); strcpy_s (entry_parms.prefix, sizeof (entry_parms.prefix), (*value == '/' ? value + 1 : value)); } // skip possible leading slash in prefix
             else if (strncmp (token, "image=",   6) == 0) { REACH_TOKEN_VALUE ();
                image_base = (uint32_t) read_integer (value); // read image base address
                if ((sep = strchr (value, '-')) != NULL) image_end       = (uint32_t) read_integer (sep + 1); // if we have a dash, read optional image end (TODO: check this value and produce an error in the relevant case. Not important.)
                if ((sep = strchr (value, ',')) != NULL) image_maxsize   = (uint32_t) read_integer (sep + 1); // if we have a comma, read optional image max size
                if ((sep = strchr (value, '=')) != NULL) image_totalsize = (uint32_t) read_integer (sep + 1); // if we have an equal sign, read optional image padding size
                if ((bootfile_pathname == NULL) || (startupfile_pathname == NULL) || (kernelfile_pathname == NULL)) // HACK until I figure out how to re-create them
                   DIE_WITH_EXITCODE (1, "creating bootable images require the --bootfile, --startupfile and --kernelfile command-line options in \"%s\" line %d", buildfile_pathname, lineno);
                if ((sep = strchr (value, ',')) != NULL) // do we have a comma separating (optional) processor and boot file name ?
+               {
                   *sep = 0;
-                  strcpy (image_processor, value); // save processor
+                  strcpy_s (image_processor, sizeof (image_processor), value); // save processor
                   update_MKIFS_PATH (image_processor);
                   value = sep + 1;
+               }
                //sprintf (image_bootfile, "%s/%s/boot/sys/%s.boot", QNX_TARGET, image_processor, value); // save preboot file name (TODO: we should search in MKIFS_PATH instead of this. Not important.)
                //strcpy (image_bootfile, bootfile_pathname); // FIXME: HACK
 #if 1
                // ######################################################################################################################################################################################################################################
                // # 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
                // ######################################################################################################################################################################################################################################
-//               if (read_filecontents (kernelfile_pathname, ".", &entry_parms.data) == NULL)
+//               if (!Buffer_ReadFromFile (&entry_parms.data, kernelfile_pathname))
 //                  DIE_WITH_EXITCODE (1, "unable to read precompiled kernel file \"%s\" specified in --kernelfile argument: %s", kernelfile_pathname, strerror (errno));
 #else // nonworking
                strcpy (path_on_buildhost, "procnto-smp-instr");
 #endif // nonworking
+            }
             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)
+                  if (sscanf_s (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)
+                  {
                      LOG_WARNING ("syntax error in \"%s\" line %d: mtime specification not in YYYY-MM-DD-HH:MM:SS format (skipping)", buildfile_pathname, lineno);
                      continue; // invalid attribute block, skip line
+                  }
                   utc_time.tm_mon--; // convert month from [1-12] to [0-11]
                   entry_parms.mtime = (uint32_t) mktime (&utc_time);
+               }
+            }
             else if (strcmp (token, "+script")     == 0) {
                entry_parms.is_compiled_bootscript = true;
-               entry_parms.data.bytes = malloc (sizeof (INITIAL_STARTUP_SCRIPT) - 1);
-               WELLMANNERED_ASSERT (entry_parms.data.bytes, "out of memory");
-               memcpy (entry_parms.data.bytes, INITIAL_STARTUP_SCRIPT, sizeof (INITIAL_STARTUP_SCRIPT) - 1); // FIXME: HACK until the script compiler is implemented
+               ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&entry_parms.data, INITIAL_STARTUP_SCRIPT)); // FIXME: HACK until the script compiler is implemented
-               entry_parms.data.len = sizeof (INITIAL_STARTUP_SCRIPT) - 1;
                should_discard_inline_contents = true; // remember we already have data (so as to discard the inline block's contents)
+            }
             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, "+keeplinked") == 0) entry_parms.should_keep_ld_output = true;
             else if (strcmp (token, "-keeplinked") == 0) entry_parms.should_keep_ld_output = false;
             else LOG_WARNING ("unimplemented attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, token);
             #undef REACH_TOKEN_VALUE
-            token = strtok (NULL, RECORD_SEP_STR); // proceed to next attribute token
+            token = strtok_r (NULL, RECORD_SEP, &ctx); // proceed to next attribute token
+         }
          line_ptr++; // reach the next character
          while ((*line_ptr != 0) && isspace (*line_ptr))
             line_ptr++; // skip leading spaces
                   LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d", default_parms.attr, entry_parms.attr, buildfile_pathname, lineno); \
                   default_parms.attr = entry_parms.attr; \
                } } while (0)
             #define APPLY_DEFAULT_ATTR_STR(attr,descr,fmt) do { if (strcmp (entry_parms.attr, default_parms.attr) != 0) { \
                   LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d", default_parms.attr, entry_parms.attr, buildfile_pathname, lineno); \
-                  strcpy (default_parms.attr, entry_parms.attr); \
+                  strcpy_s (default_parms.attr, sizeof (default_parms.attr), entry_parms.attr); \
                } } while (0)
             APPLY_DEFAULT_ATTR_NUM (dperms,                   "directory permissions",           "0%o");
             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");
+         }
          // end of attributes parsing
       } // end of "this line starts with an attributes block"
       // there's data in this line. We expect a filename in the IFS. Read it and unescape escaped characters
-      string_len = sprintf (path_in_ifs, "%s", entry_parms.prefix);
+      string_len = sprintf_s (path_in_ifs, sizeof (path_in_ifs), "%s", entry_parms.prefix);
       while ((string_len > 0) && (path_in_ifs[string_len - 1] == '/'))
          string_len--; // chop off any trailing slashes from prefix
       write_ptr = &path_in_ifs[string_len];
       *write_ptr++ = '/'; // add ONE trailing slash
       specifiedpathname_start = write_ptr; // remember the specified pathname will start here
                else
+               {
                   is_escaped_char = false; // any other char, meaning the next one will not be escaped
                   if (!should_discard_inline_contents) // only store the contents if we do NOT know the data yet
+                  {
-                     if (entry_parms.data.len == allocated_size) // reallocate in 4 kb blocks
+                     if (entry_parms.data.size == allocated_size) // reallocate in 4 kb blocks
+                     {
                         reallocated_ptr = realloc (entry_parms.data.bytes, allocated_size + 4096);
-                        WELLMANNERED_ASSERT (reallocated_ptr != NULL, "out of memory");
+                        ASSERT_WITH_ERRNO (reallocated_ptr);
                         entry_parms.data.bytes = reallocated_ptr;
                         allocated_size += 4096;
+                     }
-                     entry_parms.data.bytes[entry_parms.data.len++] = read_char;
+                     entry_parms.data.bytes[entry_parms.data.size++] = read_char;
+                  }
                   if (read_char == '\n')
                      lineno++; // update line counter as we parse the inline content
+               }
             } // end for
             *write_ptr = 0; // terminate the string
             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.data.bytes = strdup (specifiedpathname_start); // if so, store the symlink target as the dirent's blob data
+               ASSERT_WITH_ERRNO (Buffer_InitWithCString (&entry_parms.data, specifiedpathname_start)); // if so, store the symlink target as the dirent's blob data
-               WELLMANNERED_ASSERT (entry_parms.data.bytes != NULL, "out of memory");
-               entry_parms.data.len = strlen (specifiedpathname_start);
-            }
             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
+               strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is given after the equal sign
+         }
+      }
       else // no equal sign, meaning the file will have the same name on the build host filesystem
+      {
          // consistency check: symlinks MUST have an equal sign
+         {
             LOG_WARNING ("syntax error in \"%s\" line %d: missing equal sign and symlink target (skipping)", buildfile_pathname, lineno);
             continue; // invalid symlink specification, skip line
+         }
-         strcpy (path_on_buildhost, specifiedpathname_start); // the path on the build host is the one specified
+         strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is the one specified
          sep = strrchr (specifiedpathname_start, '/');
          if (sep != NULL)
             memmove (specifiedpathname_start, sep + 1, strlen (sep + 1) + 1); // the path in the IFS will be the BASENAME of the path specified (after the prefix)
+      }
       if (entry_parms.data.bytes != NULL)
          free (entry_parms.data.bytes); // if blob data was allocated, free it
+   }
-   // write IFS file
+   fclose (buildfile_fp); // finished parsing the build file
-   fp = fopen (ifs_pathname, "w+b");
+   //////////////////////////////////
-   if (fp == NULL)
+   // start constructing the IFS file
-      DIE_WITH_EXITCODE (1, "failed to open \"%s\" for writing: %s", ifs_pathname, strerror (errno));
+   Buffer_Initialize (&ifs.data);
    // do we have a startup file ? if so, this is a bootable image
    if (startupfile_pathname != NULL)
+   {
       // write boot prefix
       // ######################################################################################################################################################################################################################################
       // # FIXME: figure out how to re-create it
       // ######################################################################################################################################################################################################################################
+      buffer_t file;
-      fwrite_filecontents (bootfile_pathname, fp);
+      if (!Buffer_ReadFromFile (&file, bootfile_pathname))
+         DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", bootfile_pathname, strerror (errno));
+      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &file)); // write boot blob
+      Buffer_Forget (&file);
-      PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
-      startupheader_offset = ftell (fp); // save startup header offset
+      ifs.offsets.startupheader = ifs.data.size; // save startup header offset for future use
       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
       startup_header.version       = 1;
       startup_header.flags1        = STARTUP_HDR_FLAGS1_VIRTUAL | STARTUP_HDR_FLAGS1_TRAILER_V2; // flags, 0x21 (STARTUP_HDR_FLAGS1_VIRTUAL | STARTUP_HDR_FLAGS1_TRAILER_V2)
       startup_header.header_size   = sizeof (startup_header); // 256
       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_or_die (&startup_header, 1, sizeof (startup_header), fp); // write startup header
+      ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &startup_header, sizeof (startup_header))); // write startup header
-      PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
       // ######################################################################################################################################################################################################################################
       // # FIXME: figure out how to re-create it:
       // first: open "startup-x86" ELF file,
       //        lookup section headers table (there is no program headers table in this one)
       //        FIXME: figure out something in there where the result is 0x1401030 !!!
       // then: call the linker: 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
       // then: parse resulting ELF file, take all program segments and concatenate them --> this is the blob (FIXME: wrong?)
       // ######################################################################################################################################################################################################################################
 #if 0 // nonworking
-      {
-         buffer_t startupfile;
-         elf_section_header_t *shdr_text;
-         size_t segment_len;
-FILE *control_fp = fopen ("startup.bin.MYSTRIPPED", "wb");
-         if (read_filecontents ("startup.bin.UNSTRIPPED", MKIFS_PATH, &startupfile) == NULL)
-            DIE_WITH_EXITCODE (1, "couldn't read startup-x86");
-         elf = (elf_header_t *) startupfile.bytes; // quick access to ELF header
-         table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
-         for (table_index = 0; table_index < table_count; table_index++) // cycle through program headers
-         {
-            phdr = (elf_program_header_t *) &startupfile.bytes[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
-            segment_len = ELF_GET_NUMERIC (elf, phdr, size_in_file);
-            fwrite_or_die (&startupfile.bytes[ELF_GET_NUMERIC (elf, phdr, file_offset)], 1, segment_len, fp); // dump program segment
-fwrite_or_die (&startupfile.bytes[ELF_GET_NUMERIC (elf, phdr, file_offset)], 1, segment_len, control_fp); // dump program segment
-while (segment_len % 4096 > 0)
-{
-   fputc (0, control_fp);
-   segment_len++;
+      // <deleted>
-}
-         }
-fclose (control_fp);
-         free (startupfile.bytes);
-      }
 #else // working
+      if (!Buffer_ReadFromFile (&file, startupfile_pathname))
+         DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", startupfile_pathname, strerror (errno));
-      fwrite_filecontents (startupfile_pathname, fp); // write startup code from blob file
+      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &file)); // write startup blob
+      Buffer_Forget (&file);
 #endif // working
-      PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
-      startuptrailer_offset = ftell (fp); // save startup trailer offset
+      ifs.offsets.startuptrailer = ifs.data.size; // save startup trailer offset for future use
-      fwrite_or_die (&startup_trailer, 1, sizeof (startup_trailer), fp); // write startup trailer
+      ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &startup_trailer, sizeof (startup_trailer))); // write startup trailer
-      PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
+   }
-   imageheader_offset = ftell (fp); // save image header offset
+   ifs.offsets.imageheader = ifs.data.size; // save image header offset for future use
    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_or_die (&image_header, 1, sizeof (image_header), fp); // write image header
+   ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &image_header, sizeof (image_header))); // write image header
-   PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
    // write image directory (with the wrong file offsets)
-   imgdir_offset = ftell (fp);
+   ifs.offsets.imagedir = ifs.data.size; // save image directory offset for future use
-   imgdir_size = 0; // measure image dir size on the fly
+   curr_offset = ifs.offsets.imagedir;
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+   {
+      Buffer_WriteIFSDirectoryEntryAt (&ifs.data, curr_offset, &fsentries[fsentry_index]); // write each dirent (the unknown fields will be fixed later)
-      imgdir_size += fwrite_fsentry (&fsentries[fsentry_index], fp); // NOTE: padding is handled in this function
+      curr_offset += fsentries[fsentry_index].header.size; // advance to the next one
+   }
-   fwrite_or_die ("\0\0\0\0", 1, 4, fp); // there seems to be 4 bytes of padding after the image directory
+   ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&ifs.data, "\0\0\0\0")); // there seems to be 4 bytes of padding after the image directory
-   imgdir_size += 4;
+   imgdir_size = ifs.data.size - ifs.offsets.imagedir; // measure image dir size and save it for future use
    // 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 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)
+         if (ifs.data.size + fsentries[fsentry_index].u.file.size >= kernelfile_offset)
-            DIE_WITH_EXITCODE (1, "the compiled startup script is too big (%zd bytes, max is %zd) to fit at current offset %zd", (size_t) fsentries[fsentry_index].u.file.size, kernelfile_offset - curr_offset, curr_offset);
+            DIE_WITH_EXITCODE (1, "the compiled startup script is too big (%zd bytes, max is %zd) to fit at current offset %zd", (size_t) fsentries[fsentry_index].u.file.size, kernelfile_offset - ifs.data.size, ifs.data.size);
-         fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
+         fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // 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
+         Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write file data
          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
+         available_space = kernelfile_offset - ifs.data.size; // measure the available space until the kernel
          // look for the biggest one that can fit
          largest_index = 0;
          largest_size = 0;
          for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
                largest_index = fsentry_index;
+            }
+         }
          if (largest_size == 0)
             break; // found none ? if so, stop searching
+         fsentry_index = largest_index;
-         fsentries[largest_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
+         fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // save file data blob offset in file structure
-         // is the file we're storing a preprocessed ELF file ?
-         if (fsentries[largest_index].header.ino & IFS_INO_PROCESSED_ELF)
-         {
-            elf = (elf_header_t *) fsentries[largest_index].u.file.UNSAVED_databuf; // quick access to ELF header
-            table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
-            for (table_index = 0; table_index < table_count; table_index++)
-            {
-               phdr = (elf_program_header_t *) &fsentries[largest_index].u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+         Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write file data
-               corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);
-               if (ELF_GET_NUMERIC (elf, phdr, size_in_memory) != 0) // only patch the physical address of segments that have an actual size in memory
-                  ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + curr_offset - corrective_offset); // patch the physical address member of the program header table
-            }
-         }
-         fwrite_or_die (fsentries[largest_index].u.file.UNSAVED_databuf, 1, fsentries[largest_index].u.file.size, fp); // write file data blob
-         fsentries[largest_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+         fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
-      LOG_INFO ("Current offset: 0x%zx", curr_offset);
+      LOG_INFO ("Last written offset: 0x%zx", ifs.data.size);
       LOG_INFO ("Kernel file offset: 0x%zx", kernelfile_offset);
-      PAD_OUTFILE_TO (kernelfile_offset); // reach the kernel offset
+      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, 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
+      fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // save file data blob offset in file structure
 #ifdef PROCNTO_WIP
       // is the kernel we're storing a preprocessed ELF kernel ?
       if (fsentries[fsentry_index].header.ino & IFS_INO_PROCESSED_ELF)
+      {
          elf = (elf_header_t *) fsentries[fsentry_index].u.file.UNSAVED_databuf; // quick access to ELF header
          for (table_index = 0; table_index < table_count; table_index++)
+         {
             phdr = (elf_program_header_t *) &fsentries[fsentry_index].u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
             corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);
             if (ELF_GET_NUMERIC (elf, phdr, size_in_memory) != 0) // only patch the physical address of segments that have an actual size in memory
-               ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + curr_offset - corrective_offset); // patch the physical address member of the program header table
+               ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + ifs.data.size - corrective_offset); // patch the physical address member of the program header table (NOTE: ifs.data.size is the location where the file data is about to be written)
+         }
+      }
 #endif // PROCNTO_WIP
-      fwrite_or_die (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write kernel file data blob
+      Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write kernel file data
-      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 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 // 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 - imageheader_offset); // save file data blob offset in file structure
+      fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // save file data blob offset in file structure
-      // is the file we're storing a preprocessed ELF file ?
-      if (fsentries[fsentry_index].header.ino & IFS_INO_PROCESSED_ELF)
-      {
-         elf = (elf_header_t *) fsentries[fsentry_index].u.file.UNSAVED_databuf; // quick access to ELF header
-         table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
-         for (table_index = 0; table_index < table_count; table_index++)
-         {
-            phdr = (elf_program_header_t *) &fsentries[fsentry_index].u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+      Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write file data
-            corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);
-            if (ELF_GET_NUMERIC (elf, phdr, size_in_memory) != 0) // only patch the physical address of segments that have an actual size in memory
-               ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + curr_offset - corrective_offset); // patch the physical address member of the program header table
-         }
-      }
-      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
+   }
    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
+      fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // 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
+      Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write file data
       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
+   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
    // finally, write trailer (including empty checksum)
-   imagetrailer_offset = ftell (fp); // save image trailer offset
+   ifs.offsets.imagetrailer = ifs.data.size; // save image trailer offset for future use
-   fwrite_or_die (&image_trailer, 1, sizeof (image_trailer), fp); // write image trailer
+   ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &image_trailer, sizeof (image_trailer))); // write image trailer
-   PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
    // if we need to pad it to a specific length, do so
-   PAD_OUTFILE_TO (image_totalsize);
+   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, image_totalsize));
-   final_size = ftell (fp);
+   ifs.final_size = ifs.data.size; // and this is the final size of the IFS
    // see if we are past the image max size, in which case it's an error
-   if (final_size > image_maxsize)
+   if (ifs.final_size > image_maxsize)
-      DIE_WITH_EXITCODE (1, "image file \"%s\" size %zd exceeds max size (%zd)", ifs_pathname, final_size, (size_t) image_maxsize);
+      DIE_WITH_EXITCODE (1, "image file \"%s\" size %zd exceeds max size (%zd)", ifs_pathname, ifs.final_size, (size_t) image_maxsize);
    // do we have a startup file ? if so, this is a bootable image
    if (startupfile_pathname != NULL)
+   {
-      // rewrite startup header with final values
+      // patch the startup header with its final values
-      fseek_or_die (fp, startupheader_offset, SEEK_SET);
-      startup_header.startup_size = (uint32_t) (imageheader_offset - startupheader_offset); // size of startup header up to image header
+      startup_header.startup_size = (uint32_t) (ifs.offsets.imageheader - ifs.offsets.startupheader); // size of startup header up to image header
-      startup_header.imagefs_size = (uint32_t) (final_size - imageheader_offset); // size of uncompressed imagefs
+      startup_header.imagefs_size = (uint32_t) (ifs.final_size - ifs.offsets.imageheader); // size of uncompressed imagefs
-      startup_header.ram_size     = (uint32_t) (final_size - startupheader_offset);
+      startup_header.ram_size     = (uint32_t) (ifs.final_size - ifs.offsets.startupheader);
-      startup_header.stored_size  = (uint32_t) (final_size - startupheader_offset);
+      startup_header.stored_size  = (uint32_t) (ifs.final_size - ifs.offsets.startupheader);
-      fwrite_or_die (&startup_header, 1, sizeof (startup_header), fp); // write startup header
+      ASSERT_WITH_ERRNO (Buffer_WriteAt (&ifs.data, ifs.offsets.startupheader, &startup_header, sizeof (startup_header))); // write the final startup header at its right offset
+   }
    // 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.image_size = (uint32_t) (ifs.final_size - ifs.offsets.imageheader); // 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
+   ASSERT_WITH_ERRNO (Buffer_WriteAt (&ifs.data, ifs.offsets.imageheader, &image_header, sizeof (image_header))); // 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
+      qsort (&fsentries[1], fsentry_count - 1, sizeof (fsentry_t), fsentry_compare_pathnames_cb); // sort the filesystem entries by pathname if necessary
+   curr_offset = ifs.offsets.imagedir; // position ourselves at the beginning of the image directory
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+   {
+      Buffer_WriteIFSDirectoryEntryAt (&ifs.data, curr_offset, &fsentries[fsentry_index]); // rewrite each dirent
-      fwrite_fsentry (&fsentries[fsentry_index], fp);
+      curr_offset += fsentries[fsentry_index].header.size; // advance to the next one
+   }
-   fclose (fp); // ensure everything is flushed
    // ALL CHECKSUMS AT THE VERY END
-   read_filecontents (ifs_pathname, ".", &blob);
-   WELLMANNERED_ASSERT (blob.bytes != NULL, "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
           || (!(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
+      if (startup_header.flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2) // is it a V2 trailer ?
+      {
-      SHA512 (&blob.bytes[startupheader_offset], startuptrailer_offset - startupheader_offset, &blob.bytes[startuptrailer_offset]); // compute SHA512 checksum and write it in place in blob data
+         SHA512 (&ifs.data.bytes[ifs.offsets.startupheader], ifs.offsets.startuptrailer - ifs.offsets.startupheader, &ifs.data.bytes[ifs.offsets.startuptrailer]); // compute SHA512 checksum and write it in place
-      checksum = update_checksum (&blob.bytes[startupheader_offset], startuptrailer_offset + SHA512_DIGEST_LENGTH - startupheader_offset, is_foreign_endianness); // compute old checksum
+         checksum = update_checksum (&ifs.data.bytes[ifs.offsets.startupheader], ifs.offsets.startuptrailer + SHA512_DIGEST_LENGTH - ifs.offsets.startupheader, is_foreign_endianness); // compute old checksum
-      memcpy (&blob.bytes[startuptrailer_offset + SHA512_DIGEST_LENGTH], &checksum, 4); // and write it in place
+         memcpy (&ifs.data.bytes[ifs.offsets.startuptrailer + SHA512_DIGEST_LENGTH], &checksum, 4); // and write it in place
+      }
+      else // old V1 trailer
+      {
+         checksum = update_checksum (&ifs.data.bytes[ifs.offsets.startupheader], ifs.offsets.startuptrailer - ifs.offsets.startupheader, is_foreign_endianness); // compute old checksum
+         memcpy (&ifs.data.bytes[ifs.offsets.startuptrailer], &checksum, 4); // and write it in place
+      }
+   }
    // compute SHA-512 checksum and V1 checksum of image block
    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
-   SHA512 (&blob.bytes[imageheader_offset], imagetrailer_offset - imageheader_offset, &blob.bytes[imagetrailer_offset]); // compute SHA512 checksum and write it in place in blob data
-   checksum = update_checksum (&blob.bytes[imageheader_offset], imagetrailer_offset + SHA512_DIGEST_LENGTH - imageheader_offset, is_foreign_endianness); // compute old checksum
-   memcpy (&blob.bytes[imagetrailer_offset + SHA512_DIGEST_LENGTH], &checksum, 4); // and write it in place
+   if (image_header.flags & IMAGE_FLAGS_TRAILER_V2) // is it a V2 trailer ?
-   // 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.bytes, 1, blob.len, fp);
-   fclose (fp);
-   free (blob.bytes);
-   // finished, exit with a success code
-   LOG_INFO ("Success");
-   exit (0);
-}
-static int dump_ifs_info (const char *ifs_pathname, bool want_everything)
-{
-   #define hex_printf(buf,size,...) do { \
-      if (want_everything || ((size) <= 16 * 1024)) /* only print when it's not too big (up to 16 kb) */\
-         hex_fprintf (stdout, (buf), (size), 16, __VA_ARGS__); /* use 16 columns in hex output to stdout */ \
-      else { \
-         printf (__VA_ARGS__); \
-         hex_fprintf (stdout, (buf), 1024, 16, "   first kilobyte:\n"); \
-      } \
-   } while (0)
-   #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;
-   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;
-   fsentry_t **fsentries = NULL; // mallocated
-   size_t fsentry_count = 0;
-   fsentry_t *current_fsentry = NULL;
-   char recorded_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
-   char computed_sha512[2 * SHA512_DIGEST_LENGTH + 1] = "";
-   size_t startupfile_blobsize = 0;
-   void *reallocated_ptr;
-   bool is_foreign_endianness;
-   size_t bootfile_blobsize = 0;
-   size_t current_offset;
-   size_t fsentry_index;
-   size_t nearest_distance;
-   size_t nearest_index;
-   size_t byte_index;
-   uint32_t recorded_checksum;
-   uint32_t computed_checksum;
-   buffer_t file;
-   time_t mtime;
-   // open and read IFS file
-   if (read_filecontents (ifs_pathname, ".", &file) == NULL)
-      DIE_WITH_EXITCODE (1, "can't open \"%s\" for reading: %s", ifs_pathname, strerror (errno));
-   printf ("QNX In-kernel Filesystem analysis produced by ifstool version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
-   printf ("IFS file \"%s\" - size 0x%zx (%zd) bytes\n", ifs_pathname, file.len, file.len);
-   // parse file from start to end
-   current_offset = 0;
-   for (;;)
+   {
-      // does a startup header start here ?
-      if ((current_offset + sizeof (startup_header_t) < file.len) && (memcmp (&file.bytes[current_offset], "\xeb\x7e\xff\x00", 4) == 0))
-      {
-         startupheader_offset = current_offset;
-         startup_header = (startup_header_t *) &file.bytes[startupheader_offset];
-         // layout:
-         // [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 == ELF_MACHINE_X86_64 ? "x86_64" : (startup_header->machine == ELF_MACHINE_AARCH64 ? "aarch64" : "unknown")));
-         printf ("   startup_vaddr = 0x%08x (%d) - virtual address to transfer to after IPL is done\n", startup_header->startup_vaddr, startup_header->startup_vaddr);
-         printf ("   paddr_bias    = 0x%08x (%d) - value to add to physical addresses to get an indirectable pointer value\n", startup_header->paddr_bias, startup_header->paddr_bias);
-         printf ("   image_paddr   = 0x%08x (%d) - physical address of image\n", startup_header->image_paddr, startup_header->image_paddr);
-         printf ("   ram_paddr     = 0x%08x (%d) - physical address of RAM to copy image to (startup_size bytes copied)\n", startup_header->ram_paddr, startup_header->ram_paddr);
-         printf ("   ram_size      = 0x%08x (%d) - amount of RAM used by the startup program and executables in the fs\n", startup_header->ram_size, startup_header->ram_size);
-         printf ("   startup_size  = 0x%08x (%d) - size of startup (never compressed) - %s\n", startup_header->startup_size, startup_header->startup_size, (current_offset + sizeof (image_header_t) + startup_header->startup_size + (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? sizeof (image_trailer_v2_t) : sizeof (image_trailer_v1_t)) < file.len ? "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 > file.len)
-         {
-            LOG_WARNING ("this IFS file is corrupted (startup trailer extends past end of file)");
-            goto endofdata;
-         }
-         // check if this endianness is ours
-         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
-         // locate the right startup trailer at the right offset
-         if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
-         {
-            startuptrailer_offset = current_offset + startup_header->startup_size - sizeof (startup_trailer_v2_t);
-            startup_trailer_v2 = (startup_trailer_v2_t *) &file.bytes[startuptrailer_offset];
-            startupfile_blobsize = startup_header->startup_size - sizeof (startup_header_t) - sizeof (startup_trailer_v2_t);
-         }
-         else // old V1 trailer
-         {
-            startuptrailer_offset = current_offset + startup_header->startup_size - sizeof (startup_trailer_v1_t);
-            startup_trailer_v1 = (startup_trailer_v1_t *) &file.bytes[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 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_checksum (&file.bytes[current_offset], startupfile_blobsize, is_foreign_endianness));
-         current_offset += startupfile_blobsize; // jump over the startup blob and reach the startup trailer
-         printf ("\n");
-         printf ("Startup trailer at offset 0x%zx (%zd) - version %d:\n", current_offset, current_offset, (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? 2 : 1));
-         if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
-         {
-            for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
-               sprintf (&recorded_sha512[2 * byte_index], "%02x", startup_trailer_v2->sha512[byte_index]);
-            strcpy (computed_sha512, SHA512 (startup_header, startuptrailer_offset - startupheader_offset, NULL));
-            recorded_checksum = startup_trailer_v2->cksum;
-            computed_checksum = update_checksum (startup_header, startuptrailer_offset + SHA512_DIGEST_LENGTH - startupheader_offset, is_foreign_endianness);
-            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%zx-0x%zx[) = 0x%08x - %s\n", startupheader_offset, startuptrailer_offset + SHA512_DIGEST_LENGTH, 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\n", 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%zx-0x%zx[) = 0x%08x - %s\n", startupheader_offset, startuptrailer_offset, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
-            if (computed_checksum != recorded_checksum)
-               printf ("Computed cksum: 0x%08x\n", 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
-      }
-      // else does an image header start here ?
-      else if ((current_offset + sizeof (image_header_t) < file.len) && (memcmp (&file.bytes[current_offset], "imagefs", 7) == 0))
-      {
-         imageheader_offset = current_offset;
-         image_header = (image_header_t *) &file.bytes[imageheader_offset];
-         // layout:
-         // [IMAGE HEADER]
-         // [image directory entries]
-         // [smallest file blobs up to KERNEL]
-         // [padding]
-         // [KERNEL]
-         // [rest of file blobs]
-         // [IMAGE FOOTER]
-         printf ("\n");
-         printf ("Image header at offset %zx (%zd):\n", current_offset, current_offset);
-         printf ("   signature    = %02x %02x %02x %02x %02x %02x %02x (\"%.7s\") - good\n", image_header->signature[0], image_header->signature[1], image_header->signature[2], image_header->signature[3], image_header->signature[4], image_header->signature[5], image_header->signature[6], image_header->signature);
+      SHA512 (&ifs.data.bytes[ifs.offsets.imageheader], ifs.offsets.imagetrailer - ifs.offsets.imageheader, &ifs.data.bytes[ifs.offsets.imagetrailer]); // compute SHA512 checksum and write it in place
-         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 <= file.len ? "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 < file.len ? "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 >= file.len ? "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]));
+      checksum = update_checksum (&ifs.data.bytes[ifs.offsets.imageheader], ifs.offsets.imagetrailer + SHA512_DIGEST_LENGTH - ifs.offsets.imageheader, is_foreign_endianness); // compute old checksum
-         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 > file.len)
-         {
-            LOG_WARNING ("this IFS file is corrupted (image trailer extends past end of file)");
-            goto endofdata;
-         }
-         // check if this endianness is ours
-         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
-         // locate the image trailer at the right offset
-         if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)
-         {
-            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v2_t);
-            image_trailer_v2 = (image_trailer_v2_t *) &file.bytes[imagetrailer_offset];
-         }
-         else // old V1 trailer
-         {
-            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v1_t);
-            image_trailer_v1 = (image_trailer_v1_t *) &file.bytes[imagetrailer_offset];
-         }
-         current_offset += sizeof (image_header_t); // jump over the image header and reach the first directory entry
-         // there may be padding before the first directory entry
-         if (image_header->dir_offset - sizeof (image_header_t) > 0)
-            hex_printf (&file.bytes[current_offset], image_header->dir_offset - sizeof (image_header_t), "\n" "%zd padding bytes at offset 0x%zd (%zd):\n", image_header->dir_offset - sizeof (image_header_t), current_offset, current_offset);
-         current_offset += image_header->dir_offset - sizeof (image_header_t); // padding was processed, jump over it
-         // dump all directory entries until the last one included
-         fsentries = NULL;
-         fsentry_count = 0;
-         while (current_offset < imageheader_offset + image_header->hdr_dir_size)
-         {
-            current_fsentry = (fsentry_t *) &file.bytes[current_offset];
-            if (imageheader_offset + image_header->hdr_dir_size - current_offset < sizeof (current_fsentry->header))
-               break; // end padding reached
-            // stack up the filesystem entry pointers in an array while we read them
-            reallocated_ptr = realloc (fsentries, (fsentry_count + 1) * sizeof (fsentry_t *));
-            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-            fsentries = reallocated_ptr;
-            fsentries[fsentry_count] = current_fsentry;
-            fsentry_count++;
-            printf ("\n");
-            printf ("Filesystem entry at offset 0x%zx (%zd) - last one at 0x%zd (%zd):\n", current_offset, current_offset, imageheader_offset + image_header->hdr_dir_size, imageheader_offset + image_header->hdr_dir_size);
-            printf ("   size           = 0x%04x (%d) - size of dirent - %s\n", current_fsentry->header.size, current_fsentry->header.size, ((current_fsentry->header.size > 0) && (current_offset + current_fsentry->header.size < file.len) ? "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 < file.len ? "looks good" : "BAD (IFS file too short)"));
-               printf ("   [FILE] size   = 0x%08x (%d) - %s\n", current_fsentry->u.file.size, current_fsentry->u.file.size, (imageheader_offset + current_fsentry->u.file.offset + current_fsentry->u.file.size < file.len ? "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_size, current_fsentry->u.symlink.sym_size, (sizeof (current_fsentry->header) + 2 * sizeof (uint16_t) + current_fsentry->u.symlink.sym_offset + current_fsentry->u.symlink.sym_size <= current_fsentry->header.size ? "looks good" : "BAD (dirent too short)"));
-               printf ("   [SYMLINK] path       = \"%s\"\n", (char *) &current_fsentry->u.symlink.path); // convert from pointer to char array
-               printf ("   [SYMLINK] contents   = \"%s\"\n", ((char *) &current_fsentry->u.symlink.path) + current_fsentry->u.symlink.sym_offset); // convert from pointer to char array
-            }
-            else // can only be a device
-            {
-               printf ("   [DEVICE] 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
-            }
-            if ((current_fsentry->header.size == 0) || (current_offset + current_fsentry->header.size >= file.len))
-            {
-               LOG_WARNING ("this IFS file is corrupted (the size of this directory entry is invalid)");
-               goto endofdata;
-            }
-            current_offset += current_fsentry->header.size;
-         }
-         if (imageheader_offset + image_header->hdr_dir_size < current_offset + sizeof (current_fsentry->header))
-            hex_printf (&file.bytes[current_offset], imageheader_offset + image_header->hdr_dir_size - current_offset, "\n" "%zd padding bytes at offset 0x%zx (%zd):\n", imageheader_offset + image_header->hdr_dir_size - current_offset, current_offset, current_offset);
+      memcpy (&ifs.data.bytes[ifs.offsets.imagetrailer + SHA512_DIGEST_LENGTH], &checksum, 4); // and write it in place
-         current_offset += imageheader_offset + image_header->hdr_dir_size - current_offset; // padding was processed, jump over it
-         // at this point we are past the directory entries; what is stored now, up to and until the image trailer, is the files' data
-         if (fsentry_count > 0)
-         {
-            while (current_offset < imagetrailer_offset) // and parse data up to the trailer
-            {
-               nearest_distance = SIZE_MAX;
-               nearest_index = SIZE_MAX;
-               for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-                  if (S_ISREG (fsentries[fsentry_index]->header.mode) // if this directory entry a file (i.e. it has a data blob)...
-                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset >= current_offset) // ... AND its data blob is still ahead of our current pointer ...
-                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset < nearest_distance)) // ... AND it's the closest to us we've found so far
-                  {
-                     nearest_distance = imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset; // then remember it
-                     nearest_index = fsentry_index;
-                  }
-               if (nearest_index == SIZE_MAX)
-                  break; // found no file ahead, which means we've parsed the whole file data area, so stop the loop so as to proceed to the image trailer
-               fsentry_index = nearest_index;
-               current_fsentry = fsentries[fsentry_index]; // quick access to closest fsentry
-               // there may be padding before the file data
-               if (imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset > 0)
-                  hex_printf (&file.bytes[current_offset], imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset, "\n" "%zd padding bytes at offset 0x%zx (%zd):\n", imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset, current_offset, current_offset);
-               current_offset += imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset; // padding was processed, jump over it
-               printf ("\n");
-               printf ("File data blob at offset 0x%zx (%zd):\n", current_offset, current_offset);
-               printf ("   corresponding dirent index: %zd/%zd\n", fsentry_index, fsentry_count);
-               printf ("   corresponding inode 0x%08x (%d) -%s%s%s%s\n", current_fsentry->header.ino, current_fsentry->header.ino, (current_fsentry->header.ino & 0xE0000000 ? "" : " 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 < file.len)
-                  hex_printf (&file.bytes[current_offset], current_fsentry->u.file.size, "   data:\n");
-               if (current_offset + current_fsentry->u.file.size < file.len)
-                  printf ("   checksum %d\n", update_checksum (&file.bytes[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
-               else
-               {
-                  LOG_WARNING ("this IFS file is corrupted (the size of this file data extends past the IFS size)");
-                  goto endofdata;
-               }
-               current_offset += current_fsentry->u.file.size; // now jump over this file's data
-            }
-         }
-         // ad this point we're past the last file data, there may be padding before the image trailer
-         if (imagetrailer_offset - current_offset > 0)
-            hex_printf (&file.bytes[current_offset], imagetrailer_offset - current_offset, "\n" "%zd padding bytes at offset %zx (%zd):\n", imagetrailer_offset - current_offset, current_offset, current_offset);
-         current_offset += imagetrailer_offset - current_offset; // padding was processed, jump over it
-         printf ("\n");
-         printf ("Image trailer at offset 0x%zx (%zd) - version %d:\n", current_offset, current_offset, (image_header->flags & IMAGE_FLAGS_TRAILER_V2 ? 2 : 1));
-         if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)
-         {
-            for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
-               sprintf (&recorded_sha512[2 * byte_index], "%02x", image_trailer_v2->sha512[byte_index]);
-            strcpy (computed_sha512, SHA512 (image_header, imagetrailer_offset - imageheader_offset, NULL));
-            recorded_checksum = image_trailer_v2->cksum;
-            computed_checksum = update_checksum (image_header, imagetrailer_offset + SHA512_DIGEST_LENGTH - imageheader_offset, is_foreign_endianness);
-            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%zx-0x%zx[) = 0x%08x - %s\n", imageheader_offset, imagetrailer_offset + SHA512_DIGEST_LENGTH, 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\n", 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%zx-0x%zx[) = 0x%08x - %s\n", imageheader_offset, imagetrailer_offset, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
-            if (computed_checksum != recorded_checksum)
-               printf ("Computed cksum: 0x%08x\n", 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)
-      }
-      // 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 < file.len - 6; byte_index++)
-            if (memcmp (&file.bytes[byte_index], "\xeb\x7e\xff\x00" "\x01\x00", 4 + 2) == 0)
-               break; // stop as soon as we find it
-         if (byte_index >= file.len - 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 0x%08x\n", update_checksum (&file.bytes[current_offset], bootfile_blobsize, false)); // NOTE: endianness is not known yet -- assume same
-         current_offset = byte_index; // now reach the next segment
-      }
+   }
-endofdata:
-   // at this point there's nothing left we're able to parse
-   if (current_offset < file.len)
+   else // old V1 trailer
+   {
-      printf ("End of identifiable data reached.\n");
+      checksum = update_checksum (&ifs.data.bytes[ifs.offsets.imageheader], ifs.offsets.imagetrailer - ifs.offsets.imageheader, is_foreign_endianness); // compute old checksum
-      hex_printf (&file.bytes[current_offset], file.len - current_offset, "\n" "%zd extra bytes at offset %zx (%zd):\n", file.len - current_offset, current_offset, current_offset);
+      memcpy (&ifs.data.bytes[ifs.offsets.imagetrailer], &checksum, 4); // and write it in place
+   }
-   printf ("End of file reached at offset 0x%zx (%zd)\n", file.len, file.len);
+   // now rewrite IFS with the correct checksums
-   printf ("IFS dissecation complete.\n");
+   ASSERT_WITH_ERRNO (Buffer_WriteToFile (&ifs.data, ifs_pathname));
-   return (0);
-}
-static int create_intermediate_dirs (const char *file_pathname)
-{
-   // creates all intermediate directories from root (or cwd) up to file_path
-   char *temp_pathname;
-   char *separator;
-   size_t string_index;
-   size_t length;
+   // finished, cleanup
-   temp_pathname = strdup (file_pathname); // have a working copy of file_pathname
-   if (temp_pathname == NULL)
-      return (-1); // on strdup() failure, return an error value (errno is set)
-   length = strlen (temp_pathname);
-   for (string_index = length - 1; string_index != SIZE_MAX; string_index--) // i.e. loop until it overflows
+   for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-      if ((temp_pathname[string_index] == '/') || (temp_pathname[string_index] == '\\'))
-         break; // look for the last directory separator and stop as soon as we find it
-   if (string_index != SIZE_MAX)
+   {
-      for (; string_index < length; string_index++)
-         temp_pathname[string_index] = 0; // if we found one, break there so as to have just the path and clear the rest of the string
-      separator = strtok (&temp_pathname[1], "/\\"); // for each separator in the remaining string past the first one...
-      while (separator != NULL)
-      {
-         (void) mkdir (temp_pathname, 0755); // create directories recursively
-         temp_pathname[strlen (temp_pathname)] = '/'; // put the separator back
-         separator = strtok (NULL, "/\\"); // and look for the next one
-      }
+   }
-   free (temp_pathname); // release our working copy of file_pathname
-   return (0);
-}
-static int dump_ifs_contents (const char *ifs_pathname, const char *outdir)
-{
-   static char outfile_pathname[MAXPATHLEN] = "";
-   startup_header_t *startup_header = NULL;
-   size_t startupheader_offset = 0;
-   image_header_t *image_header = NULL;
-   size_t imageheader_offset = 0;
-   size_t imagetrailer_offset = 0;
-   fsentry_t **fsentries = NULL; // mallocated
-   size_t fsentry_count = 0;
-   fsentry_t *current_fsentry = NULL;
-   size_t startupfile_blobsize = 0;
-   struct utimbuf file_times = { 0, 0 };
-   void *reallocated_ptr;
-   size_t bootfile_blobsize = 0;
-   size_t current_offset;
-   size_t fsentry_index;
-   size_t nearest_distance;
-   size_t nearest_index;
-   size_t byte_index;
-   buffer_t file;
-   FILE *fp;
-   // open and read IFS file
-   if (read_filecontents (ifs_pathname, ".", &file) == NULL)
-      DIE_WITH_EXITCODE (1, "can't open \"%s\" for reading: %s\n", ifs_pathname, strerror (errno));
-   // create the output directory
+   // and exit with a success code
-   create_intermediate_dirs (outdir);
-   (void) mkdir (outdir, 0755);
-   // parse file from start to end
-   current_offset = 0;
-   for (;;)
-   {
-      // does a startup header start here ?
-      if ((current_offset + sizeof (startup_header_t) < file.len) && (memcmp (&file.bytes[current_offset], "\xeb\x7e\xff\x00", 4) == 0))
-      {
-         startupheader_offset = current_offset;
-         startup_header = (startup_header_t *) &file.bytes[startupheader_offset];
-         // layout:
-         // [STARTUP HEADER]
-         // (startup file blob)
-         // [STARTUP TRAILER v1 or v2]
-         // validate that the file can contain up to the startup trailer
-         if (current_offset + startup_header->startup_size > file.len)
-         {
-            LOG_WARNING ("this IFS file is corrupted (startup trailer extends past end of file)");
-            goto endofdata;
-         }
-         // locate the right startup trailer at the right offset
-         if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)
-            startupfile_blobsize = startup_header->startup_size - sizeof (startup_header_t) - sizeof (startup_trailer_v2_t);
-         else // old V1 trailer
-            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
-         // write startup blob
-         sprintf (outfile_pathname, "%s/STARTUP.BLOB", outdir);
-         fp = fopen (outfile_pathname, "wb");
-         WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));
-         fwrite (&file.bytes[current_offset], 1, startupfile_blobsize, fp);
-         fclose (fp);
+   LOG_INFO ("Success");
-         current_offset += startupfile_blobsize; // jump over the startup blob and reach the startup trailer
-         current_offset += (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? sizeof (startup_trailer_v2_t) : sizeof (startup_trailer_v1_t)); // jump over the startup trailer and reach the next segment
-      }
-      // else does an image header start here ?
-      else if ((current_offset + sizeof (image_header_t) < file.len) && (memcmp (&file.bytes[current_offset], "imagefs", 7) == 0))
-      {
-         imageheader_offset = current_offset;
-         image_header = (image_header_t *) &file.bytes[imageheader_offset];
-         // layout:
-         // [IMAGE HEADER]
-         // [image directory entries]
-         // [smallest file blobs up to KERNEL]
-         // [padding]
-         // [KERNEL]
-         // [rest of file blobs]
-         // [IMAGE FOOTER]
-         // validate that the file can contain up to the image trailer
-         if (current_offset + image_header->image_size > file.len)
-         {
-            LOG_WARNING ("this IFS file is corrupted (image trailer extends past end of file)");
-            goto endofdata;
-         }
-         // locate the image trailer at the right offset
-         if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)
-            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v2_t);
-         else // old V1 trailer
-            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v1_t);
-         current_offset += sizeof (image_header_t); // jump over the image header
-         current_offset += image_header->dir_offset - sizeof (image_header_t); // jump over possible padding
-         // dump all directory entries until the last one included
-         fsentries = NULL;
-         fsentry_count = 0;
-         while (current_offset < imageheader_offset + image_header->hdr_dir_size)
-         {
-            current_fsentry = (fsentry_t *) &file.bytes[current_offset];
-            if (imageheader_offset + image_header->hdr_dir_size - current_offset < sizeof (current_fsentry->header))
-               break; // end padding reached
-            // stack up the filesystem entry pointers in an array while we read them
-            reallocated_ptr = realloc (fsentries, (fsentry_count + 1) * sizeof (fsentry_t *));
-            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
-            fsentries = reallocated_ptr;
-            fsentries[fsentry_count] = current_fsentry;
-            fsentry_count++;
-            if ((current_fsentry->header.size == 0) || (current_offset + current_fsentry->header.size >= file.len))
-            {
-               LOG_WARNING ("this IFS file is corrupted (the size of this directory entry is invalid)");
-               goto endofdata;
-            }
-            current_offset += current_fsentry->header.size;
-         }
-         current_offset += imageheader_offset + image_header->hdr_dir_size - current_offset; // jump over possible padding
-         // at this point we are past the directory entries; what is stored now, up to and until the image trailer, is the files' data
-         if (fsentry_count > 0)
-         {
-            while (current_offset < imagetrailer_offset) // and parse data up to the trailer
-            {
-               nearest_distance = SIZE_MAX;
-               nearest_index = SIZE_MAX;
-               for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-                  if (S_ISREG (fsentries[fsentry_index]->header.mode) // if this directory entry a file (i.e. it has a data blob)...
-                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset >= current_offset) // ... AND its data blob is still ahead of our current pointer ...
-                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset < nearest_distance)) // ... AND it's the closest to us we've found so far
-                  {
-                     nearest_distance = imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset; // then remember it
-                     nearest_index = fsentry_index;
-                  }
-               if (nearest_index == SIZE_MAX)
-                  break; // found no file ahead, which means we've parsed the whole file data area, so stop the loop so as to proceed to the image trailer
-               fsentry_index = nearest_index;
-               current_fsentry = fsentries[fsentry_index]; // quick access to closest fsentry
-               current_offset += imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset; // jump over possible padding
-               if (current_offset + current_fsentry->u.file.size >= file.len)
-               {
-                  LOG_WARNING ("this IFS file is corrupted (the size of this file data extends past the IFS size)");
-                  goto endofdata;
-               }
-               // write filesystem data entry
-               if (S_ISDIR (current_fsentry->header.mode))
-               {
-                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.dir.path); // convert from pointer to char array
-                  create_intermediate_dirs (outfile_pathname);
-                  (void) mkdir (outfile_pathname, current_fsentry->header.mode & 0777);
-               }
-               else if (S_ISLNK (current_fsentry->header.mode))
-               {
-                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.symlink.path); // convert from pointer to char array
-                  create_intermediate_dirs (outfile_pathname);
-#ifdef _WIN32
-                  fp = fopen (outfile_pathname, "wb"); // on Windows create symlinks as plain files
-                  WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));
-                  fwrite ((char *) &current_fsentry->u.symlink.path + current_fsentry->u.symlink.sym_offset, 1, current_fsentry->u.symlink.sym_size, fp); // convert from pointer to char array
-                  fclose (fp);
-#else // !_WIN32, thus POSIX
-                  symlink (current_fsentry->u.symlink.contents, outfile_pathname); // on UNIX systems, just create the symlink for real
-#endif // _WIN32
-               }
-               else if (S_ISREG (current_fsentry->header.mode))
-               {
-                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.file.path); // convert from pointer to char array
-                  create_intermediate_dirs (outfile_pathname);
-                  fp = fopen (outfile_pathname, "wb"); // on Windows create symlinks as plain files
-                  WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));
-                  fwrite (&file.bytes[current_offset], 1, current_fsentry->u.file.size, fp);
-                  fclose (fp);
-               }
-               else // must be a device node. Since we might not be the super-user and/or on Win32, create plain file with "X:Y" as data
-               {
-                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.device.path); // convert from pointer to char array
-                  create_intermediate_dirs (outfile_pathname);
-                  fp = fopen (outfile_pathname, "wb"); // on Windows create symlinks as plain files
-                  WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));
-                  fprintf (fp, "%u:%u", current_fsentry->u.device.dev, current_fsentry->u.device.rdev);
-                  fclose (fp);
-               }
-               // set created file mtime
-               file_times.actime = current_fsentry->header.mtime;
-               file_times.modtime = current_fsentry->header.mtime;
-               utime (outfile_pathname, &file_times);
-               // set created file mode
-#ifndef _WIN32
-               (void) chmod (outfile_pathname, current_fsentry->header.mode & 0777); // only on POSIX systems
-#endif // !_WIN32
-               current_offset += current_fsentry->u.file.size; // now jump over this file's data
-            }
-         }
-         // ad this point we're past the last file data, there may be padding before the image trailer
-         current_offset += imagetrailer_offset - current_offset; // jump over possible padding and reach the image trailer
-         current_offset += (image_header->flags & IMAGE_FLAGS_TRAILER_V2 ? sizeof (image_trailer_v2_t) : sizeof (image_trailer_v1_t)); // now jump over the image trailer and reach the next segment (typically end of file)
-      }
-      // else it has to be a boot blob, of which we don't know the size, except that it has to fit in 0xffff bytes and be immediately followed by a startup header
-      else
-      {
-         // 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 < file.len - 6; byte_index++)
-            if (memcmp (&file.bytes[byte_index], "\xeb\x7e\xff\x00" "\x01\x00", 4 + 2) == 0)
-               break; // stop as soon as we find it
-         if (byte_index >= file.len - 6)
-            break; // if not found, stop scanning
-         bootfile_blobsize = byte_index - current_offset;
-         // write boot blob
-         sprintf (outfile_pathname, "%s/BOOT.BLOB", outdir);
-         fp = fopen (outfile_pathname, "wb");
-         WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));
-         fwrite (&file.bytes[current_offset], 1, bootfile_blobsize, fp);
-         fclose (fp);
-         current_offset = byte_index; // now reach the next segment
-      }
-   }
-endofdata:
-   return (0);
+   exit (0);
+}

Subversion Repositories QNX 8.QNX8 IFS tool

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