Subversion Repositories QNX 8.QNX8 IFS tool

// ifstool.c -- portable reimplementation of QNX's mkifs by Pierre-Marie Baty <pm@pmbaty.com>

// TODO: preboot file stripping

// TODO: startup file stripping

// TODO: kernel file stripping

// TODO: boot script compiler

#include <stdint.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <sys/stat.h>

#include <ctype.h>

#include <time.h>

// compiler-specific glue

#ifdef _MSC_VER

#include <io.h>

#include <direct.h>

#include <sys/utime.h>

#define __x86_64__ 1

#define __ORDER_BIG_ENDIAN__    4321

#define __ORDER_LITTLE_ENDIAN__ 1234

#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

#define __attribute__(x)

#define __builtin_bswap16(x) _byteswap_ushort ((unsigned short) (x))

#define __builtin_bswap32(x) _byteswap_ulong ((unsigned long) (x))

#define __builtin_bswap64(x) _byteswap_uint64 ((unsigned long long) (x))

#define S_IFIFO 0x1000

#define S_IFLNK 0xa000

#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)

#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)

#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)

#define strdup(s) _strdup ((s))

#define strcasecmp(s1,s2) _stricmp ((s1), (s2))

#define fseek(fp,off,m) _fseeki64 ((fp), (off), (m))

#define access(p,m) _access ((p), (m))

#define mkdir(p,m) _mkdir ((p))

#define chmod(p,m) _chmod ((p), (m))

#define utimbuf __utimbuf32

#define utime(p,t) _utime32 ((p), (t))

#define MAXPATHLEN 1024

#ifndef thread_local

#define thread_local __declspec(thread) // the thread_local keyword wasn't defined before C++11 and C23

#endif // !thread_local

#define START_OF_PACKED_STRUCT() __pragma(pack(push)) __pragma(pack(1))

#define END_OF_PACKED_STRUCT() __pragma(pack(pop))

#define PACKED(thing) thing

#else // !_MSC_VER

#include <sys/param.h>

#include <unistd.h>

#include <utime.h>

#ifndef thread_local

#define thread_local __thread // the thread_local keyword wasn't defined before C++11 and C23

#endif // !thread_local

#define START_OF_PACKED_STRUCT()

#define END_OF_PACKED_STRUCT()

#define PACKED(thing) thing __attribute__((packed))

#endif // _MSC_VER

// handy macros that generate a version number in the format "YYYYMMDD" corresponding to the build date. Usage: printf ("version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);

#ifndef VERSION_ARG_YYYYMMDD

#define BUILDDATE_YEAR  (&__DATE__[7]) // compiler will optimize this into a const string, e.g. "2021"

#define BUILDDATE_MONTH ( \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Jan ") ? "01" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Feb ") ? "02" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Mar ") ? "03" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Apr ") ? "04" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "May ") ? "05" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Jun ") ? "06" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Jul ") ? "07" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Aug ") ? "08" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Sep ") ? "09" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Oct ") ? "10" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Nov ") ? "11" : \

   *((uint32_t *) __DATE__) == *((uint32_t *) "Dec ") ? "12" : \

   "XX" \

) // compiler will optimize this into a const string, e.g. "11"

#define BUILDDATE_DAY ( \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  1 ") ? "01" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  2 ") ? "02" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  3 ") ? "03" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  4 ") ? "04" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  5 ") ? "05" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  6 ") ? "06" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  7 ") ? "07" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  8 ") ? "08" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) "  9 ") ? "09" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 10 ") ? "10" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 11 ") ? "11" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 12 ") ? "12" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 13 ") ? "13" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 14 ") ? "14" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 15 ") ? "15" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 16 ") ? "16" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 17 ") ? "17" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 18 ") ? "18" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 19 ") ? "19" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 20 ") ? "20" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 21 ") ? "21" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 22 ") ? "22" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 23 ") ? "23" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 24 ") ? "24" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 25 ") ? "25" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 26 ") ? "26" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 27 ") ? "27" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 28 ") ? "28" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 29 ") ? "29" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 30 ") ? "30" : \

   *((uint32_t *) &__DATE__[3]) == *((uint32_t *) " 31 ") ? "31" : \

   "XX" \

) // compiler will optimize this into a const string, e.g. "14"

#define VERSION_FMT_YYYYMMDD "%s%s%s"

#define VERSION_ARG_YYYYMMDD BUILDDATE_YEAR, BUILDDATE_MONTH, BUILDDATE_DAY

#endif // !VERSION_ARG_YYYYMMDD

// macro to bring __FILE_NAME__ support to moronic compilers

#ifndef __FILE_NAME__ // Clang 9+ has the macro, GCC 12+ added it too in 2021, MSVC obviously won't do it. Heh.

