Subversion Repositories QNX 8.QNX8 IFS tool

#include <sys/stat.h>

#include <sys/stat.h>

#include <ctype.h>

#include <ctype.h>

#include <time.h>

#include <time.h>

#ifdef _MSC_VER

#ifdef _MSC_VER

#include <io.h>

#include <io.h>

#define __x86_64__ 1

#define __x86_64__ 1

#define __ORDER_BIG_ENDIAN__    4321

#define __ORDER_BIG_ENDIAN__    4321

#define __ORDER_LITTLE_ENDIAN__ 1234

#define __ORDER_LITTLE_ENDIAN__ 1234

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

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

#define MAXPATHLEN 1024

#define MAXPATHLEN 1024

#ifndef thread_local

#ifndef thread_local

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

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

#endif // !thread_local

#endif // !thread_local

#else // !_MSC_VER

#else // !_MSC_VER

#include <sys/param.h>

#include <sys/param.h>

#include <unistd.h>

#include <unistd.h>

#ifndef thread_local

#ifndef thread_local

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

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

#endif // !thread_local

#endif // !thread_local

#endif // _MSC_VER

#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);

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

#ifndef VERSION_ARG_YYYYMMDD

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

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

#define VERSION_FMT_YYYYMMDD "%04s%02s%02s"

#define VERSION_FMT_YYYYMMDD "%04s%02s%02s"

#define VERSION_ARG_YYYYMMDD BUILDDATE_YEAR, BUILDDATE_MONTH, BUILDDATE_DAY

#define VERSION_ARG_YYYYMMDD BUILDDATE_YEAR, BUILDDATE_MONTH, BUILDDATE_DAY

#endif // !VERSION_ARG_YYYYMMDD

#endif // !VERSION_ARG_YYYYMMDD

// macros for accessing ELF files

// macros for accessing ELF files

#define ELF_MAGIC_STR "\x7f" "ELF"

#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_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_ENDIAN_BIG    2 // 'endianness' member of an ELF header: ELF file is big endian

#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_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_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

#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

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

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

#define STARTUP_HDR_FLAGS1_VIRTUAL        (1 << 0)

#define STARTUP_HDR_FLAGS1_VIRTUAL        (1 << 0)

#define STARTUP_HDR_FLAGS1_BIGENDIAN      (1 << 1)

#define STARTUP_HDR_FLAGS1_BIGENDIAN      (1 << 1)

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

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

#define IFS_INO_PROCESSED_ELF 0x80000000

#define IFS_INO_PROCESSED_ELF 0x80000000

#define IFS_INO_RUNONCE_ELF   0x40000000

#define IFS_INO_RUNONCE_ELF   0x40000000

#define IFS_INO_BOOTSTRAP_EXE 0x20000000

#define IFS_INO_BOOTSTRAP_EXE 0x20000000

// SHA-512 block and digest sizes

// SHA-512 block and digest sizes

#define SHA512_BLOCK_LENGTH 128 // in bytes

#define SHA512_BLOCK_LENGTH 128 // in bytes

#define SHA512_DIGEST_LENGTH 64 // in bytes

#define SHA512_DIGEST_LENGTH 64 // in bytes

{

{

   uint64_t state[8];

   uint64_t state[8];

   uint64_t bitcount[2];

   uint64_t bitcount[2];

   uint8_t buffer[SHA512_BLOCK_LENGTH];

   uint8_t buffer[SHA512_BLOCK_LENGTH];

} SHA512_CTX;

} SHA512_CTX;

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

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

#define SCRIPT_FLAGS_EXTSCHED   0x01

#define SCRIPT_FLAGS_EXTSCHED   0x01

#define SCRIPT_FLAGS_SESSION    0x02

#define SCRIPT_FLAGS_SESSION    0x02

#define SCRIPT_APS_SYSTEM_PARTITION_NAME "System"

#define SCRIPT_APS_SYSTEM_PARTITION_NAME "System"

#define SCRIPT_APS_PARTITION_NAME_LENGTH 15

#define SCRIPT_APS_PARTITION_NAME_LENGTH 15

#define SCRIPT_APS_MAX_PARTITIONS        8

#define SCRIPT_APS_MAX_PARTITIONS        8

{

{

   uint16_t size; // size of cmd entry

   uint16_t size; // size of cmd entry

   uint8_t type;

   uint8_t type;

   uint8_t spare;

   uint8_t spare;

} bootscriptcmd_header_t;

} bootscriptcmd_header_t;

typedef union bootscriptcmd_s

typedef union bootscriptcmd_s

