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

 #include <time.h>
 #ifdef _MSC_VER
 #include <io.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 access(p,m) _access ((p), (m))
 #define MAXPATHLEN 1024
 #else // !_MSC_VER
 #include <sys/param.h>
 #include <unistd.h>
-#endif // _MSC_VER
-#ifdef _MSC_VER
-#pragma pack(push)
-#pragma pack(1)
 #endif // _MSC_VER
 // handy macros that generate a version number in the format "YYYYMMDD" corresponding to the build date. Usage: printf ("version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
+#ifndef VERSION_ARG_YYYYMMDD
 #define BUILDDATE_YEAR  (&__DATE__[7]) // compiler will optimize this into a const string, e.g. "2021"
-#define BUILDDATE_MONTH (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Jan ")) ? "01" : \
+#define BUILDDATE_MONTH (*((uint32_t *) __DATE__) == *((uint32_t *) "Jan ") ? "01" : \
-                         (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Feb ")) ? "02" : \
+                         (*((uint32_t *) __DATE__) == *((uint32_t *) "Feb ") ? "02" : \
-                          (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Mar ")) ? "03" : \
+                          (*((uint32_t *) __DATE__) == *((uint32_t *) "Mar ") ? "03" : \
-                           (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Apr ")) ? "04" : \
+                           (*((uint32_t *) __DATE__) == *((uint32_t *) "Apr ") ? "04" : \
-                            (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "May ")) ? "05" : \
+                            (*((uint32_t *) __DATE__) == *((uint32_t *) "May ") ? "05" : \
-                             (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Jun ")) ? "06" : \
+                             (*((uint32_t *) __DATE__) == *((uint32_t *) "Jun ") ? "06" : \
-                              (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Jul ")) ? "07" : \
+                              (*((uint32_t *) __DATE__) == *((uint32_t *) "Jul ") ? "07" : \
-                               (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Aug ")) ? "08" : \
+                               (*((uint32_t *) __DATE__) == *((uint32_t *) "Aug ") ? "08" : \
-                                (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Sep ")) ? "09" : \
+                                (*((uint32_t *) __DATE__) == *((uint32_t *) "Sep ") ? "09" : \
-                                 (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Oct ")) ? "10" : \
+                                 (*((uint32_t *) __DATE__) == *((uint32_t *) "Oct ") ? "10" : \
-                                  (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Nov ")) ? "11" : \
+                                  (*((uint32_t *) __DATE__) == *((uint32_t *) "Nov ") ? "11" : \
-                                   (*((uint32_t *) ((void *) __DATE__)) == *((uint32_t *) ((void *) "Dec ")) ? "12" : "XX")))))))))))) // compiler will optimize this into a const string, e.g. "11"
+                                   (*((uint32_t *) __DATE__) == *((uint32_t *) "Dec ") ? "12" : "XX")))))))))))) // compiler will optimize this into a const string, e.g. "11"
-#define BUILDDATE_DAY   (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 1")) ? "01" : \
+#define BUILDDATE_DAY   (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  1 ") ? "01" : \
-                         (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 2")) ? "02" : \
+                         (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  2 ") ? "02" : \
-                          (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 3")) ? "03" : \
+                          (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  3 ") ? "03" : \
-                           (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 4")) ? "04" : \
+                           (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  4 ") ? "04" : \
-                            (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 5")) ? "05" : \
+                            (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  5 ") ? "05" : \
-                             (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 6")) ? "06" : \
+                             (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  6 ") ? "06" : \
-                              (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 7")) ? "07" : \
+                              (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  7 ") ? "07" : \
-                               (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 8")) ? "08" : \
+                               (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  8 ") ? "08" : \
-                                (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) " 9")) ? "09" : \
+                                (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  9 ") ? "09" : \
-                                 (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "10")) ? "10" : \
+                                 (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 10 ") ? "10" : \
-                                  (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "11")) ? "11" : \
+                                  (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 11 ") ? "11" : \
-                                   (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "12")) ? "12" : \
+                                   (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 12 ") ? "12" : \
-                                    (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "13")) ? "13" : \
+                                    (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 13 ") ? "13" : \
-                                     (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "14")) ? "14" : \
+                                     (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 14 ") ? "14" : \
-                                      (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "15")) ? "15" : \
+                                      (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 15 ") ? "15" : \
-                                       (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "16")) ? "16" : \
+                                       (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 16 ") ? "16" : \
-                                        (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "17")) ? "17" : \
+                                        (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 17 ") ? "17" : \
-                                         (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "18")) ? "18" : \
+                                         (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 18 ") ? "18" : \
-                                          (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "19")) ? "19" : \
+                                          (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 19 ") ? "19" : \
-                                           (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "20")) ? "20" : \
+                                           (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 20 ") ? "20" : \
-                                            (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "21")) ? "21" : \
+                                            (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 21 ") ? "21" : \
-                                             (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "22")) ? "22" : \
+                                             (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 22 ") ? "22" : \
-                                              (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "23")) ? "23" : \
+                                              (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 23 ") ? "23" : \
-                                               (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "24")) ? "24" : \
+                                               (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 24 ") ? "24" : \
-                                                (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "25")) ? "25" : \
+                                                (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 25 ") ? "25" : \
-                                                 (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "26")) ? "26" : \
+                                                 (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 26 ") ? "26" : \
-                                                  (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "27")) ? "27" : \
+                                                  (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 27 ") ? "27" : \
-                                                   (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "28")) ? "28" : \
+                                                   (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 28 ") ? "28" : \
-                                                    (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "29")) ? "29" : \
+                                                    (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 29 ") ? "29" : \
-                                                     (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "30")) ? "30" : \
+                                                     (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 30 ") ? "30" : \
-                                                      (*((uint16_t *) ((void *) &__DATE__[4])) == *((uint16_t *) ((void *) "31")) ? "31" : "XX"))))))))))))))))))))))))))))))) // compiler will optimize this into a const string, e.g. "14"
+                                                      (*((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 31 ") ? "31" : "XX"))))))))))))))))))))))))))))))) // compiler will optimize this into a const string, e.g. "14"
 #define VERSION_FMT_YYYYMMDD "%04s%02s%02s"
 #define VERSION_ARG_YYYYMMDD BUILDDATE_YEAR, BUILDDATE_MONTH, BUILDDATE_DAY
+#endif // !VERSION_ARG_YYYYMMDD
 #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) == '\\'))
 #define PATH_SEP ';'
+#define PATH_SEP_STR ";"
 #else // !_WIN32, thus POSIX
 #define IS_DIRSEP(c) ((c) == '/')
 #define PATH_SEP ':'
+#define PATH_SEP_STR ":"
 #endif // _WIN32
 #define RECORD_SEP '\x1e' // ASCII record separator
 #define RECORD_SEP_STR "\x1e" // ASCII record separator (as string)
+#define ELF_MAGIC_STR "\x7f" "ELF"
+#define ELF_ENDIAN_LITTLE 1 // ELF file is little endian
+#define ELF_ENDIAN_BIG    2 // ELF file is big endian
+#define ELF_DT_NULL    0 // marks end of dynamic section
+#define ELF_DT_SONAME 14 // canonical name of shared object
+#define ELF_HDR_MEMBER(hdr,member) ((hdr)->u.elf.platform_size == 2 ? (hdr)->u.elf64.member : (hdr)->u.elf32.member) // this macro supports 32- and 64-bit ELF files transparently (FIXME: support foreign endianness as well)
+#define ELF_STRUCT_MEMBER(hdr,structure,member) ((hdr)->u.elf.platform_size == 2 ? (structure)->u.elf64.member : (structure)->u.elf32.member) // this macro supports 32- and 64-bit ELF files transparently (FIXME: support foreign endianness as well)
+#define ELF_STRUCT_SIZE(hdr,structure) ((hdr)->u.elf.platform_size == 2 ? sizeof ((structure)->u.elf64) : sizeof ((structure)->u.elf32)) // this macro supports 32- and 64-bit ELF files transparently (FIXME: support foreign endianness as well)
 #define WILL_BE_FILLED_LATER 0xbaadf00d
 // bitmapped flags used in the flags1 member of the startup header
+{
    uint64_t state[8];
    uint64_t bitcount[2];
    uint8_t buffer[SHA512_BLOCK_LENGTH];
 } SHA512_CTX;
+#ifdef _MSC_VER
+#pragma pack(push)
+#pragma pack(1)
+#endif // _MSC_VER
 #if 0 // TODO: startup script compiler. Someday.
 #define SCRIPT_FLAGS_EXTSCHED   0x01
 #define SCRIPT_FLAGS_SESSION    0x02
 #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\0" "/usr/lib/ldqnx-64.so.2\0" \
+   "\x34\x00" /*size*/ "\x04" /*type*/ "\x00" /*spare*/ "/proc/boot/ldqnx-64.so.2\0" "/usr/lib/ldqnx-64.so.2\0" \
    /* sh /proc/boot/startup.sh */ \
    "\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 */ \
 typedef struct __attribute__((packed)) image_trailer_v2_s
+{
    uint8_t sha512[64]; // SHA512 from start of image header to start of trailer
    uint32_t cksum; // checksum from start of header to start of this member
 } image_trailer_v2_t; // NOTE: this is the same structure as startup_trailer_v2_t
+// Executable and Linkable Format master header structure type definition
+typedef struct __attribute__((packed)) elf_header_s
+{
+   union __attribute__((packed))
+   {
+      struct __attribute__((packed))
+      {
+         uint8_t magic[4];                     // offset 0: "\x07" + "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;
+      struct __attribute__((packed))
+      {
+         uint8_t magic[4];                     // offset 0: "\x07" + "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;
+      struct __attribute__((packed))
+      {
+         uint8_t magic[4];                     // offset 0: "\x07" + "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;
+   } u;
+} elf_header_t;
+// Executable and Linkable Format section header structure type definition
+typedef struct __attribute__((packed)) elf_section_header_s
+{
+   union __attribute__((packed))
+   {
+      struct __attribute__((packed))
+      {
+         uint32_t name_offset;  // offset 0: offset in the string table of the name of this section
+         uint32_t type;         // offset 4:
+         uint32_t flags;        // offset 8:
+         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;
+      struct __attribute__((packed))
+      {
+         uint32_t name_offset;  // offset 0: offset in the string table of the name of this section
+         uint32_t type;         // offset 4:
+         uint64_t flags;        // offset 8:
+         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;
+   } u;
+} elf_section_header_t;
+// Executable and Linkable Format dynamic section entry structure type definition
+typedef struct __attribute__((packed)) elf_dynamic_section_entry_s
+{
+   union __attribute__((packed))
+   {
+      struct __attribute__((packet))
+      {
+         int32_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)
+         union
+         {
+            uint32_t as_integer; // value as integer
+            uint32_t as_pointer; // value as address
+         } value;
+      } elf32;
+      struct __attribute__((packed))
+      {
+         int64_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)
+         union
+         {
+            uint64_t as_integer; // value as intege
+            uint64_t as_pointer; // value as address
+         } value;
+      } elf64;
+   } u;
+} elf_dynamic_section_entry_t;
 #ifdef _MSC_VER
 #pragma pack(pop)
 #endif // _MSC_VER
    int dperms; // directory permissions (e.g. 0755)
    int perms; // file permissions (e.g. 0644)
    int uid; // owner user ID (e.g. 0 = root)
    int gid; // owner group ID (e.g. 0 = root)
    int st_mode; // entry type (e.g. S_IFREG for files) and permissions
+   uint32_t mtime; // entry's modification time POSIX timestamp - set to UINT32_MAX to use the concerned files' mtime on the build host
+   uint32_t mtime_for_inline_files; // same as above but only for files that don't exist on the build host (i.e. files with an explicit content blob)
    char prefix[MAXPATHLEN]; // install path (e.g. "proc/boot")
+   bool should_follow_symlinks; // follow symlinks
+   bool should_autosymlink_dylib; // dynamic libraries should be written under their official SONAME and a named symlink be created pointing at them
    bool is_compiled_bootscript; // entry has [+script] attribute
    char search[10 * MAXPATHLEN]; // binary search path (the default one will be constructed at startup)
-   uint8_t *precompiled_data;
+   uint8_t *data;
-   size_t precompiled_datalen;
+   size_t datalen;
 } parms_t;
 // global variables
 static char line_buffer[4096]; // scrap buffer for the IFS build file parser
 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
 static uint32_t image_align = 4; // default image alignment, as per QNX docs
 static uint32_t image_kernel_ino = 0;
 static uint32_t image_bootscript_ino = 0;
+#if defined(__x86_64__)
 static char image_processor[16] = "x86_64"; // 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)
+#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 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.
 // 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 int32_t start_value, 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 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, uint8_t **databuf, size_t *datalen); // 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 int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp
 static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp); // writes the given filesystem entry into fp (without its contents)
-static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, const char *stored_pathname, parms_t *entry_parms, const uint8_t *data, const size_t entry_datalen); // stack up a new filesystem entry
+static 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 int fsentry_compare_sizes_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by size
+static void update_MKIFS_PATH (const char *processor);
 static int dump_ifs_info (const char *ifs_pathname); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
 static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data)
+{
       sprintf (&digest_as_string[2 * byte_index], "%02x", digest_or_NULL[byte_index]);
    return (digest_as_string);
+}
-static int32_t update_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness)
+static 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 };
-   int32_t image_cksum = start_value;
+   const char *current_char_ptr;
-   const char *current_char_ptr = data;
+   int32_t image_cksum;
    size_t i;