#define __FILE_NAME__ ( \

   (sizeof (__FILE__) >  2) && (__FILE__[sizeof (__FILE__) -  2] == '/') ? &__FILE__[sizeof (__FILE__) -  1] : \

   (sizeof (__FILE__) >  3) && (__FILE__[sizeof (__FILE__) -  3] == '/') ? &__FILE__[sizeof (__FILE__) -  2] : \

   (sizeof (__FILE__) >  4) && (__FILE__[sizeof (__FILE__) -  4] == '/') ? &__FILE__[sizeof (__FILE__) -  3] : \

   (sizeof (__FILE__) >  5) && (__FILE__[sizeof (__FILE__) -  5] == '/') ? &__FILE__[sizeof (__FILE__) -  4] : \

   (sizeof (__FILE__) >  6) && (__FILE__[sizeof (__FILE__) -  6] == '/') ? &__FILE__[sizeof (__FILE__) -  5] : \

   (sizeof (__FILE__) >  7) && (__FILE__[sizeof (__FILE__) -  7] == '/') ? &__FILE__[sizeof (__FILE__) -  6] : \

   (sizeof (__FILE__) >  8) && (__FILE__[sizeof (__FILE__) -  8] == '/') ? &__FILE__[sizeof (__FILE__) -  7] : \

   (sizeof (__FILE__) >  9) && (__FILE__[sizeof (__FILE__) -  9] == '/') ? &__FILE__[sizeof (__FILE__) -  8] : \

   (sizeof (__FILE__) > 10) && (__FILE__[sizeof (__FILE__) - 10] == '/') ? &__FILE__[sizeof (__FILE__) -  9] : \

   (sizeof (__FILE__) > 11) && (__FILE__[sizeof (__FILE__) - 11] == '/') ? &__FILE__[sizeof (__FILE__) - 10] : \

   (sizeof (__FILE__) > 12) && (__FILE__[sizeof (__FILE__) - 12] == '/') ? &__FILE__[sizeof (__FILE__) - 11] : \

   (sizeof (__FILE__) > 13) && (__FILE__[sizeof (__FILE__) - 13] == '/') ? &__FILE__[sizeof (__FILE__) - 12] : \

   (sizeof (__FILE__) > 14) && (__FILE__[sizeof (__FILE__) - 14] == '/') ? &__FILE__[sizeof (__FILE__) - 13] : \

   (sizeof (__FILE__) > 15) && (__FILE__[sizeof (__FILE__) - 15] == '/') ? &__FILE__[sizeof (__FILE__) - 14] : \

   (sizeof (__FILE__) > 16) && (__FILE__[sizeof (__FILE__) - 16] == '/') ? &__FILE__[sizeof (__FILE__) - 15] : \

   (sizeof (__FILE__) > 17) && (__FILE__[sizeof (__FILE__) - 17] == '/') ? &__FILE__[sizeof (__FILE__) - 16] : \

   (sizeof (__FILE__) > 18) && (__FILE__[sizeof (__FILE__) - 18] == '/') ? &__FILE__[sizeof (__FILE__) - 17] : \

   (sizeof (__FILE__) > 19) && (__FILE__[sizeof (__FILE__) - 19] == '/') ? &__FILE__[sizeof (__FILE__) - 18] : \

   (sizeof (__FILE__) > 20) && (__FILE__[sizeof (__FILE__) - 20] == '/') ? &__FILE__[sizeof (__FILE__) - 19] : \

   (sizeof (__FILE__) > 21) && (__FILE__[sizeof (__FILE__) - 21] == '/') ? &__FILE__[sizeof (__FILE__) - 20] : \

   (sizeof (__FILE__) > 22) && (__FILE__[sizeof (__FILE__) - 22] == '/') ? &__FILE__[sizeof (__FILE__) - 21] : \

   (sizeof (__FILE__) > 23) && (__FILE__[sizeof (__FILE__) - 23] == '/') ? &__FILE__[sizeof (__FILE__) - 22] : \

   (sizeof (__FILE__) > 24) && (__FILE__[sizeof (__FILE__) - 24] == '/') ? &__FILE__[sizeof (__FILE__) - 23] : \

   (sizeof (__FILE__) > 25) && (__FILE__[sizeof (__FILE__) - 25] == '/') ? &__FILE__[sizeof (__FILE__) - 24] : \

   (sizeof (__FILE__) > 26) && (__FILE__[sizeof (__FILE__) - 26] == '/') ? &__FILE__[sizeof (__FILE__) - 25] : \

   (sizeof (__FILE__) > 27) && (__FILE__[sizeof (__FILE__) - 27] == '/') ? &__FILE__[sizeof (__FILE__) - 26] : \

   (sizeof (__FILE__) > 28) && (__FILE__[sizeof (__FILE__) - 28] == '/') ? &__FILE__[sizeof (__FILE__) - 27] : \

   (sizeof (__FILE__) > 29) && (__FILE__[sizeof (__FILE__) - 29] == '/') ? &__FILE__[sizeof (__FILE__) - 28] : \

   (sizeof (__FILE__) > 30) && (__FILE__[sizeof (__FILE__) - 30] == '/') ? &__FILE__[sizeof (__FILE__) - 29] : \

   (sizeof (__FILE__) > 31) && (__FILE__[sizeof (__FILE__) - 31] == '/') ? &__FILE__[sizeof (__FILE__) - 30] : \

   (sizeof (__FILE__) > 32) && (__FILE__[sizeof (__FILE__) - 32] == '/') ? &__FILE__[sizeof (__FILE__) - 31] : \

   (sizeof (__FILE__) > 33) && (__FILE__[sizeof (__FILE__) - 33] == '/') ? &__FILE__[sizeof (__FILE__) - 32] : \

   __FILE__) // this *COMPILE-TIME* macro complements the __FILE__ macro defined by the C standard by returning just the filename portion of the full path. Supports filenames up to 32 chars. Expand as necessary.