{

{

   {

   {

      bootscriptcmd_header_t hdr;

      bootscriptcmd_header_t hdr;

      uint8_t cpu; // CPU (turn into runmask)

      uint8_t cpu; // CPU (turn into runmask)

      uint8_t flags;

      uint8_t flags;

      union script_external_extsched

      union script_external_extsched

      {

      {

         uint8_t reserved[2];

         uint8_t reserved[2];

         {

         {

            uint8_t id;

            uint8_t id;

            uint8_t reserved[1];

            uint8_t reserved[1];

         } aps;

         } aps;

      } extsched; // extended scheduler

      } extsched; // extended scheduler

      uint8_t priority; // priority to run cmd at

      uint8_t priority; // priority to run cmd at

      uint8_t argc; // # of args

      uint8_t argc; // # of args

      uint8_t envc; // # of environment entries

      uint8_t envc; // # of environment entries

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

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

   } external;

   } external;

   {

   {

      bootscriptcmd_header_t hdr;

      bootscriptcmd_header_t hdr;

      uint16_t checks;

      uint16_t checks;

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

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

   } waitfor_reopen;

   } waitfor_reopen;

   {

   {

      bootscriptcmd_header_t hdr;

      bootscriptcmd_header_t hdr;

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

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

   } display_msg;

   } display_msg;

   {

   {

      bootscriptcmd_header_t hdr;

      bootscriptcmd_header_t hdr;

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

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

   } procmgr_symlink;

   } procmgr_symlink;

   {

   {

      bootscriptcmd_header_t hdr;

      bootscriptcmd_header_t hdr;

      uint8_t parent;

      uint8_t parent;

      uint8_t budget;

      uint8_t budget;

      uint16_t critical;

      uint16_t critical;

      uint8_t id;

      uint8_t id;

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

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

   } extsched_aps;

   } extsched_aps;

} bootscriptcmd_t;

} bootscriptcmd_t;

#endif // 0

#endif // 0

#define INITIAL_STARTUP_SCRIPT \

#define INITIAL_STARTUP_SCRIPT \

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

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

   "\x18\x00" /*size*/ "\x03" /*type*/ "\x00" /*spare*/ "Startup complete\n\0" "\x00\00" /*padding*/ \

   "\x18\x00" /*size*/ "\x03" /*type*/ "\x00" /*spare*/ "Startup complete\n\0" "\x00\00" /*padding*/ \

   /* trailer */ \

   /* trailer */ \

   "\x00\x00\x00\x00"

   "\x00\x00\x00\x00"

{

{

   {

   {

      uint16_t size; // size of dirent

      uint16_t size; // size of dirent

      uint16_t extattr_offset; // if zero, no extattr data

      uint16_t extattr_offset; // if zero, no extattr data

      uint32_t ino; // if zero, skip entry

      uint32_t ino; // if zero, skip entry

      uint32_t mode; // mode and perms of entry

      uint32_t mode; // mode and perms of entry

      uint32_t gid;

      uint32_t gid;

      uint32_t uid;

      uint32_t uid;

      uint32_t mtime;

      uint32_t mtime;

   } header;

   } header;

   {

   {

      {

      {

         uint32_t offset; // offset from header

         uint32_t offset; // offset from header

         uint32_t size;

         uint32_t size;

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

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

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

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

      } file;

      } file;

      {

      {

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

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

      } dir;

      } dir;

      {

      {

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

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

         uint16_t sym_size; // strlen (contents)

         uint16_t sym_size; // strlen (contents)

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

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

         char *contents; // null terminated symlink contents

         char *contents; // null terminated symlink contents

      } symlink;

      } symlink;

      {

      {

         uint32_t dev;

         uint32_t dev;

         uint32_t rdev;

         uint32_t rdev;

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

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

      } device;

      } device;

   } u;

   } u;

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

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

} fsentry_t;

} fsentry_t;

{

{

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

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

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

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

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

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

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

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

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

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

   uint16_t zero0;         // [  ] Zeros

   uint16_t zero0;         // [  ] Zeros

   uint32_t zero[1];       // [  ] 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)

   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)

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

} startup_header_t;

} startup_header_t;

{

{

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

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

} startup_trailer_v1_t;

} startup_trailer_v1_t;

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

// 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.

// 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.

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

{

{

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

   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

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

} startup_trailer_v2_t;

} startup_trailer_v2_t;

{

{

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

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

   uint8_t flags; // endian neutral flags, 0x1c

   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 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 hdr_dir_size; // size from start of header to last dirent (here 0x12b8 or 4792)

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

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

   uint32_t spare[10]; // zerofill

   uint32_t spare[10]; // zerofill

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

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

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

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

} image_header_t;

} image_header_t;