+   image_cksum = 0;
+   current_char_ptr = data;
    for (i = 0; i < data_len; i++)
+   {
       accumulator[i % 4] = *current_char_ptr;
       if (i % 4 == 3)
          if (is_foreign_endianness)
          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, uint8_t **databuf, size_t *datalen)
+{
+   // locates pathname among MKIFS_PATH, and places its contents in a buffer (caller frees). Returns resolved pathname (static buffer) or NULL.
+   /*thread_local*/ static char final_pathname[MAXPATHLEN];
+   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 (final_pathname, pathname); // in this case, it MUST exist at its designated location (either absolute or relative to the current working directory)
+   else // the path is relative, search it among the search paths we have
+   {
+      // construct a potential final path using each element of the search path
+      token = search_path;
+      nextsep = &token[strcspn (token, PATH_SEP_STR)];
+      while (token != NULL)
+      {
+         sprintf (final_pathname, "%.*s/%s", (int) (nextsep - token), token, pathname);
+         if (access (final_pathname, 0) == 0)
+            break; // if a file can indeed be found at this location, stop searching
+         token = (*nextsep != 0 ? nextsep + 1 : NULL);
+         nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP_STR)] : 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
+   fp = fopen (final_pathname, "rb");
+   if (fp == NULL)
+      return (NULL); // unexistent file (errno is set to ENOENT)
+   fseek (fp, 0, SEEK_END);
+   *datalen = ftell (fp); // measure file length
+   fseek (fp, 0, SEEK_SET);
+   *databuf = malloc (*datalen);
+   if (*databuf == NULL)
+   {
+      fclose (fp);
+      *datalen = 0;
+      return (NULL); // out of memory (errno is set to ENOMEM)
+   }
+   if (fread (*databuf, 1, *datalen, fp) != *datalen) // read the file in whole
+   {
+      fclose (fp);
+      *datalen = 0;
+      return (NULL); // short read (errno is set)
+   }
+   fclose (fp); // close the file
+   return (final_pathname); // file was read successfully and its content put in databuf with size datalen
+}
 static int fwrite_filecontents (const char *pathname, FILE *fp)
+{
+}
 static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp)
+{
+   // writes a directory entry in the image filesystem file pointed to by fp (or fakes so if fp is NULL)
+   // 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;
       if (fp != NULL)
          fwrite (fsentry->u.device.path, (size_t) datalen, 1, fp); // write null-terminated path (no leading slash)
       count += datalen;
+   }
-   if ((fp != NULL) && (count % image_align != 0))
+   if (count < fsentry->header.size)
+   {
+      if (fp != NULL)
-      fwrite (zeropad_buffer, count % image_align, 1, fp); // pad as necessary
+         fwrite (zeropad_buffer, fsentry->header.size - count, 1, fp); // pad as necessary
-   count = ROUND_TO_UPPER_MULTIPLE (count, image_align);
+      count += fsentry->header.size - count;
+   }
+   else if (count > fsentry->header.size)
+   {
+      fprintf (stderr, "ERROR: attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.\n", (size_t) fsentry->header.size, count);
+      exit (1);
+   }
    return (count);
+}
-static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, const char *stored_pathname, parms_t *entry_parms, const uint8_t *entry_data, const size_t entry_datalen)
+static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
    static char candidate_pathname[1024];
-   static char *MKIFS_PATH = 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_shstr; // section headers strings (containing ELF sections names)
+   const elf_section_header_t *shdr_dynstr; // dynamic strings
+   const elf_section_header_t *shdr_dynamic; // dynamic section
+   const elf_section_header_t *shdr;
+   const char *canonical_dylib_name;
+   const char *elf_section_name;
+   const char *dynamic_strings; // strings table of the ".dynamic" section
+   const char *shtable_strings; // strings table of the section headers table
+   const char *last_dirsep;
+   const elf_header_t *elf;
+   char *resolved_pathname;
    void *reallocated_ptr;
-   char processor_base[16];
+   void *old_data;
    struct stat stat_buf;
-   uint8_t *data_buffer = NULL;
+   size_t table_index;
-   size_t data_len = 0;
+   size_t table_count;
-   uint32_t mtime = (uint32_t) time (NULL);
+   //uint32_t mtime = (entry_parms->m(uint32_t) time (NULL);
    uint32_t extra_ino_flags = 0;
    fsentry_t *fsentry;
-   char *token;
-   FILE *fp;
    if (S_ISDIR (entry_parms->st_mode)) // are we storing a directory ?
+   {
       fprintf (stderr, "directory: ino 0x%x uid %d gid %d mode 0%o path \"%s\"\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname);
+   }
    else if (S_ISREG (entry_parms->st_mode)) // else are we storing a regular file ?
+   {
-      if ((entry_data != NULL) && (entry_datalen > 0)) // was an explicit contents blob supplied ?
+      if (strcmp (stored_pathname, "/proc/boot/boot") == 0) // is it the kernel ?
+      {
-         if (strcmp (stored_pathname, "proc/boot/boot") == 0) // is it the kernel ?
-         {
-            // HACK: for now just consider the kernel as a binary blob
+         // HACK: for now just consider the kernel as a binary blob
-            // FIXME: reimplement properly
+         // FIXME: reimplement properly
-            data_len = entry_datalen;
+         sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix); // fix the entry name
-            data_buffer = malloc (data_len);
+         stored_pathname = candidate_pathname;
+         extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
-            if (data_buffer == NULL)
+         image_kernel_ino = extra_ino_flags | (inode_count + 1);
-            {
+      }
-               fprintf (stderr, "fatal error: out of memory\n");
+      else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?
-               exit (1);
-            }
-            memcpy (data_buffer, entry_data, data_len);
+         image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
-            sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix); // fix the entry name
-            stored_pathname = candidate_pathname;
-            extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
-            image_kernel_ino = extra_ino_flags | (inode_count + 1);
-         }
-         else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?
-            image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
-         // should we substitute precompiled data to this data blob ?
+      // do we already know the data for this data blob ?
-         if ((entry_parms->precompiled_data != NULL) && (entry_parms->precompiled_datalen > 0))
+      if (entry_parms->data != NULL)
-         {
+      {
-            data_len = entry_parms->precompiled_datalen;
+         entry_parms->mtime = entry_parms->mtime_for_inline_files;
-            data_buffer = malloc (data_len);
-            if (data_buffer == NULL)
-            {
-               fprintf (stderr, "fatal error: out of memory\n");
-               exit (1);
-            }
-            memcpy (data_buffer, entry_parms->precompiled_data, data_len);
+         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)\n", extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->datalen);
-         }
-         else // else use the supplied data blob
-         {
-            data_len = entry_datalen;
-            data_buffer = malloc (data_len);
-            if (data_buffer == NULL)
-            {
-               fprintf (stderr, "fatal error: out of memory\n");
-               exit (1);
-            }
-            memcpy (data_buffer, entry_data, data_len);
-         }
+      }
 /*
          else if (entry_parms->should_compile_contents_as_startup_script) // should we compile this contents as a startup script ?
+         {
             // HACK: for now just use a precompiled script
             // FIXME: replace this with a true compilation with the rules defined above
             memcpy (data_buffer, INITIAL_STARTUP_SCRIPT, INITIAL_STARTUP_SCRIPT_LEN);
             data_len = INITIAL_STARTUP_SCRIPT_LEN;
             image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
          }*/