#endif // !__FILE_NAME__

// macro to exit less brutally than with abort() if something doesn't go the way we'd like to

#define WELLMANNERED_ASSERT(is_is_true,...) do { if (!(is_is_true)) { fprintf (stderr, "ifstool: fatal error: consistency check in %s() at %s line %d failed: ", __FUNCTION__, __FILE_NAME__, __LINE__); fprintf (stderr, __VA_ARGS__); fputc ('\n', stderr); exit (1); } } while (0)

// macros for checked read/write/seek operations

#define fseek_or_die(fp,pos,mode) WELLMANNERED_ASSERT (fseek ((fp), (pos), (mode)) == 0, "fseek() failed with errno %d (%s)", errno, strerror (errno))

#define fread_or_die(buf,sz,len,fp) WELLMANNERED_ASSERT (fread ((buf), (sz), (len), (fp)) == (len), "fread() failed with errno %d (%s)", errno, strerror (errno))

#define fwrite_or_die(buf,sz,len,fp) WELLMANNERED_ASSERT ((fwrite ((buf), (sz), (len), (fp)) == (len)) && (fflush ((fp)) == 0), "flushed fwrite() failed with errno %d (%s)", errno, strerror (errno))

// macros for accessing ELF files

#define ELF_MAGIC_STR "\x7f" "ELF"

#define ELF_ENDIAN_LITTLE 1 // 'endianness' member of an ELF header: ELF file is little endian

#define ELF_ENDIAN_BIG    2 // 'endianness' member of an ELF header: ELF file is big endian

#define ELF_MACHINE_X86_64  0x3e // 'instruction_set' member of an ELF header, also used in the IFS startup header: ELF file is for x86_64 processors (62 decimal)

#define ELF_MACHINE_AARCH64 0xb7 // 'instruction_set' member of an ELF header, also used in the IFS startup header: ELF file is for ARM64 processors (183 decimal)

#define ELF_SECTIONTYPE_STRINGTABLE 3

#define ELF_DT_NULL    0 // marks end of dynamic section

#define ELF_DT_SONAME 14 // canonical name of shared object