{

{

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

   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

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

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

// 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.

// 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.

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

{

{

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

   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

   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

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

// Executable and Linkable Format master header structure type definition

// Executable and Linkable Format master header structure type definition

{

{

   {

   {

      {

      {

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

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

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

         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 endianness;                   // offset 5: 1 = little endian, 2 = big endian

         uint8_t header_version;               // offset 6: typically 1

         uint8_t header_version;               // offset 6: typically 1

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

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

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

         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

         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 elf_version;                 // offset 20: typically 1

      } elf;

      } elf;

      {

      {

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

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

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

         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 endianness;                   // offset 5: 1 = little endian, 2 = big endian

         uint8_t header_version;               // offset 6: typically 1

         uint8_t header_version;               // offset 6: typically 1

         uint16_t program_header_table_len;    // offset 44: number of entries 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_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_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

         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

      } elf32; // size == 52

      {

      {

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

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

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

         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 endianness;                   // offset 5: 1 = little endian, 2 = big endian

         uint8_t header_version;               // offset 6: typically 1

         uint8_t header_version;               // offset 6: typically 1

         uint16_t section_header_table_len;    // offset 60: number of entries 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

         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

      } elf64; // size == 64

   } u;

   } u;

} elf_header_t;

} elf_header_t;

// Executable and Linkable Format program header structure type definition

// Executable and Linkable Format program header structure type definition

{

{

   {

   {

      {

      {

         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_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;

      } elf;

      {

      {

         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_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 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 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 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_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 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 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)

         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

      } elf32; // 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 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)

         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 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 virtual_addr;   // offset 16: virtual address where this segment should be mapped in memory

         uint64_t size_in_memory; // offset 40: size of this segment in memory (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)

         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

      } elf64; // size == 56

   } u;

   } u;

} elf_program_header_t;

} elf_program_header_t;

// Executable and Linkable Format section header structure type definition

// Executable and Linkable Format section header structure type definition

{

{

   {

   {

      {

      {

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

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

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

         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 file_offset;  // offset 16: offset of this section in the ELF file

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

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

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

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

         uint32_t info;         // offset 28: optional extra information

         uint32_t info;         // offset 28: optional extra information

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

         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

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

      } elf32; // size == 40

      } elf32; // size == 40

      {

      {

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

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

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

         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 file_offset;  // offset 24: offset of this section in the ELF file

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

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

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

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

         uint32_t info;         // offset 44: optional extra information

         uint32_t info;         // offset 44: optional extra information

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

         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

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

      } elf64; // size == 64

      } elf64; // size == 64

   } u;

   } u;

} elf_section_header_t;

} elf_section_header_t;

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

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

{

{

   {

   {

      {

      {

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

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

      } elf32; // size == 8

      } elf32; // size == 8

      {

      {

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

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

      } elf64; // size == 16

      } elf64; // size == 16

   } u;

   } u;

} elf_dynamic_section_entry_t;

} elf_dynamic_section_entry_t;

typedef struct parms_s

typedef struct parms_s

{

{

   int dperms; // directory permissions (e.g. 0755)

   int dperms; // directory permissions (e.g. 0755)

   int perms; // file permissions (e.g. 0644)

   int perms; // file permissions (e.g. 0644)

   int uid; // owner user ID (e.g. 0 = root)

   int uid; // owner user ID (e.g. 0 = root)

   bool should_autosymlink_dylib; // dynamic libraries should be written under their official SONAME and a named symlink be created pointing at them

   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

   bool is_compiled_bootscript; // entry has [+script] attribute

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

   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)

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

} parms_t;

} parms_t;

// global variables

// global variables

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

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

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 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 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 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 *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 *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8]); // returns the ORed description of byte 'x' according to the description strings for each bit

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

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

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 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 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 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_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 void update_MKIFS_PATH (const char *processor);

      }

      }

   return (outstr);

   return (outstr);

}

}

{

{

   // locates pathname among MKIFS_PATH, and places its contents in a buffer (caller frees). Returns resolved pathname (static buffer) or NULL.

   // locates pathname among MKIFS_PATH, and places its contents in a buffer (caller frees). Returns resolved pathname (static buffer) or NULL.

   static thread_local char final_pathname[MAXPATHLEN];

   static thread_local char final_pathname[MAXPATHLEN];

   fp = fopen (final_pathname, "rb");

   fp = fopen (final_pathname, "rb");

   if (fp == NULL)

   if (fp == NULL)

      return (NULL); // unexistent file (errno is set to ENOENT)

      return (NULL); // unexistent file (errno is set to ENOENT)

   fseek (fp, 0, SEEK_END);

   fseek (fp, 0, SEEK_END);

   fseek (fp, 0, SEEK_SET);

   fseek (fp, 0, SEEK_SET);

   {

   {

      fclose (fp);

      fclose (fp);

      return (NULL); // out of memory (errno is set to ENOMEM)

      return (NULL); // out of memory (errno is set to ENOMEM)

   }

   }

   {

   {

      fclose (fp);

      fclose (fp);

      return (NULL); // short read (errno is set)

      return (NULL); // short read (errno is set)

   }

   }

   fclose (fp); // close the file

   fclose (fp); // close the file

   return (final_pathname); // file was read successfully and its content put in databuf with size datalen

   return (final_pathname); // file was read successfully and its content put in databuf with size datalen

   free (blob_buffer);

   free (blob_buffer);

   return (ret);

   return (ret);

}

}

{

{

   int name_len = (int) strlen (name) + 1;

   int name_len = (int) strlen (name) + 1;

         return (idx);

         return (idx);

   WELLMANNERED_ASSERT (false, "bad call (name '%s' not found in string table)", name);

   WELLMANNERED_ASSERT (false, "bad call (name '%s' not found in string table)", name);

   return (0);

   return (0);

}

}

}

}

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 size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)

{

{

      name_len = strlen ((name)) + 1; \

      name_len = strlen ((name)) + 1; \