-         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)\n", extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, data_len);
-      }
-      else if ((entry_data != NULL) && (entry_data[0] != 0)) // else entry_datalen == 0, was some sort of pathname supplied ?
+      else if (buildhost_pathname != NULL) // else entry_datalen == 0, was some sort of pathname supplied ?
+      {
-         // is it an absolute pathname ?
-         if (IS_DIRSEP (entry_data[0])
-             || (isalpha (entry_data[0])
+         resolved_pathname = read_filecontents (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH), &entry_parms->data, &entry_parms->datalen);
-                 && (entry_data[1] == ':')
+         if (resolved_pathname == NULL)
-                 && IS_DIRSEP (entry_data[2])))
+         {
-            // in this case, it MUST exist at its designated location (either absolute or relative to the current working directory)
+            fprintf (stderr, "fatal error: filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s\n", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
-            strcpy (candidate_pathname, entry_data);
+            fprintf (stderr, "             v\n");
-            if (stat (candidate_pathname, &stat_buf) != 0)
+            fprintf (stderr, "%s", current_line);
-            {
-               fprintf (stderr, "fatal error: filesystem entry \"%s\" specified in \"%s\" line %d not found on build host\n", entry_data, buildfile_pathname, lineno);
+            fprintf (stderr, "             ^\n");
-               exit (1);
+            exit (1);
-            }
+         }
-         else // the path is relative, search it among the search paths we have
-         {
-            // is the search path NOT defined ?
+         stat (resolved_pathname, &stat_buf); // can't fail
-            if (entry_parms->search[0] == 0)
+         if (entry_parms->mtime == UINT32_MAX)
-            {
-               // initialize the default search path in MKIFS_PATH
+            entry_parms->mtime = (uint32_t) stat_buf.st_mtime;
-               if (MKIFS_PATH == NULL)
-               {
-                  MKIFS_PATH = getenv ("MKIFS_PATH"); // look in the environment first, and construct a default one if not supplied
+         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->datalen);
-                  if (MKIFS_PATH == NULL)
-                  {
-                     strcpy (processor_base, image_processor); // construct PROCESSOR_BASE
-                     token = strchr (processor_base, '-');
-                     if (token != NULL)
+      } // end if "was pathname supplied"
-                        *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
-                     if (MKIFS_PATH == NULL)
-                     {
-                        fprintf (stderr, "fatal error: out of memory\n");
-                        exit (1);
-                     }
-                     sprintf (MKIFS_PATH, ".|%s/%s/sbin|%s/%s/usr/sbin|%s/%s/boot/sys|%s/%s/boot/sys|%s/%s/bin|%s/%s/usr/bin|%s/%s/lib|%s/%s/lib/dll|%s/%s/usr/lib", // use a platform-agnostic character as path separator
+      // is the file we're storing a dylib and should we check for its canonical name ? FIXME: support for big endian is wrong. We should swap only if endianness is foreign, and also swap all ELF struct members below.
-                                          QNX_TARGET, image_processor,
-                                          QNX_TARGET, image_processor,
-                                          QNX_TARGET, image_processor,
+      if ((entry_parms->datalen > 52) // file is big enough to contain an ELF header
-                                          QNX_TARGET, processor_base,
+          && ((elf = (elf_header_t *) entry_parms->data) != NULL) // cast (necessary true)
-                                          QNX_TARGET, image_processor,
-                                          QNX_TARGET, image_processor,
+          && (memcmp (ELF_HDR_MEMBER (elf, magic), ELF_MAGIC_STR, 4) == 0) // file starts with the ELF magic
-                                          QNX_TARGET, image_processor,
+          && (   ((ELF_HDR_MEMBER (elf, endianness) == ELF_ENDIAN_LITTLE) && (ELF_HDR_MEMBER (elf, type) == 3)) // file is little endian (offset 5) AND relocatable executable (i.e. a dynamic library)
-                                          QNX_TARGET, image_processor,
+              || ((ELF_HDR_MEMBER (elf, endianness) == ELF_ENDIAN_BIG)    && (__builtin_bswap16 (ELF_HDR_MEMBER (elf, type)) == 3))) // file is big endian (offset 5) AND relocatable executable (i.e. a dynamic library)
-                                          QNX_TARGET, image_processor);
+          && entry_parms->should_autosymlink_dylib) // we should store it under its official .so name
-                  }
+      {
-               } // at this point MKIFS_PATH is defined
+         // we need to find the SONAME of this library
+         canonical_dylib_name = NULL;
-               strcpy (entry_parms->search, MKIFS_PATH); // if entry search path is not defined, use the contents of MKIFS_PATH
-            }
+         shdr_shstr = (elf_section_header_t *) &entry_parms->data[ELF_HDR_MEMBER (elf, section_header_table_offset) + (size_t) ELF_HDR_MEMBER (elf, section_header_item_size) * ELF_HDR_MEMBER (elf, section_header_names_idx)]; // quick access to section header for the section that contains the section names
+         shtable_strings = &entry_parms->data[ELF_STRUCT_MEMBER (elf, shdr_shstr, file_offset)]; // locate the start of the strings table that contains the section names
-            // convert path separators in the MKIFS_PATH environment variable into something platform-agnostic
+         // locate the sections we need (the dynamic section and its strings table)
+         table_count = ELF_HDR_MEMBER (elf, section_header_table_len);
+         shdr_dynamic = NULL;
+         shdr_dynstr = NULL;
-            for (token = entry_parms->search; *token != 0; token++)
+         for (table_index = 0; table_index < table_count; table_index++)
+         {
+            shdr = (elf_section_header_t *) &entry_parms->data[ELF_HDR_MEMBER (elf, section_header_table_offset) + (size_t) ELF_HDR_MEMBER (elf, section_header_item_size) * table_index]; // quick access to section header
+            elf_section_name = &shtable_strings[ELF_STRUCT_MEMBER (elf, shdr, name_offset)];
+            if (strcmp (elf_section_name, ".dynamic") == 0)
-               if (*token == PATH_SEP)
+               shdr_dynamic = shdr;
+            else if (strcmp (elf_section_name, ".dynstr") == 0)
-                  *token = '|';
+               shdr_dynstr = shdr;
+         }
-            token = strtok (entry_parms->search, "|");
+         // make sure we have both the dynamic section header and its own strings table header
-            while (token != NULL)
+         if ((shdr_dynamic != NULL) && (shdr_dynstr != NULL))
-            {
+         {
+            dynamic_strings = (char *) &entry_parms->data[ELF_STRUCT_MEMBER (elf, shdr_dynstr, file_offset)]; // quick access to dynamic sections strings table
+            // walk through the dynamic section, look for the DT_SONAME entry
+            for (dynamic_entry = (elf_dynamic_section_entry_t *) &entry_parms->data[ELF_STRUCT_MEMBER (elf, shdr_dynamic, file_offset)];
-               sprintf (candidate_pathname, "%s/%s", token, entry_data);
+                 (ELF_STRUCT_MEMBER (elf, dynamic_entry, tag) != ELF_DT_NULL);
+                 dynamic_entry = (elf_dynamic_section_entry_t *) ((uint8_t *) dynamic_entry + ELF_STRUCT_SIZE (elf, dynamic_entry)))
-               if (stat (candidate_pathname, &stat_buf) == 0)
+               if (ELF_STRUCT_MEMBER (elf, dynamic_entry, tag) == ELF_DT_SONAME)
+               {
+                  canonical_dylib_name = dynamic_strings + ELF_STRUCT_MEMBER (elf, dynamic_entry, value.as_integer);
                   break;
-               token = strtok (NULL, "|");
-            }
+               }
-            if (token == NULL)
+            // 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);
-               fprintf (stderr, "fatal error: filesystem entry \"%s\" specified in \"%s\" line %d not found on build host\n", entry_data, buildfile_pathname, lineno);
+               if (strcmp (candidate_pathname, stored_pathname) != 0) // claimed dylib name differs from passed name ?
-               exit (1);
+               {
+                  original_stored_pathname = stored_pathname; // if so, remember to create a symlink here
+                  stored_pathname = candidate_pathname;
+               }
+            }
+         }
-         data_len = stat_buf.st_size;
-         mtime = (uint32_t) stat_buf.st_mtime;
-         data_buffer = malloc (data_len);
-         if (data_buffer == NULL)
-         {
-            fprintf (stderr, "fatal error: out of memory\n");
-            exit (1);
-         }
-         fp = fopen (candidate_pathname, "rb");
-         fread (data_buffer, 1, data_len, fp);
-         fclose (fp);
-         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_data, data_len);
+      }
+   }
    else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?