#define ELF_GET_NUMERIC(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \

   ( \

      (sizeof ((elfstruct)->u.elf64.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \

         (elfstruct)->u.elf64.member /* same endianness, or single byte required: don't swap */ \

      : /* else */ \

         (sizeof ((elfstruct)->u.elf64.member) == 8 ? __builtin_bswap64 ((elfstruct)->u.elf64.member) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? __builtin_bswap32 ((elfstruct)->u.elf64.member) : __builtin_bswap16 ((elfstruct)->u.elf64.member))) /* different endianness: swap */ \

   ) \

   : /* else peek at 32-bit ELF */ \

   ( \

      (sizeof ((elfstruct)->u.elf32.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \

         (elfstruct)->u.elf32.member /* same endianness, or single byte required: don't swap */ \

      : /* else */ \

         (sizeof ((elfstruct)->u.elf32.member) == 4 ? __builtin_bswap32 ((elfstruct)->u.elf32.member) : __builtin_bswap16 ((elfstruct)->u.elf32.member)) /* different endianness: swap */ \

   ) \

) // this macro supports 32- and 64-bit ELF files in low and big endianness transparently

#define ELF_SET_NUMERIC(elfhdr,elfstruct,member,data) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \

   ((elfstruct)->u.elf64.member = ( \

      (sizeof ((elfstruct)->u.elf64.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \

         (sizeof ((elfstruct)->u.elf64.member) == 8 ? (uint64_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? (uint32_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 2 ? (uint16_t) ((data)) : (uint8_t) ((data))))) /* same endianness, or single byte required: don't swap */ \

      : /* else */ \

         (sizeof ((elfstruct)->u.elf64.member) == 8 ? __builtin_bswap64 ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? __builtin_bswap32 ((data)) : __builtin_bswap16 ((data)))) /* different endianness: swap */ \

   )) \

   : /* else poke at 32-bit ELF */ \

   ((elfstruct)->u.elf32.member = ( \

      (sizeof ((elfstruct)->u.elf32.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \

         (sizeof ((elfstruct)->u.elf64.member) == 4 ? (uint32_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 2 ? (uint16_t) ((data)) : (uint8_t) ((data)))) /* same endianness, or single byte required: don't swap */ \

      : /* else */ \

         (sizeof ((elfstruct)->u.elf32.member) == 4 ? __builtin_bswap32 ((data)) : __builtin_bswap16 ((data))) /* different endianness: swap */ \

   )) \

) // this macro supports 32- and 64-bit ELF files in low and big endianness transparently

#define ELF_GET_STRING(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member) // this macro supports 32- and 64-bit ELF files transparently

#define ELF_SET_STRING(elfhdr,elfstruct,member,data,len) memcpy (((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member), (data), (len)) // this macro supports 32- and 64-bit ELF files transparently

#define ELF_STRUCT_SIZE(elfhdr,elfstruct) ((elfhdr)->u.elf.platform_size == 2 ? sizeof ((elfstruct)->u.elf64) : sizeof ((elfstruct)->u.elf32)) // this macro supports 32- and 64-bit ELF files transparently

// placeholder value

#define WILL_BE_FILLED_LATER 0xbaadf00d // urgh

// bitmapped flags used in the flags1 member of the startup header

#define STARTUP_HDR_FLAGS1_VIRTUAL        (1 << 0)

#define STARTUP_HDR_FLAGS1_BIGENDIAN      (1 << 1)

//#define STARTUP_HDR_FLAGS1_COMPRESS_MASK  0x1c

//#define STARTUP_HDR_FLAGS1_COMPRESS_SHIFT 0x02

//#define STARTUP_HDR_FLAGS1_COMPRESS_NONE  0x00

//#define STARTUP_HDR_FLAGS1_COMPRESS_ZLIB  0x04

//#define STARTUP_HDR_FLAGS1_COMPRESS_LZO   0x08

//#define STARTUP_HDR_FLAGS1_COMPRESS_UCL   0x0c

#define STARTUP_HDR_FLAGS1_TRAILER_V2     (1 << 5) // if set, then a struct startup_trailer_v2 follows the startup. If the image is compressed, then the compressed imagefs is followed by a struct image_trailer_v2

// bitmapped flags used in the flags member of the image header

#define IMAGE_FLAGS_BIGENDIAN  (1 << 0) // header, trailer, dirents in big-endian format

#define IMAGE_FLAGS_READONLY   (1 << 1) // do not try to write to image (rom/flash)

#define IMAGE_FLAGS_INO_BITS   (1 << 2) // inode bits valid

#define IMAGE_FLAGS_SORTED     (1 << 3) // dirent section is sorted (by pathname)

#define IMAGE_FLAGS_TRAILER_V2 (1 << 4) // image uses struct image_trailer_v2

// bitmapped flags superposed to a filesystem entry's inode number

#define IFS_INO_PROCESSED_ELF 0x80000000

#define IFS_INO_RUNONCE_ELF   0x40000000

#define IFS_INO_BOOTSTRAP_EXE 0x20000000

// miscellaneous macros

#define ROUND_TO_UPPER_MULTIPLE(val,multiple) ((((val) + (size_t) (multiple) - 1) / (multiple)) * (multiple)) // note that val is being evaluated once, so it can be the result of a function call

#ifdef _WIN32

#define IS_DIRSEP(c) (((c) == '/') || ((c) == '\\')) // platform-specific directory separator, Win32 variant

#define PATH_SEP ';' // platform-specific PATH element separator, Win32 variant

#define PATH_SEP_STR ";" // platform-specific PATH element separator (as string), Win32 variant

#else // !_WIN32, thus POSIX

#define IS_DIRSEP(c) ((c) == '/') // platform-specific directory separator, UNIX variant

#define PATH_SEP ':' // platform-specific PATH element separator, UNIX variant

#define PATH_SEP_STR ":" // platform-specific PATH element separator (as string), UNIX variant

#endif // _WIN32

#define RECORD_SEP '\x1e' // arbitrarily-chosen ASCII record separator

#define RECORD_SEP_STR "\x1e" // arbitrarily-chosen ASCII record separator (as string)

// SHA-512 block and digest sizes

#define SHA512_BLOCK_LENGTH 128 // in bytes

#define SHA512_DIGEST_LENGTH 64 // in bytes

// SHA-512 computation context structure type definition

typedef struct sha512_ctx_s

{

   uint64_t state[8];

   uint64_t bitcount[2];

   uint8_t buffer[SHA512_BLOCK_LENGTH];

} SHA512_CTX;

#if 0 // TODO: startup script compiler. Someday.

#define SCRIPT_FLAGS_EXTSCHED   0x01

#define SCRIPT_FLAGS_SESSION    0x02

#define SCRIPT_FLAGS_SCHED_SET  0x04

#define SCRIPT_FLAGS_CPU_SET    0x08

#define SCRIPT_FLAGS_BACKGROUND 0x20

#define SCRIPT_FLAGS_KDEBUG     0x40

#define SCRIPT_POLICY_NOCHANGE 0

#define SCRIPT_POLICY_FIFO     1

#define SCRIPT_POLICY_RR       2

#define SCRIPT_POLICY_OTHER    3

#define SCRIPT_TYPE_EXTERNAL        0

#define SCRIPT_TYPE_WAITFOR         1

#define SCRIPT_TYPE_REOPEN          2

#define SCRIPT_TYPE_DISPLAY_MSG     3

#define SCRIPT_TYPE_PROCMGR_SYMLINK 4

#define SCRIPT_TYPE_EXTSCHED_APS    5

#define SCRIPT_CHECKS_MS 100

#define SCRIPT_SCHED_EXT_NONE 0

#define SCRIPT_SCHED_EXT_APS  1

#define SCRIPT_APS_SYSTEM_PARTITION_ID   0

#define SCRIPT_APS_SYSTEM_PARTITION_NAME "System"

#define SCRIPT_APS_PARTITION_NAME_LENGTH 15

#define SCRIPT_APS_MAX_PARTITIONS        8

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) bootscriptcmd_header_s

{

   uint16_t size; // size of cmd entry

   uint8_t type;

   uint8_t spare;

} bootscriptcmd_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef union bootscriptcmd_s

{

   PACKED (struct) script_external

   {

      bootscriptcmd_header_t hdr;

      uint8_t cpu; // CPU (turn into runmask)

      uint8_t flags;

      union script_external_extsched

      {

         uint8_t reserved[2];

         PACKED (struct)

         {

            uint8_t id;

            uint8_t reserved[1];

         } aps;

      } extsched; // extended scheduler

      uint8_t policy; // POLICY_FIFO, POLICY_RR, ...

      uint8_t priority; // priority to run cmd at

      uint8_t argc; // # of args

      uint8_t envc; // # of environment entries

      char args[0]; // executable, argv, envp (null padded to 32-bit align)

   } external;

   PACKED (struct) script_waitfor_reopen

   {

      bootscriptcmd_header_t hdr;

      uint16_t checks;

      char fname[0]; // char fname[] (null padded to 32-bit align)

   } waitfor_reopen;

   PACKED (struct) script_display_msg

   {

      bootscriptcmd_header_t hdr;

      char msg[0]; // char msg[] (null padded to 32-bit align)

   } display_msg;

   PACKED (struct) script_procmgr_symlink

   {

      bootscriptcmd_header_t hdr;

      char src_dest[0]; // <src_name>, '\0', <dest_name> '\0' (null padded to 32-bit align)

   } procmgr_symlink;

   PACKED (struct) script_extsched_aps

   {

      bootscriptcmd_header_t hdr;

      uint8_t parent;

      uint8_t budget;

      uint16_t critical;

      uint8_t id;

      char pname[0]; // char pname[] (null padded to 32-bit align)

   } extsched_aps;

} bootscriptcmd_t;

END_OF_PACKED_STRUCT () // restore default alignment

#endif // 0

#define INITIAL_STARTUP_SCRIPT \

   /* procmgr_symlink /proc/boot/ldqnx-64.so.2 /usr/lib/ldqnx-64.so.2 */ \

   "\x34\x00" /*size*/ "\x04" /*type*/ "\x00" /*spare*/ "/proc/boot/ldqnx-64.so.2\0" "/usr/lib/ldqnx-64.so.2\0" \

   /* 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 */ \

   "\x00\x00\x00\x00"

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) fsentry_s

{

   PACKED (struct) fsentry_header_s

   {

      uint16_t size; // size of dirent

      uint16_t extattr_offset; // if zero, no extattr data

      uint32_t ino; // if zero, skip entry

      uint32_t mode; // mode and perms of entry

      uint32_t gid;

      uint32_t uid;

      uint32_t mtime;

   } header;

   PACKED (union) fsentry_specific_u

   {

      PACKED (struct) fsentry_file_s // when (mode & S_IFMT) == S_IFREG

      {

         uint32_t offset; // offset from header

         uint32_t size;

         char *path; // null terminated path (no leading slash)

         char *UNSAVED_databuf; // file data blob buffer (NOT SAVED IN THE IFS)

      } file;

      PACKED (struct) fsentry_dir_s // when (mode & S_IFMT) == S_IFDIR

      {

         char *path; // null terminated path (no leading slash)

      } dir;

      PACKED (struct) fsentry_symlink_s // when (mode & S_IFMT) == S_IFLNK

      {

         uint16_t sym_offset; // offset to 'contents' from 'path'

         uint16_t sym_size; // strlen (contents)

         char *path; // null terminated path (no leading slash)

         char *contents; // null terminated symlink contents

      } symlink;

      PACKED (struct) fsentry_device_s // when (mode & S_IFMT) == S_IF<CHR|BLK|FIFO|NAM|SOCK>

      {

         uint32_t dev;

         uint32_t rdev;

         char *path; // null terminated path (no leading slash)

      } device;

   } u;

   bool UNSAVED_was_data_written; // whether this entry's data was written to the image (NOT SAVED IN THE IFS)

} fsentry_t;

END_OF_PACKED_STRUCT () // restore default alignment

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) startup_header_s // size 256 bytes

{

   // I - used by the QNX IPL

   // S - used by the startup program

   uint8_t signature[4];   // [I ] Header signature, "\xeb\x7e\xff\x00"

   uint16_t version;       // [I ] Header version, i.e. 1

   uint8_t flags1;         // [IS] Misc flags, 0x21 (= 0x20 | STARTUP_HDR_FLAGS1_VIRTUAL)

   uint8_t flags2;         // [  ] No flags defined yet (0)

   uint16_t header_size;   // [ S] sizeof(struct startup_header), i.e. 256

   uint16_t machine;       // [IS] Machine type from elfdefinitions.h, i.e. 0x003E --> _ELF_DEFINE_EM(EM_X86_64, 62, "AMD x86-64 architecture")

   uint32_t startup_vaddr; // [I ] Virtual Address to transfer to after IPL is done, here 0x01403008 (appears in "Entry" column for "startup.*")

   uint32_t paddr_bias;    // [ S] Value to add to physical address to get a value to put into a pointer and indirected through, here 0 (no indirections)

   uint32_t image_paddr;   // [IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)

   uint32_t ram_paddr;     // [IS] Physical address of RAM to copy image to (startup_size bytes copied), here 0x01400f30 (same as above)

   uint32_t ram_size;      // [ S] Amount of RAM used by the startup program and executables contained in the file system, here 0x00cd6128 i.e. 13 459 752 dec. which is 13 Mb. i.e. IFS file size minus 0x9eee

   uint32_t startup_size;  // [I ] Size of startup (never compressed), here 0x02f148 or 192 840 bytes

   uint32_t stored_size;   // [I ] Size of entire image, here 0x00cd6128 (same as ram_size)

   uint32_t imagefs_paddr; // [IS] Set by IPL to where the imagefs is when startup runs (0)

   uint32_t imagefs_size;  // [ S] Size of uncompressed imagefs, here 0x00ca6fe0 or 13 266 912 bytes

   uint16_t preboot_size;  // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))

   uint16_t zero0;         // [  ] Zeros

   uint32_t zero[1];       // [  ] Zeros

   uint64_t addr_off;      // [ S] Offset to add to startup_vaddr, image_paddr, ram_paddr, and imagefs_paddr members, here zero (0)

   uint32_t info[48];      // [IS] Array of startup_info* structures (zero filled)

} startup_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) startup_trailer_s