-   {
-      data_len = strlen (entry_data);
-      data_buffer = malloc (data_len + 1);
-      if (data_buffer == NULL)
-      {
-         fprintf (stderr, "fatal error: out of memory\n");
-         exit (1);
-      }
-      memcpy (data_buffer, entry_data, data_len + 1); // copy including null terminator
-      fprintf (stderr, "symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, data_buffer);
+      fprintf (stderr, "symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data);
-   }
    else // we must be storing a FIFO
+   {
-      if (strchr (entry_data, ':') == NULL)
+      if (strchr (entry_parms->data, ':') == NULL)
+      {
          fprintf (stderr, "fatal error: device entry \"%s\" malformed (no 'dev:rdev' pair)\n", stored_pathname);
          exit (1);
+      }
-      fprintf (stderr, "fifo: ino 0x%x uid %d gid %d mode 0%o path \"%s\" dev rdev %s)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_data);
+      fprintf (stderr, "fifo: ino 0x%x uid %d gid %d mode 0%o path \"%s\" dev rdev %s)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data);
+   }
-   // reallocate filesystem entries array to hold one more slot
+   // grow filesystem entries array to hold one more slot
    reallocated_ptr = realloc (*fsentries, (*fsentry_count + 1) * sizeof (fsentry_t)); // attempt to reallocate
    if (reallocated_ptr == NULL)
+   {
       fprintf (stderr, "fatal error: out of memory\n");
       exit (1);
    fsentry->header.extattr_offset = 0;
    fsentry->header.ino = 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 = mtime;
+   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);
+      fsentry->u.dir.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
-      fsentry->header.size = (uint16_t) (sizeof (fsentry->header) + ROUND_TO_UPPER_MULTIPLE (strlen (fsentry->u.dir.path) + 1, image_align)); // now we can set the size
+      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) data_len;
+      fsentry->u.file.size = (uint32_t) entry_parms->datalen;
+      fsentry->u.file.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
-      fsentry->u.file.path = strdup (stored_pathname);
+      fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->datalen);
-      fsentry->u.file.UNSAVED_databuf = data_buffer;
+      if (fsentry->u.file.UNSAVED_databuf == NULL)
+      {
+         fprintf (stderr, "fatal error: out of memory\n");
+         exit (1);
+      }
+      memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data, entry_parms->datalen);
-      fsentry->header.size = (uint16_t) (sizeof (fsentry->header) + ROUND_TO_UPPER_MULTIPLE (strlen (fsentry->u.file.path) + 1, image_align)); // now we can set the 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) + 1);
+      fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname) + 1);
-      fsentry->u.symlink.sym_size = (uint16_t) data_len;
+      fsentry->u.symlink.sym_size = (uint16_t) entry_parms->datalen;
+      fsentry->u.symlink.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
-      fsentry->u.symlink.path = strdup (stored_pathname);
+      fsentry->u.symlink.contents = strdup (entry_parms->data);
-      fsentry->u.symlink.contents = data_buffer;
+      if (fsentry->u.symlink.contents == NULL)
+      {
+         fprintf (stderr, "fatal error: out of memory\n");
+         exit (1);
+      }
-      fsentry->header.size = (uint16_t) (sizeof (fsentry->header) + ROUND_TO_UPPER_MULTIPLE ((size_t) fsentry->u.symlink.sym_offset + fsentry->u.symlink.sym_size + 1, image_align)); // now we can set the size
+      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
+   else // necessarily a device node
+   {
-      fsentry->u.device.dev  = strtol (entry_data, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
+      fsentry->u.device.dev  = strtol (entry_parms->data, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
-      fsentry->u.device.rdev = strtol (strchr (entry_data, ':') + 1, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
+      fsentry->u.device.rdev = strtol (strchr (entry_parms->data, ':') + 1, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
-      fsentry->u.device.path = strdup (stored_pathname);
+      fsentry->u.device.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
-      fsentry->header.size = (uint16_t) (sizeof (fsentry->header) + ROUND_TO_UPPER_MULTIPLE (strlen (fsentry->u.device.path), image_align)); // now we can set the size
+      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)++;
+   // should we also add a symlink to this entry ? (in case we stored a dylib file under its canonical name)
+   if (original_stored_pathname != NULL)
+   {
+      entry_parms->is_compiled_bootscript = false;
+      entry_parms->should_autosymlink_dylib = false;
+      entry_parms->should_follow_symlinks = false;
+      entry_parms->st_mode = S_IFLNK | 0777; // NOTE: mkifs stores symlink permissions as rwxrwxrwx !
+      last_dirsep = strrchr (stored_pathname, '/');
+      old_data = entry_parms->data; // backup previous data pointer
+      entry_parms->data = (uint8_t *) (last_dirsep == NULL ? stored_pathname : last_dirsep + 1); // store symlink target in dirent data
+      entry_parms->datalen = strlen (entry_parms->data);
+      add_fsentry (fsentries, fsentry_count, entry_parms, original_stored_pathname, NULL);
+      entry_parms->data = old_data; // restore previous data pointer so that it can be freed normally
+   }
    return (*fsentry_count);
+}
 static int fsentry_compare_pathnames_cb (const void *a, const void *b)
    const char *pathname_b = (S_ISDIR (entry_b->header.mode) ? entry_b->u.dir.path : (S_ISREG (entry_b->header.mode) ? entry_b->u.file.path : (S_ISLNK (entry_b->header.mode) ? entry_b->u.symlink.path : entry_b->u.device.path)));
    return (strcmp (pathname_a, pathname_b));
+}
-static int fsentry_compare_sizes_cb (const void *a, const void *b)
+static void update_MKIFS_PATH (const char *processor)
+{
-   // qsort() callback that compares two imagefs filesystem entries and sort them by increasing data size
+   // updates the value of MKIFS_PATH according to the passed processor name string, unless an environment variable already defines it
+   char processor_base[16];
+   size_t data_len;
+   char *envvar;
+   char *token;
+   envvar = getenv ("MKIFS_PATH"); // look in the environment first, and construct a default one if not supplied
+   if (envvar != NULL)
+      MKIFS_PATH = envvar; // if envvar is present, set MKIFS_PATH to point to it
+   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
-   const fsentry_t *entry_a = (const fsentry_t *) a;
+      token = strchr (processor_base, '-');
+      if (token != NULL)
+         *token = 0; // split anything from the first dash onwards
-   const fsentry_t *entry_b = (const fsentry_t *) b;
+      data_len = strlen (processor_base);
-   const int32_t size_a = (S_ISREG (entry_a->header.mode) ? entry_a->u.file.size : 0); // only files (i.e. entries wearing the S_IFREG flag) have a separate data block
+      if ((data_len > 2) && ((processor_base[data_len - 2] == 'b') || (processor_base[data_len - 2] == 'l')) && (processor_base[data_len - 1] == 'e'))
+         processor_base[data_len - 2] = 0; // if it ends with "le" or "be", strip that too
+      MKIFS_PATH = malloc (10 * MAXPATHLEN); // construct a default MKIFS_PATH now
+      if (MKIFS_PATH == NULL)
+      {
+         fprintf (stderr, "fatal error: out of memory\n");
+         exit (1);
+      }
-   const int32_t size_b = (S_ISREG (entry_b->header.mode) ? entry_b->u.file.size : 0); // only files (i.e. entries wearing the S_IFREG flag) have a separate data block
+      sprintf (MKIFS_PATH, "." PATH_SEP_STR "%s/%s/sbin" PATH_SEP_STR "%s/%s/usr/sbin" PATH_SEP_STR "%s/%s/boot/sys" PATH_SEP_STR "%s/%s/boot/sys" PATH_SEP_STR "%s/%s/bin" PATH_SEP_STR "%s/%s/usr/bin" PATH_SEP_STR "%s/%s/lib" PATH_SEP_STR "%s/%s/lib/dll" PATH_SEP_STR "%s/%s/usr/lib", // use a platform-specific character as path separator
+               QNX_TARGET, processor,
+               QNX_TARGET, processor,
+               QNX_TARGET, processor,
+               QNX_TARGET, processor_base,
+               QNX_TARGET, processor,
+               QNX_TARGET, processor,
+               QNX_TARGET, processor,
+               QNX_TARGET, processor,
-   return ((int) size_b - (int) size_a);
+               QNX_TARGET, processor);
+   }
+   return;
+}
 int main (int argc, char **argv)
+{
    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)
    static fsentry_t *fsentries = NULL; // output IFS's filesystem entries
    static size_t fsentry_count = 0; // number of entries in the IFS filesystem
-   static parms_t default_parms = { 0755, 0644, 0, 0, S_IFREG, "/proc/boot", false, "", NULL, 0 }; // default parameters for a filesystem entry
+   static parms_t default_parms = { // default parameters for a filesystem entry
+      .dperms = 0755,
+      .perms = 0644,
+      .uid = 0,
+      .gid = 0,
+      .st_mode = S_IFREG,
+      .mtime = UINT32_MAX,
+      .mtime_for_inline_files = UINT32_MAX,
+      .prefix = "/proc/boot",
+      .should_follow_symlinks = true, // [+|-followlink]
+      .should_autosymlink_dylib = true, // [+|-autolink]
+      .is_compiled_bootscript = false, // [+|-script]
+      .search = "",
+      .data = NULL,
+      .datalen = 0
+   };
    static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
    // bootable IFS support
    char *bootfile_pathname = NULL;           // HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS
    size_t bootfile_size = 0;                 // HACK: size of the bootcode binary blob file to put at the start of a bootable IFS
    char *startupfile_pathname = NULL;        // HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS
    size_t startupfile_ep_from_imagebase = 0; // HACK: startup code entrypoint offset from image base for a bootable IFS
    char *kernelfile_pathname = NULL;         // HACK: pathname to precompiled kernel file blob to put in a bootable IFS
    size_t kernelfile_offset = 0;             // HACK: kernel file offset in bootable IFS
+   char path_on_buildhost[MAXPATHLEN] = "";
-   char path_in_ifs[MAXPATHLEN];
+   char path_in_ifs[MAXPATHLEN] = "";
    char *ifs_pathname = NULL;
    void *reallocated_ptr;
+   struct tm utc_time;
    struct stat stat_buf;
    size_t startuptrailer_offset;
    size_t startupheader_offset;
    size_t imgtrailer_offset;
    size_t imgheader_offset;
    size_t imgdir_offset;
    size_t imgdir_size;
    size_t final_size;
+   size_t blob_size;
+   size_t available_space;
+   size_t allocated_size;
    size_t fsentry_index;
+   size_t largest_index;
+   size_t largest_size;
    size_t curr_offset;
-   size_t blob_datasize; // mallocated size
-   size_t blob_datalen; // used size
-   uint8_t *blob_data = NULL; // mallocated
-   char *line_ptr;
+   char *specifiedpathname_start;
    char *directiveblock_start;
+   char *blob_data;
    char *write_ptr;
+   char *line_ptr;
    char *token;
    char *value;
    char *sep;
    //char *ctx;
    int arg_index;
             exit (1);
+         }
          *sep = 0;
          kernelfile_pathname = argv[arg_index];
          kernelfile_offset = (size_t) read_integer (sep + 1);
+      }
+      else if (strcmp (argv[arg_index], "-n") == 0)
+         default_parms.mtime_for_inline_files = 0; // inline files should have a mtime set to zero
+      else if (strcmp (argv[arg_index], "-nn") == 0)
+      {
+         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], "--info") == 0)
          want_info = true;
       else if ((strcmp (argv[arg_index], "-?") == 0) || (strcmp (argv[arg_index], "--help") == 0))
          want_help = true;
       fprintf ((want_help ? stdout : stderr), "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");
       fprintf ((want_help ? stdout : stderr), "          version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
       if (!want_help)
          fprintf (stderr, "error: missing parameters\n");
       fprintf ((want_help ? stdout : stderr), "usage:\n");
-      fprintf ((want_help ? stdout : stderr), "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] <buildfile> <outfile>\n");
+      fprintf ((want_help ? stdout : stderr), "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-n[n]] <buildfile> <outfile>\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool --info <ifs file>\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool --help\n");
+      fprintf ((want_help ? stdout : stderr), "WARNING: the compilation feature is currently a work in progress (broken). Only the --info mode is usable at the moment.\n");
       exit (want_help ? 0 : 1);
+   }
    // do we want info about a particular IFS ? if so, dump it
    if (want_info)
    else if (access (QNX_TARGET, 0) != 0)
+   {
       fprintf (stderr, "error: the QNX_TARGET environment variable doesn't point to an existing directory\n");
       exit (1);
+   }
+   // prepare a default MKIFS_PATH assuming the host processor
+   update_MKIFS_PATH (image_processor);
    // open build file
    buildfile_fp = fopen (buildfile_pathname, "rb");
    if (buildfile_fp == NULL)
+   {
+   }
    // stack up filesystem entries
    memcpy (&entry_parms, &default_parms, sizeof (default_parms));
    entry_parms.st_mode = S_IFDIR | default_parms.dperms;
-   add_fsentry (&fsentries, &fsentry_count, "", &entry_parms, NULL, 0); // add the root dir first
+   add_fsentry (&fsentries, &fsentry_count, &entry_parms, "", NULL); // add the root dir first
    while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)
+   {
+      if (current_line != NULL)
+         free (current_line);
+      current_line = strdup (line_buffer);
+      if (current_line == NULL)
+      {
+         fprintf (stderr, "fatal error: out of memory\n");
+         exit (1);
+      }
       lineno++; // keep track of current line number
       //fprintf (stderr, "read buildfile line %d: {%s}\n", lineno, line_buffer);
       line_ptr = line_buffer;
       while ((*line_ptr != 0) && isspace (*line_ptr))
       if ((string_len > 0) && (line_buffer[string_len - 1] == '\n'))
          line_buffer[string_len - 1] = 0; // chop off newline for easier debug output
       // reset entry values
       memcpy (&entry_parms, &default_parms, sizeof (default_parms));
+      path_in_ifs[0] = 0;
+      path_on_buildhost[0] = 0;
       //fprintf (stderr, "parsing buildfile line %d: [%s]\n", lineno, line_ptr);
       // does this line start with an attribute block ?
       if (*line_ptr == '[')
+               }
                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
+                  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 (FIXME: we should search in MKIFS_PATH instead of this. Not important.)
                //strcpy (image_bootfile, bootfile_pathname); // FIXME: HACK
                if (stat (bootfile_pathname, &stat_buf) != 0)
                if (stat (kernelfile_pathname, &stat_buf) != 0)
+               {
                   fprintf (stderr, "fatal error: unable to read precompiled kernel file \"%s\" specified in --kernelfile argument\n", kernelfile_pathname);
                   exit (1);
+               }
-               entry_parms.precompiled_data = malloc (stat_buf.st_size);
+               entry_parms.data = malloc (stat_buf.st_size);
-               if (entry_parms.precompiled_data == NULL)
+               if (entry_parms.data == NULL)
+               {
                   fprintf (stderr, "fatal error: out of memory\n");
                   exit (1);
+               }
                fp = fopen (kernelfile_pathname, "rb");
-               fread (entry_parms.precompiled_data, 1, stat_buf.st_size, fp);
+               fread (entry_parms.data, 1, stat_buf.st_size, fp);
                fclose (fp);
-               entry_parms.precompiled_datalen = stat_buf.st_size;
+               entry_parms.datalen = stat_buf.st_size;
+            }
+            else if (strncmp (token, "mtime=", 6) == 0) { REACH_TOKEN_VALUE (); if (strcmp (value, "*") == 0) entry_parms.mtime = UINT32_MAX; else {
+                  // value *must* be "YYYY-MM-DD-HH:MM:SS" by specification
+                  memset (&utc_time, 0, sizeof (utc_time));
+                  if (sscanf (value, "%u-%u-%u-%u:%u:%u", &utc_time.tm_year, &utc_time.tm_mon, &utc_time.tm_mday, &utc_time.tm_hour, &utc_time.tm_min, &utc_time.tm_sec) != 6)
+                  {
+                     fprintf (stderr, "warning: syntax error in \"%s\" line %d: mtime specification not in YYYY-MM-DD-HH:MM:SS format (skipping)\n", 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) {
+            else if (strcmp (token, "+script")     == 0) {
                entry_parms.is_compiled_bootscript = true;
+               entry_parms.data = malloc (sizeof (INITIAL_STARTUP_SCRIPT) - 1);
+               if (entry_parms.data == NULL)
+               {
+                  fprintf (stderr, "fatal error: out of memory\n");
+                  exit (1);
+               }
-               entry_parms.precompiled_data = INITIAL_STARTUP_SCRIPT; // HACK until the script compiler is implemented
+               memcpy (entry_parms.data, INITIAL_STARTUP_SCRIPT, sizeof (INITIAL_STARTUP_SCRIPT) - 1); // FIXME: HACK until the script compiler is implemented
-               entry_parms.precompiled_datalen = sizeof (INITIAL_STARTUP_SCRIPT) - 1;
+               entry_parms.datalen = sizeof (INITIAL_STARTUP_SCRIPT) - 1;
+            }
+            else if (strcmp (token, "-script")     == 0) entry_parms.is_compiled_bootscript = false;
+            else if (strcmp (token, "+followlink") == 0) entry_parms.should_follow_symlinks = true;
+            else if (strcmp (token, "-followlink") == 0) entry_parms.should_follow_symlinks = false;
+            else if (strcmp (token, "+autolink")   == 0) entry_parms.should_autosymlink_dylib = true;
+            else if (strcmp (token, "-autolink")   == 0) entry_parms.should_autosymlink_dylib = false;
             else fprintf (stderr, "warning: unimplemented attribute in \"%s\" line %d: '%s'\n", buildfile_pathname, lineno, token);
             #undef REACH_TOKEN_VALUE
             token = strtok (NULL, RECORD_SEP_STR); // proceed to next attribute token
+         }
                } } while (0)
             #define APPLY_DEFAULT_ATTR_STR(attr,descr,fmt) do { if (strcmp (entry_parms.attr, default_parms.attr) != 0) { \
                   fprintf (stderr, "info: changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d\n", default_parms.attr, entry_parms.attr, buildfile_pathname, lineno); \
                   strcpy (default_parms.attr, entry_parms.attr); \
                } } while (0)
-            APPLY_DEFAULT_ATTR_NUM (dperms,  "directory permissions", "0%o");
+            APPLY_DEFAULT_ATTR_NUM (dperms,                   "directory permissions",           "0%o");
-            APPLY_DEFAULT_ATTR_NUM (perms,   "file permissions",      "0%o");
+            APPLY_DEFAULT_ATTR_NUM (perms,                    "file permissions",                "0%o");
-            APPLY_DEFAULT_ATTR_NUM (uid,     "owner ID",              "%d");
+            APPLY_DEFAULT_ATTR_NUM (uid,                      "owner ID",                        "%d");
-            APPLY_DEFAULT_ATTR_NUM (gid,     "group ID",              "%d");
+            APPLY_DEFAULT_ATTR_NUM (gid,                      "group ID",                        "%d");
-            APPLY_DEFAULT_ATTR_NUM (st_mode, "inode type",            "0%o");
+            APPLY_DEFAULT_ATTR_NUM (st_mode,                  "inode type",                      "0%o");
-            APPLY_DEFAULT_ATTR_STR (prefix,  "prefix",                "\"%s\"");
+            APPLY_DEFAULT_ATTR_STR (prefix,                   "prefix",                          "\"%s\"");
-            APPLY_DEFAULT_ATTR_NUM (is_compiled_bootscript, "compiled script state", "%d");
+            APPLY_DEFAULT_ATTR_NUM (is_compiled_bootscript,   "compiled script state",           "%d");
+            APPLY_DEFAULT_ATTR_NUM (should_follow_symlinks,   "symlink resolution",              "%d");
+            APPLY_DEFAULT_ATTR_NUM (should_autosymlink_dylib, "dylib canonical name symlinking", "%d");
             #undef APPLY_DEFAULT_ATTR_STR
             #undef APPLY_DEFAULT_ATTR_NUM
             continue; // end of line reached, proceed to the next line