{

   uint32_t cksum; // checksum from start of header to start of trailer

} startup_trailer_v1_t;

END_OF_PACKED_STRUCT () // restore default alignment

// NOTE: The checksums in this trailer will only be valid prior to entering startup.

// Because the startup binary is executed in-place, its data segment will change once the program is running.

// Hence, any checksum validation would need to be done by the boot loader / IFS.

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) startup_trailer_v2_s

{

   uint8_t sha512[64]; // SHA512 from start of header to start of trailer

   uint32_t cksum; // checksum from start of header to start of this member

} startup_trailer_v2_t;

END_OF_PACKED_STRUCT () // restore default alignment

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) image_header_s

{

   uint8_t signature[7]; // image filesystem signature, i.e. "imagefs"

   uint8_t flags; // endian neutral flags, 0x1c

   uint32_t image_size; // size from start of header to end of trailer (here 0xca6fe0 or 13 266 912)

   uint32_t hdr_dir_size; // size from start of header to last dirent (here 0x12b8 or 4792)

   uint32_t dir_offset; // offset from start of header to start of first dirent (here 0x5c or 92)

   uint32_t boot_ino[4]; // inode of files for bootstrap pgms (here 0xa0000002, 0, 0, 0)

   uint32_t script_ino; // inode of file for script (here 3)

   uint32_t chain_paddr; // offset to next filesystem signature (0)

   uint32_t spare[10]; // zerofill

   uint32_t mountflags; // default _MOUNT_* from sys/iomsg.h (0)

   char mountpoint[4]; // default mountpoint for image ("/" + "\0\0\0")

} image_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) image_trailer_v1_s

{

   uint32_t cksum; // checksum from start of header to start of trailer

} image_trailer_v1_t; // NOTE: this is the same structure as startup_trailer_v1_t

END_OF_PACKED_STRUCT () // restore default alignment

// NOTE: the checksums in this trailer will only be valid until the first non-startup bootstrap binary (e.g., startup-verifier, procnto, ...) is invoked.

// Because bootstrap binaries execute in-place, their data segments will change once the programs are running.

// Hence, any checksum validation would need to be done either by the boot loader / IFS or by the startup.

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) image_trailer_v2_s

{

   uint8_t sha512[64]; // SHA512 from start of image header to start of trailer

   uint32_t cksum; // checksum from start of header to start of this member

} image_trailer_v2_t; // NOTE: this is the same structure as startup_trailer_v2_t

END_OF_PACKED_STRUCT () // restore default alignment

// Executable and Linkable Format master header structure type definition

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) elf_header_s

{

   PACKED (union)

   {

      PACKED (struct)

      {

         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"

         uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

         uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian

         uint8_t header_version;               // offset 6: typically 1

         uint8_t os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

         uint8_t spare[8];                     // offset 8: zeroes

         uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

         uint16_t instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

         uint32_t elf_version;                 // offset 20: typically 1

      } elf;

      PACKED (struct) // size == 52

      {

         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"

         uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

         uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian

         uint8_t header_version;               // offset 6: typically 1

         uint8_t os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

         uint8_t spare[8];                     // offset 8: zeroes

         uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

         uint16_t instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

         uint32_t elf_version;                 // offset 20: typically 1

         uint32_t entrypoint_offset;           // offset 24: offset to program entrypoint

         uint32_t program_header_table_offset; // offset 28: offset to program header table

         uint32_t section_header_table_offset; // offset 32: offset to section header table

         uint32_t flags;                       // offset 36: flags (architecture-dependent, none for x86)

         uint16_t header_size;                 // offset 40: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF -- DO NOT USE sizeof() ON THE elf_header_s STRUCT BECAUSE OF THE UNION! WRITE THE CORRECT SIZE YOURSELF!

         uint16_t program_header_item_size;    // offset 42: size of an entry in the program header table

         uint16_t program_header_table_len;    // offset 44: number of entries in the program header table

         uint16_t section_header_item_size;    // offset 46: size of an entry in the section header table

         uint16_t section_header_table_len;    // offset 48: number of entries in the section header table

         uint16_t section_header_names_idx;    // offset 50: index of the entry in the section header table that contains the section names

      } elf32; // size == 52

      PACKED (struct) // size == 64

      {

         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"

         uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

         uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian

         uint8_t header_version;               // offset 6: typically 1

         uint8_t os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

         uint8_t spare[8];                     // offset 8: zeroes

         uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

         uint16_t instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

         uint32_t elf_version;                 // offset 20: typically 1

         uint64_t entrypoint_offset;           // offset 24: program entry offset

         uint64_t program_header_table_offset; // offset 32: offset to program header table

         uint64_t section_header_table_offset; // offset 40: offset to section header table

         uint32_t flags;                       // offset 48: flags (architecture-dependent, none for x86)

         uint16_t header_size;                 // offset 52: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF

         uint16_t program_header_item_size;    // offset 54: size of an entry in the program header table

         uint16_t program_header_table_len;    // offset 56: number of entries in the program header table

         uint16_t section_header_item_size;    // offset 58: size of an entry in the section header table

         uint16_t section_header_table_len;    // offset 60: number of entries in the section header table

         uint16_t section_header_names_idx;    // offset 62: index of the entry in the section header table that contains the section names

      } elf64; // size == 64

   } u;

} elf_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