+         }
          // end of attributes parsing
       string_len = sprintf (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
+      is_quoted_context = (*line_ptr == '"');
+      if (is_quoted_context)
+         line_ptr++; // skip a possible initial quote
       if (*line_ptr == '/')
+      {
          fprintf (stderr, "warning: paths in the IFS file should not begin with a leading '/' in \"%s\" line %d\n", buildfile_pathname, lineno);
          line_ptr++; // consistency check: paths in the IFS should not begin with a '/'
+      }
-      while ((*line_ptr != 0) && (*line_ptr != '=') && !isspace (*line_ptr))
+      while ((*line_ptr != 0) && ((!is_quoted_context && (*line_ptr != '=') && !isspace (*line_ptr)) || (is_quoted_context && (*line_ptr == '"'))))
+      {
          if (*line_ptr == '\\')
+         {
             line_ptr++;
             *write_ptr++ = *line_ptr; // unescape characters that are escaped with '\'
          else
             *write_ptr++ = *line_ptr;
          line_ptr++;
+      }
       *write_ptr = 0; // terminate the string
+      if (is_quoted_context && (*line_ptr == '"'))
+         line_ptr++; // skip a possible final quote
       // we reached a space OR an equal sign
       while ((*line_ptr != 0) && isspace (*line_ptr))
          line_ptr++; // skip optional spaces after the filename in the IFS
-      blob_data = NULL;
-      blob_datasize = 0;
-      blob_datalen = 0;
       // do we have an equal sign ?
       if (*line_ptr == '=') // we must be creating either a directory or a file, do we have an equal sign ?
+      {
          line_ptr++; // skip the equal sign
+         }
          // read the host system's path, it may be either a path or a contents definition. Is it a content definition ?
          if (*line_ptr == '{')
+         {
+            path_on_buildhost[0] = 0; // this is an inline fine, which means it doesn't exist on the build host
+            allocated_size = 0;
             line_ptr++; // skip the leading content definition
             is_escaped_char = false;
             for (;;)
+            {
                read_char = fgetc (buildfile_fp);
                else if ((read_char == '}') && !is_escaped_char)
                   break; // found an unescaped closing bracked, stop parsing
                else
+               {
                   is_escaped_char = false; // any other char, meaning the next one will not be escaped
-                  if (blob_datalen == blob_datasize) // reallocate in 4 kb blocks
+                  if (entry_parms.data == NULL) // only store the contents if we do NOT know the data yet
+                  {
-                     reallocated_ptr = realloc (blob_data, blob_datasize + 4096);
+                     if (entry_parms.datalen == allocated_size) // reallocate in 4 kb blocks
-                     if (reallocated_ptr == NULL)
+                     {
+                        reallocated_ptr = realloc (entry_parms.data, allocated_size + 4096);
+                        if (reallocated_ptr == NULL)
+                        {
-                        fprintf (stderr, "fatal error: out of memory\n");
+                           fprintf (stderr, "fatal error: out of memory\n");
-                        exit (1);
+                           exit (1);
+                        }
+                        entry_parms.data = reallocated_ptr;
+                        allocated_size += 4096;
+                     }
-                     blob_data = reallocated_ptr;
+                     entry_parms.data[entry_parms.datalen++] = read_char;
-                     blob_datasize += 4096;
+                  }
-                  blob_data[blob_datalen++] = read_char;
                   if (read_char == '\n')
                      lineno++;
+               }
+            }
+         }
-         else // not a content definition between { brackets }, meaning it's a build host filesystem path
+         else // not a content definition between { brackets }, must be either a pathname on the build host, or the target of a symlink
+         {
+            is_quoted_context = (*line_ptr == '"');
+            if (is_quoted_context)
+               line_ptr++; // skip a possible initial quote
+            specifiedpathname_start = line_ptr; // remember where the specified pathname starts
-            blob_data = line_ptr; // explicit pathname on build host
+            write_ptr = line_ptr; // now unescape all characters
+            while ((*line_ptr != 0) && ((!is_quoted_context && !isspace (*line_ptr)) || (is_quoted_context && (*line_ptr == '"'))))
+            {
+               if (*line_ptr == '\\')
+               {
+                  line_ptr++;
+                  *write_ptr++ = *line_ptr; // unescape characters that are escaped with '\'
+               }
+               else
+                  *write_ptr++ = *line_ptr;
+               line_ptr++;
+            }
+            *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.datalen = strlen (specifiedpathname_start); // if so, store the symlink target as the dirent's blob data
+               entry_parms.data = strdup (specifiedpathname_start);
+               if (entry_parms.data == NULL)
+               {
+                  fprintf (stderr, "fatal error: out of memory\n");
-            blob_datalen = 0;
+                  exit (1);
+               }
+            }
+            else // it's a build host filesystem path
+               strcpy (path_on_buildhost, line_ptr); // the path on the build host is given after the equal sign
+         }
+      }
       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
+         {
             fprintf (stderr, "warning: syntax error in \"%s\" line %d: missing equal sign and symlink target (skipping)\n", buildfile_pathname, lineno);
             continue; // invalid symlink specification, skip line
+         }
-         blob_data = &path_in_ifs[strlen (entry_parms.prefix) + 1]; // same pathname
+         strcpy (path_on_buildhost, specifiedpathname_start); // the path on the build host is the one specified
+         sep = strrchr (specifiedpathname_start, '/');
-         blob_datalen = 0;
+         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)
+      }
       // now add this entry to the image filesystem
+      if (S_ISDIR (entry_parms.st_mode))
-      entry_parms.st_mode |= (S_ISDIR (entry_parms.st_mode) ? entry_parms.dperms : entry_parms.perms); // complete entry permissions
+         entry_parms.st_mode |= entry_parms.dperms;
+      else if (S_ISLNK (entry_parms.st_mode))
-      add_fsentry (&fsentries, &fsentry_count, path_in_ifs, &entry_parms, blob_data, blob_datalen); // and add filesystem entry
+         entry_parms.st_mode |= 0777; // NOTE: mkifs sets symlink permissions to rwxrwxrwx !?
-      if (blob_datasize > 0)
+      else // file or device node
-         free (blob_data); // if blob data was allocated, free it
+         entry_parms.st_mode |= entry_parms.perms;
-   }
-   // sort the filesystem entries by pathname
-   qsort (&fsentries[1], fsentry_count - 1, sizeof (fsentry_t), fsentry_compare_pathnames_cb);
+      add_fsentry (&fsentries, &fsentry_count, &entry_parms, path_in_ifs, path_on_buildhost); // and add filesystem entry
-   // calculate filesystem entries size
-   imgdir_size = sizeof (image_header);
-   for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-   {
-      fprintf (stderr, "info: sorted entry: %s\n", (S_ISDIR (fsentries[fsentry_index].header.mode) ? fsentries[fsentry_index].u.dir.path : (S_ISREG (fsentries[fsentry_index].header.mode) ? fsentries[fsentry_index].u.file.path : (S_ISLNK (fsentries[fsentry_index].header.mode) ? fsentries[fsentry_index].u.symlink.path : fsentries[fsentry_index].u.device.path))));
+      if (entry_parms.data != NULL)
-      imgdir_size += fwrite_fsentry (&fsentries[fsentry_index], NULL);
+         free (entry_parms.data); // if blob data was allocated, free it
+   }
-   fprintf (stderr, "info: image directory size: %zd (0x%zx)\n", imgdir_size, imgdir_size);
    // write IFS file
-   fp = fopen (ifs_pathname, "wb");
+   fp = fopen (ifs_pathname, "w+b");
    if (fp == NULL)
+   {
       fprintf (stderr, "error: failed to open \"%s\" for writing (%s)\n", ifs_pathname, strerror (errno));
       exit (1);
+   }
    imgheader_offset = ftell (fp); // save image header offset
    memset (&image_header, 0, sizeof (image_header)); // prepare image header
    memcpy (&image_header.signature, "imagefs", 7); // image filesystem signature, i.e. "imagefs"
    image_header.flags         = IMAGE_FLAGS_TRAILER_V2 | IMAGE_FLAGS_SORTED | IMAGE_FLAGS_INO_BITS; // endian neutral flags, 0x1c (IMAGE_FLAGS_TRAILER_V2 | IMAGE_FLAGS_SORTED | IMAGE_FLAGS_INO_BITS)
    image_header.image_size    = WILL_BE_FILLED_LATER; // size from header to end of trailer (here 0xca6fe0 or 13 266 912)