// Executable and Linkable Format program header structure type definition

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) elf_program_header_s

{

   PACKED (union)

   {

      PACKED (struct)

      {

         uint32_t segment_type; // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

      } elf;

      PACKED (struct) // size == 32

      {

         uint32_t segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

         uint32_t file_offset;    // offset 4: file offset of this segment

         uint32_t virtual_addr;   // offset 8: virtual address where this segment should be mapped in memory

         uint32_t physical_addr;  // offset 12: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory

         uint32_t size_in_file;   // offset 16: size of this segment in the ELF file (may be zero)

         uint32_t size_in_memory; // offset 20: size of this segment in memory (may be zero)

         uint32_t segment_flags;  // offset 24: bitmap of segment flags (1: executable, 2: writable, 4: readable)

         uint32_t alignment;      // offset 28: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)

      } elf32; // size == 32

      PACKED (struct) // size == 56

      {

         uint32_t segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

         uint32_t segment_flags;  // offset 4: bitmap of segment flags (1: executable, 2: writable, 4: readable)

         uint64_t file_offset;    // offset 8: file offset of this segment

         uint64_t virtual_addr;   // offset 16: virtual address where this segment should be mapped in memory

         uint64_t physical_addr;  // offset 24: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory

         uint64_t size_in_file;   // offset 32: size of this segment in the ELF file (may be zero)

         uint64_t size_in_memory; // offset 40: size of this segment in memory (may be zero)

         uint64_t alignment;      // offset 48: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)

      } elf64; // size == 56

   } u;

} elf_program_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

// Executable and Linkable Format section header structure type definition

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) elf_section_header_s

{

   PACKED (union)

   {

      PACKED (struct)

      {

         uint32_t name_offset; // offset 0: offset in the string table of the name of this section

         uint32_t type;        // offset 4: section type (0: unused, 1: program data, 2: symbols table, 3: strings table, 4: relocs with addends, 5: symbols hash table, 6: dyld info, 7: notes, 8: BSS, 9: relocs without addends, 11: dyld symbols table, 14: constructors, 15: destructors, 16, preconstructors, 17: group, 18: extended section indices, 19: number of typedefs ...)

      } elf;

      PACKED (struct) // size == 40

      {

         uint32_t name_offset;  // offset 0: offset in the string table of the name of this section

         uint32_t type;         // offset 4: section type (0: unused, 1: program data, 2: symbols table, 3: strings table, 4: relocs with addends, 5: symbols hash table, 6: dyld info, 7: notes, 8: BSS, 9: relocs without addends, 11: dyld symbols table, 14: constructors, 15: destructors, 16, preconstructors, 17: group, 18: extended section indices, 19: number of typedefs ...)

         uint32_t flags;        // offset 8: bitmapped flags (1: writable, 2: takes RAM, 4: executable, 8: reserved, 16: mergeable, 32: contains C-strings, 64: sh_info contains SHT index, 128: preserve order, 256: OS-specific, 512: group member, 1024: TLS template ...)

         uint32_t virtual_addr; // offset 12: address in virtual memory where this section may be loaded

         uint32_t file_offset;  // offset 16: offset of this section in the ELF file

         uint32_t size;         // offset 20: size of this section

         uint32_t linked_index; // offset 24: optional section index of an associated section

         uint32_t info;         // offset 28: optional extra information

         uint32_t alignment;    // offset 32: required memory alignment (must be a power of 2)

         uint32_t entry_size;   // offset 36: for table-like sections, size of an element in the table

      } elf32; // size == 40

      PACKED (struct) // size == 64

      {

         uint32_t name_offset;  // offset 0: offset in the string table of the name of this section

         uint32_t type;         // offset 4: section type (0: unused, 1: program data, 2: symbols table, 3: strings table, 4: relocs with addends, 5: symbols hash table, 6: dyld info, 7: notes, 8: BSS, 9: relocs without addends, 11: dyld symbols table, 14: constructors, 15: destructors, 16, preconstructors, 17: group, 18: extended section indices, 19: number of typedefs ...)

         uint64_t flags;        // offset 8: bitmapped flags (1: writable, 2: takes RAM, 4: executable, 8: reserved, 16: mergeable, 32: contains C-strings, 64: sh_info contains SHT index, 128: preserve order, 256: OS-specific, 512: group member, 1024: TLS template ...)

         uint64_t virtual_addr; // offset 16: address in virtual memory where this section may be loaded

         uint64_t file_offset;  // offset 24: offset of this section in the ELF file

         uint64_t size;         // offset 32: size of this section

         uint32_t linked_index; // offset 40: optional section index of an associated section

         uint32_t info;         // offset 44: optional extra information

         uint64_t alignment;    // offset 48: required memory alignment (must be a power of 2)

         uint64_t entry_size;   // offset 56: for table-like sections, size of an element in the table

      } elf64; // size == 64

   } u;

} elf_section_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