-   image_header.hdr_dir_size  = (uint32_t) imgdir_size; // size from header to last dirent (here 0x12b8 or 4792)
+   image_header.hdr_dir_size  = WILL_BE_FILLED_LATER; // size from header to last dirent (here 0x12b8 or 4792)
    image_header.dir_offset    = sizeof (image_header); // offset from header to first dirent (here 0x5c or 92)
    image_header.boot_ino[0]   = image_kernel_ino; // inode of files for bootstrap p[ro?]g[ra?]ms (here 0xa0000002, 0, 0, 0)
    image_header.script_ino    = image_bootscript_ino; // inode of file for script (here 3)
    image_header.mountpoint[0] = '/'; // default mountpoint for image ("/" + "\0\0\0")
    fwrite (&image_header, sizeof (image_header), 1, fp); // write image header
    PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
    // write image directory (with the wrong file offsets)
+   if (image_header.flags & IMAGE_FLAGS_SORTED)
+      qsort (&fsentries[1], fsentry_count - 1, sizeof (fsentry_t), fsentry_compare_pathnames_cb); // sort the filesystem entries by pathname
    imgdir_offset = ftell (fp);
+   imgdir_size = 0; // measure image dir size on the fly
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
-      fwrite_fsentry (&fsentries[fsentry_index], fp); // NOTE: padding is handled in this function
+      imgdir_size += fwrite_fsentry (&fsentries[fsentry_index], fp); // NOTE: padding is handled in this function
-   PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+   imgdir_size += fwrite ("\0\0\0\0", 1, 4, fp); // there seems to be 4 bytes of padding after the image directory
    // is it a bootable image with a kernel file ?
    if ((startupfile_pathname != NULL) && (kernelfile_pathname != NULL))
+   {
-      // sort the filesystem entries by sizes
+      // start by writing the startup script data blob, if we have one
-      qsort (fsentries, fsentry_count, sizeof (fsentry_t), fsentry_compare_sizes_cb);
+      for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
-      // write as many small files as we can before reaching the kernel offset
+         if (fsentries[fsentry_index].header.ino == image_bootscript_ino)
+            break; // locate it
-      for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+      if (fsentry_index < fsentry_count) // found it ?
+      {
-         if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written)
-            continue; // skip all entries that don't have a separate data block and those who were written already
          curr_offset = ftell (fp);
          if (curr_offset + fsentries[fsentry_index].u.file.size >= kernelfile_offset)
+         {
-            break; // stop writing entries as soon as we reach the kernel file offset
+            fprintf (stderr, "error: the compiled startup script is too big (%zd bytes, max is %zd) to fit at current offset %zd\n", (size_t) fsentries[fsentry_index].u.file.size, kernelfile_offset - curr_offset, curr_offset);
+            exit (1);
+         }
          fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imgheader_offset); // save file data blob offset in file structure
          fwrite (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
-         PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+//            PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
          fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
+      // now write the filesystem entries that may fit before the kernel
+      for (;;)
+      {
+         curr_offset = ftell (fp); // see where we are
+         available_space = kernelfile_offset - curr_offset; // measure the available space
+         // look for the biggest one that can fit
+         largest_index = 0;
+         largest_size = SIZE_MAX;
+         for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
+         {
+            if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written || (fsentries[fsentry_index].u.file.size > available_space))
+               continue; // skip all entries that don't have a separate data block, those who were written already and those that wouldn't fit
+            if (fsentries[fsentry_index].u.file.size > largest_size)
+            {
+               largest_size = fsentries[fsentry_index].u.file.size;
+               largest_index = fsentry_index;
+            }
+         }
+         if (largest_size == SIZE_MAX)
+            break; // found none ? if so, stop searching
+         fsentries[largest_index].u.file.offset = (uint32_t) (curr_offset - imgheader_offset); // save file data blob offset in file structure
+         fwrite (fsentries[largest_index].u.file.UNSAVED_databuf, 1, fsentries[largest_index].u.file.size, fp); // write file data blob
+//         PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+         fsentries[largest_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
       PAD_OUTFILE_TO (kernelfile_offset); // reach the kernel offset
       // ######################################################################################################################################################################################################################################
       // # FIXME: figure out how to re-create it: linker call involved
       fwrite_filecontents (kernelfile_pathname, fp); // write kernel from blob file
       PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+   }
    // then write all the other files
-   for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+   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)
          continue; // skip all entries that don't have a separate data block and those who were written already
       curr_offset = ftell (fp);
       fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imgheader_offset); // save file data blob offset in file structure
       fwrite (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
-      PAD_OUTFILE_TO (ROUND_TO_UPPER_MULTIPLE (ftell (fp), image_align)); // pad as necessary
+//      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
+   }
    // finally, write trailer (including empty checksum)
    imgtrailer_offset = ftell (fp); // save image trailer offset
       startup_header.ram_size = (uint32_t) final_size; // FIXME: this is necessarily a bit less, but should we really bother calculating the right size ?
       startup_header.stored_size = startup_header.ram_size;
       fwrite (&startup_header, sizeof (startup_header), 1, fp); // write startup header
       // compute SHA-512 checksum and V1 checksum of startup block
-      blob_datasize = startuptrailer_offset - startupheader_offset;
+      blob_size = startuptrailer_offset - startupheader_offset;
-      blob_data = malloc (blob_datasize);
+      blob_data = malloc (blob_size + sizeof (startup_trailer));
       if (blob_data == NULL)
+      {
          fprintf (stderr, "fatal error: out of memory\n");
          exit (1);
+      }
       fseek (fp, startupheader_offset, SEEK_SET);
-      fread (blob_data, 1, blob_datasize, fp);
+      fread (blob_data, 1, blob_size, fp);
-      SHA512 (blob_data, blob_datasize, startup_trailer.sha512); // compute SHA512 checksum
+      SHA512 (blob_data, blob_size, startup_trailer.sha512); // compute SHA512 checksum
       if (   ( (startup_header.flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
           || (!(startup_header.flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
          is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
       else
          is_foreign_endianness = false; // else this header is for the same endianness as us
-      startup_trailer.cksum = 0; // compute old checksum
+      fseek (fp, startupheader_offset, SEEK_SET);
-      startup_trailer.cksum = update_checksum (startup_trailer.cksum, (const uint32_t *) blob_data, blob_datasize, is_foreign_endianness);
+      fread (blob_data, 1, blob_size + SHA512_DIGEST_LENGTH, fp);
-      startup_trailer.cksum = update_checksum (startup_trailer.cksum, (const uint32_t *) startup_trailer.sha512, sizeof (startup_trailer.sha512), is_foreign_endianness);
+      startup_trailer.cksum = update_checksum (blob_data, blob_size + SHA512_DIGEST_LENGTH, is_foreign_endianness); // compute old checksum
       free (blob_data);
       // rewrite startup trailer with final values
       fseek (fp, startuptrailer_offset, SEEK_SET);
       fwrite (&startup_trailer, sizeof (startup_trailer), 1, fp); // write startup trailer
+   }
    // rewrite image header with final values
    fseek (fp, imgheader_offset, SEEK_SET);
    image_header.image_size = (uint32_t) (final_size - imgheader_offset); // size of uncompressed imagefs
+   image_header.hdr_dir_size = sizeof (image_header) + (uint32_t) imgdir_size; // size from start of image header to last dirent
    fwrite (&image_header, sizeof (image_header), 1, fp); // write image header
-   // rewrite image directory with final checksum values
+   // rewrite image directory with final offset values
    fseek (fp, imgdir_offset, SEEK_SET);
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
       fwrite_fsentry (&fsentries[fsentry_index], fp);
    // compute SHA-512 checksum and V1 checksum of image block
-   blob_datasize = imgtrailer_offset - imgheader_offset;
+   blob_size = imgtrailer_offset - imgheader_offset;
-   blob_data = malloc (blob_datasize);
+   blob_data = malloc (blob_size + sizeof (image_trailer));
    if (blob_data == NULL)
+   {
       fprintf (stderr, "fatal error: out of memory\n");
       exit (1);
+   }
    fseek (fp, imgheader_offset, SEEK_SET);
-   fread (blob_data, 1, blob_datasize, fp);
+   fread (blob_data, 1, blob_size, fp);
-   SHA512 (blob_data, blob_datasize, image_trailer.sha512); // compute SHA512 checksum
+   SHA512 (blob_data, blob_size, image_trailer.sha512); // compute SHA512 checksum
    if (   ( (image_header.flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
        || (!(image_header.flags & IMAGE_FLAGS_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)))
       is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
    else
       is_foreign_endianness = false; // else this header is for the same endianness as us
-   image_trailer.cksum = 0; // compute old checksum
+   fseek (fp, imgheader_offset, SEEK_SET);
-   image_trailer.cksum = update_checksum (image_trailer.cksum, (const uint32_t *) blob_data, blob_datasize, is_foreign_endianness);
+   fread (blob_data, 1, blob_size + SHA512_DIGEST_LENGTH, fp);
-   image_trailer.cksum = update_checksum (image_trailer.cksum, (const uint32_t *) image_trailer.sha512, sizeof (image_trailer.sha512), is_foreign_endianness);
+   image_trailer.cksum = update_checksum (blob_data, blob_size, is_foreign_endianness); // compute old checksum
    free (blob_data);
    // rewrite image trailer with final checksum values
    fseek (fp, imgtrailer_offset, SEEK_SET);
    fwrite (&image_trailer, sizeof (image_trailer), 1, fp); // write image trailer
+}
 static int dump_ifs_info (const char *ifs_pathname)
+{
+   #define hex_printf(buf,size,...) do { \
+      if ((size) <= 16 * 1024) /* only print when it's not too big (up to 16 kb) */\
-   #define hex_printf(buf,size,...) hex_fprintf (stdout, (buf), (size), 16, __VA_ARGS__) // use 16 columns in hex output to stdout
+         hex_fprintf (stdout, (buf), (size), 16, __VA_ARGS__); /* use 16 columns in hex output to stdout */ \
+      else { \
+         printf (__VA_ARGS__); \
+         printf ("   size %zd > 16kb, not printed\n", (size_t) (size)); \
+      } \
+   } while (0)
    #define BINARY(x) binary ((x), '-', 'x')
    static const char *startupheader_flags1_strings[8] = {
       "VIRTUAL", // bit 0
       "BIGENDIAN", // bit 1
          hex_printf ((uint8_t *) &startup_header->info[0], sizeof (startup_header->info), "   info[48] =\n");
          // validate that the file can contain up to the startup trailer
          if (current_offset + startup_header->startup_size > filesize)
+         {
-            fprintf (stderr, "WARNING: this IFS file is too short (startup trailer would be past end of file)\n");
+            printf ("WARNING: this IFS file is corrupted (startup trailer extends past end of file)\n");
-            break;
+            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__)))
          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 (0, &filedata[current_offset], startupfile_blobsize, is_foreign_endianness));
+         printf ("   checksum %d\n", update_checksum (&filedata[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, (size_t) ((uint8_t *) startup_trailer_v2 - (uint8_t *) startup_header), NULL));
             recorded_checksum = startup_trailer_v2->cksum;
-            computed_checksum = update_checksum (0, startup_header, sizeof (startup_header_t) + startupfile_blobsize + SHA512_DIGEST_LENGTH, is_foreign_endianness);
+            computed_checksum = update_checksum (startup_header, sizeof (startup_header_t) + startupfile_blobsize + SHA512_DIGEST_LENGTH, is_foreign_endianness);
             printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (strcasecmp (computed_sha512, recorded_sha512) != 0)
                printf ("Computed SHA-512: %s\n", computed_sha512);
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          else // old v1 trailer
+         {
             recorded_checksum = startup_trailer_v1->cksum;
-            computed_checksum = update_checksum (0, startup_header, sizeof (startup_header) + startupfile_blobsize, is_foreign_endianness);
+            computed_checksum = update_checksum (startup_header, sizeof (startup_header) + startupfile_blobsize, is_foreign_endianness);
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_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 > filesize)
+         {
-            fprintf (stderr, "WARNING: this IFS file is too short (image trailer would be past end of file)\n");
+            printf ("WARNING: this IFS file is corrupted (image trailer extends past end of file)\n");
-            break;
+            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__)))
             fsentries[fsentry_count] = current_fsentry;
             fsentry_count++;
             printf ("\n");
             printf ("Filesystem entry at offset 0x%zx (%zd) - last one at 0x%zd (%zd):\n", current_offset, current_offset, imageheader_offset + image_header->hdr_dir_size, imageheader_offset + image_header->hdr_dir_size);
-            printf ("   size           = 0x%04x (%d) - size of dirent - %s\n", current_fsentry->header.size, current_fsentry->header.size, (current_offset + current_fsentry->header.size < filesize ? "looks good" : "BAD"));
+            printf ("   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 < filesize) ? "looks good" : "BAD"));
             printf ("   extattr_offset = 0x%04x (%d) - %s\n", current_fsentry->header.extattr_offset, current_fsentry->header.extattr_offset, (current_fsentry->header.extattr_offset == 0 ? "no extattr" : "has extattr"));
             printf ("   ino            = 0x%08x (%d) - inode number (%s%s%s%s)\n", current_fsentry->header.ino, current_fsentry->header.ino, (current_fsentry->header.ino & 0xE0000000 ? "is" : "nothing special"), (current_fsentry->header.ino & IFS_INO_PROCESSED_ELF ? " PROCESSED_ELF" : ""), (current_fsentry->header.ino & IFS_INO_RUNONCE_ELF ? " RUNONCE_ELF" : ""), (current_fsentry->header.ino & IFS_INO_BOOTSTRAP_EXE ? " BOOTSTRAP_EXE" : ""));
             printf ("   mode           = 0x%08x (%d) - %s (0%o), POSIX permissions 0%o\n", current_fsentry->header.mode, current_fsentry->header.mode, (S_ISDIR (current_fsentry->header.mode) ? "directory" : (S_ISREG (current_fsentry->header.mode) ? "file" : (S_ISLNK (current_fsentry->header.mode) ? "symlink" : "device"))), (current_fsentry->header.mode & 0xF000) >> 12, current_fsentry->header.mode & 0xFFF);
             printf ("   gid            = 0x%08x (%d) - owner group ID%s\n", current_fsentry->header.gid, current_fsentry->header.gid, (current_fsentry->header.gid == 0 ? " (root)" : ""));
             printf ("   uid            = 0x%08x (%d) - owner user ID%s\n", current_fsentry->header.uid, current_fsentry->header.uid, (current_fsentry->header.uid == 0 ? " (root)" : ""));
             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 >= filesize))
+            {
+               printf ("WARNING: this IFS file is corrupted (the size of this directory entry is invalid)\n");
+               goto endofdata;
+            }
             current_offset += current_fsentry->header.size;
+         }
          if (imageheader_offset + image_header->hdr_dir_size < current_offset + sizeof (current_fsentry->header))
                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 < filesize)
+               {
+                  if ((current_fsentry->u.file.size < 1024) && (current_offset + current_fsentry->u.file.size < filesize))
+                     hex_printf (&filedata[current_offset], current_fsentry->u.file.size, "   data:\n");
+                  else
-               printf ("   first 4 bytes: %02x%02x%02x%02x \"%c%c%c%c\" (%s)\n", (uint8_t) filedata[current_offset + 0], (uint8_t) filedata[current_offset + 1], (uint8_t) filedata[current_offset + 2], (uint8_t) filedata[current_offset + 3], (isprint (filedata[current_offset + 0]) ? filedata[current_offset + 0] : '.'), (isprint (filedata[current_offset + 1]) ? filedata[current_offset + 1] : '.'), (isprint (filedata[current_offset + 2]) ? filedata[current_offset + 2] : '.'), (isprint (filedata[current_offset + 3]) ? filedata[current_offset + 3] : '.'), (memcmp (&filedata[current_offset], "\x7f" "ELF", 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "data file")));
+                     printf ("   first 4 bytes: %02x%02x%02x%02x \"%c%c%c%c\" (%s)\n", (uint8_t) filedata[current_offset + 0], (uint8_t) filedata[current_offset + 1], (uint8_t) filedata[current_offset + 2], (uint8_t) filedata[current_offset + 3], (isprint (filedata[current_offset + 0]) ? filedata[current_offset + 0] : '.'), (isprint (filedata[current_offset + 1]) ? filedata[current_offset + 1] : '.'), (isprint (filedata[current_offset + 2]) ? filedata[current_offset + 2] : '.'), (isprint (filedata[current_offset + 3]) ? filedata[current_offset + 3] : '.'), (memcmp (&filedata[current_offset], ELF_MAGIC_STR, 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "data file")));
+               }
+               if (current_offset + current_fsentry->u.file.size < filesize)
-               printf ("   checksum %d\n", update_checksum (0, &filedata[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
+                  printf ("   checksum %d\n", update_checksum (&filedata[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
+               else
+               {
+                  printf ("WARNING: this IFS file is corrupted (the size of this file data extends past the IFS size)\n");
+                  goto endofdata;
+               }
                current_offset += current_fsentry->u.file.size; // now jump over this file's data
+            }
+         }
+         {
             for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)
                sprintf (&recorded_sha512[2 * byte_index], "%02x", image_trailer_v2->sha512[byte_index]);
             strcpy (computed_sha512, SHA512 (image_header, (size_t) ((uint8_t *) image_trailer_v2 - (uint8_t *) image_header), NULL));
             recorded_checksum = image_trailer_v2->cksum;
-            computed_checksum = update_checksum (0, image_header, image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH, is_foreign_endianness);
+            computed_checksum = update_checksum (image_header, image_header->image_size - sizeof (image_trailer_v2_t) + SHA512_DIGEST_LENGTH, is_foreign_endianness);
             printf ("    sha512 = %s - %s\n", recorded_sha512, (strcasecmp (computed_sha512, recorded_sha512) == 0 ? "GOOD" : "BAD"));
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (strcasecmp (computed_sha512, recorded_sha512) != 0)
                printf ("Computed SHA-512: %s\n", computed_sha512);
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
          else // old v1 trailer
+         {
             recorded_checksum = image_trailer_v1->cksum;
-            computed_checksum = update_checksum (0, image_header, image_header->image_size - sizeof (image_trailer_v1_t), is_foreign_endianness);
+            computed_checksum = update_checksum (image_header, image_header->image_size - sizeof (image_trailer_v1_t), is_foreign_endianness);
             printf ("    cksum = 0x%08x (%d) - %s\n", recorded_checksum, recorded_checksum, (computed_checksum == recorded_checksum ? "GOOD" : "BAD"));
             if (computed_checksum != recorded_checksum)
                printf ("Computed cksum: 0x%08x (%d)\n", computed_checksum, computed_checksum);
+         }
             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 (0, &filedata[current_offset], bootfile_blobsize, false)); // NOTE: endianness is not known yet -- assume same
+         printf ("   checksum 0x%08x\n", update_checksum (&filedata[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 < filesize)
+   {
       printf ("End of identifiable data reached.\n");
-      if (filesize - current_offset < 16384)
-         hex_printf (&filedata[current_offset], filesize - current_offset, "\n" "%zd extra bytes at offset %zx (%zd):\n", filesize - current_offset, current_offset, current_offset);
+      hex_printf (&filedata[current_offset], filesize - current_offset, "\n" "%zd extra bytes at offset %zx (%zd):\n", filesize - current_offset, current_offset, current_offset);
-      else
-         printf ("\n" "%zd extra bytes at offset %zx (%zd) - size > 16k, not printed\n", filesize - current_offset, current_offset, current_offset);
+   }
    printf ("End of file reached at offset 0x%zx (%zd)\n", filesize, filesize);
    printf ("IFS dissecation complete.\n");
    return (0);

Subversion Repositories QNX 8.QNX8 IFS tool

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