// Executable and Linkable Format dynamic section entry structure type definition

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) elf_dynamic_section_entry_s

{

   PACKED (union)

   {

      PACKED (struct) // size == 8

      {

         int32_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)

         uint32_t value; // value (as integer, or as pointed address)

      } elf32; // size == 8

      PACKED (struct) // size == 16

      {

         int64_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)

         uint64_t value; // value (as integer, or as pointed address)

      } elf64; // size == 16

   } u;

} elf_dynamic_section_entry_t;

END_OF_PACKED_STRUCT () // restore default alignment

// generic buffer structure type definition

typedef struct buffer_s

{

   uint8_t *bytes; // mallocated data

   size_t len; // length of allocated data

} buffer_t;

// IFS directory entry insertion parameters structure type definition

typedef struct parms_s

{

   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

   int extra_ino_flags; // bitmap of extra inode flags (IFS_INO_xxx)

   char search[10 * MAXPATHLEN]; // binary search path (the default one will be constructed at startup)

   buffer_t data;

} parms_t;

// global variables

static char line_buffer[4096]; // scrap buffer for the IFS build file parser

static uint32_t image_base = 4 * 1024 * 1024; // default image base, as per QNX docs -- can be changed with the [image=XXXX] attribute in the IFS build file

static uint32_t image_end = UINT32_MAX; // default image end (no limit)

static uint32_t image_maxsize = UINT32_MAX; // default image max size (no limit)

static uint32_t image_totalsize = 0; // image total size, measured once all the blocks have been written to the output IFS file

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 void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer

static long long read_integer (const char *str); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)

static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...); // hexdump-style formatted output to a file stream (which may be stdout/stderr)

static char *binary (const uint8_t x, char char_for_zero, char char_for_one); // returns the binary representation of byte 'x' as a string

static char *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8]); // returns the ORed description of byte 'x' according to the description strings for each bit

static char *read_filecontents (const char *pathname, const char *search_path, buffer_t *outbuf); // locates pathname among MKIFS_PATH, reads it, places its contents in a buffer (caller frees) and returns a pointer to the resolved pathname (static string)

static int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp

static int relative_offset_of_in (const char *name, const buffer_t *stringbuf); // returns the relative offset of a particular string in a string table

static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file

static size_t 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, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // stack up a new filesystem entry

static int fsentry_compare_pathnames_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by pathnames

static void update_MKIFS_PATH (const char *processor);

static int dump_ifs_info (const char *ifs_pathname, bool want_everything); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error

static int create_intermediate_dirs (const char *file_pathname); // creates all intermediate directories to file_pathname so that fopen(file_pathname, "w") doesn't fail

static int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error

static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data)

{

   // logical functions used in SHA-384 and SHA-512

   #define S64(b,x)      (((x) >> (b)) | ((x) << (64 - (b)))) // 64-bit rotate right

   #define Ch(x,y,z)     (((x) & (y)) ^ ((~(x)) & (z)))

   #define Maj(x,y,z)    (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))

   #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))

   #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))

   #define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ ((x) >> 7))

   #define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ ((x) >> 6))

   // hash constant words K for SHA-384 and SHA-512

   static const uint64_t K512[80] = {

      0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,

      0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,

      0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,

      0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,

      0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,

      0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,

      0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,

      0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,

      0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,

      0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL

   };

   uint64_t     a, b, c, d, e, f, g, h, s0, s1;

   uint64_t     T1, T2, *W512 = (uint64_t *) context->buffer;

   int j;

   // initialize registers with the prev. intermediate value

   a = context->state[0]; b = context->state[1]; c = context->state[2]; d = context->state[3]; e = context->state[4]; f = context->state[5]; g = context->state[6]; h = context->state[7];

   for (j = 0; j < 16; j++)

   {

#if __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__

      W512[j] = __builtin_bswap64 (*data); // convert to host byte order

#elif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__

      W512[j] = *data;

#else // __BYTE_ORDER__ == ???

#error Please port this SHA-512 code to your exotic endianness platform. What are you compiling this on? PDP? Honeywell?

#endif // __BYTE_ORDER__ ==  __ORDER_LITTLE_ENDIAN__

      // apply the SHA-512 compression function to update a..h

      T1 = h + Sigma1_512 (e) + Ch (e, f, g) + K512[j] + W512[j];

      T2 = Sigma0_512 (a) + Maj (a, b, c);

      // update registers

      h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2;

      data++;

   }

   for (; j < 80; j++)

   {

      // part of the message block expansion

      s0 = W512[(j + 1) & 0x0f];

      s0 = sigma0_512 (s0);

      s1 = W512[(j + 14) & 0x0f];

      s1 = sigma1_512 (s1);

      // apply the SHA-512 compression function to update a..h

      T1 = h + Sigma1_512 (e) + Ch (e, f, g) + K512[j] + (W512[j & 0x0f] += s1 + W512[(j + 9) & 0x0f] + s0);