Subversion Repositories QNX 8.QNX8 IFS tool

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

typedef struct sha512_ctx_s

   uint64_t state[8];

   uint64_t bitcount[2];

   uint8_t buffer[SHA512_BLOCK_LENGTH];

} SHA512_CTX;

 

 

 

 

 

 

 

 

 

 

 

typedef struct __attribute__((packed)) bootscriptcmd_header_s

   uint16_t size; // size of cmd entry

   uint8_t type;

   uint8_t spare;

} bootscriptcmd_header_t;

 

 

typedef union bootscriptcmd_s

   struct __attribute__((packed)) script_external

   {

      bootscriptcmd_header_t hdr;

      uint8_t cpu; // CPU (turn into runmask)

      uint8_t flags;

      union script_external_extsched

      {

         uint8_t reserved[2];

         struct __attribute__((packed))

         {

            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;

   struct __attribute__((packed)) script_waitfor_reopen

   {

      bootscriptcmd_header_t hdr;

      uint16_t checks;

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

   } waitfor_reopen;

   struct __attribute__((packed)) script_display_msg

   {

      bootscriptcmd_header_t hdr;

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

   } display_msg;

   struct __attribute__((packed)) 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;

   struct __attribute__((packed)) 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;

 

 

 

 

typedef struct __attribute__((packed)) fsentry_s

   struct __attribute__((packed)) 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;

   union __attribute__((packed)) fsentry_specific_u

   {

      struct __attribute__((packed)) 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;

      struct __attribute__((packed)) fsentry_dir_s // when (mode & S_IFMT) == S_IFDIR

      {

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

      } dir;

      struct __attribute__((packed)) 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;

      struct __attribute__((packed)) 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;

 

 

typedef struct __attribute__((packed)) 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;

 

 

typedef struct __attribute__((packed)) startup_trailer_s

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

} startup_trailer_v1_t;

 

 

typedef struct __attribute__((packed)) 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;

 

 

typedef struct __attribute__((packed)) 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;

 

 

typedef struct __attribute__((packed)) 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

 

 

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

 

 

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;

 

 

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;

 

 

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;

 

 

 

 

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

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

 

   uint8_t *data;

   size_t datalen;

} parms_t;

 

 

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;

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)

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)

static char *buildfile_pathname = NULL; // pathname of IFS build file

static char *current_line = NULL; // copy of current line in IFS build file

static int lineno = 0; // current line number in IFS build file

static char *QNX_TARGET = NULL; // value of the $QNX_TARGET environment variable

static char *MKIFS_PATH = NULL; // value of the $MKIFS_PATH environment variable (may contain references to $QNX_TARGET). Initialized by this program if empty.

 

 

static 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, 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, 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); // 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)

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

   {

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

      W512[j] = *data;

 

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

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

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

 

      // update registers

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

 

      data++;

   }

 

   for (; j < 80; j++)

   {

      // part of the message block expansion

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

      s0 = sigma0_512 (s0);

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

      s1 = sigma1_512 (s1);

 

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

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

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

 

      // update registers

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

   }

 

   // compute the current intermediate hash value

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

 

   // clean up

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

   #undef sigma1_512

   #undef sigma0_512

   #undef Sigma1_512

   #undef Sigma0_512

   #undef Maj

   #undef Ch

   #undef S64

   return;

 

 

static void SHA512_Init (SHA512_CTX *context)

   // initial hash value H for SHA-512

   static const uint64_t sha512_initial_hash_value[8] = {

      0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL, 0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL

   };

 

   memcpy (context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);

   memset (context->buffer, 0, SHA512_BLOCK_LENGTH);

   context->bitcount[0] = context->bitcount[1] = 0;

 

 

void SHA512_Update (SHA512_CTX *context, void *datain, size_t len)

   #define ADDINC128(w,n) do { \

 

   size_t freespace, usedspace;

   const uint8_t *data = (const uint8_t *) datain;

 

   if (len == 0)

      return; // calling with empty data is valid - we do nothing

 

   usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;

   if (usedspace > 0)

   {

      // calculate how much free space is available in the buffer

      freespace = SHA512_BLOCK_LENGTH - usedspace;

 

      if (len >= freespace)

      {

         // fill the buffer completely and process it

         memcpy (&context->buffer[usedspace], data, freespace);

         ADDINC128 (context->bitcount, freespace << 3);

         len -= freespace;

         data += freespace;

         sha512_private_transform (context, (uint64_t *) context->buffer);

      }

      else

      {

         // the buffer is not full yet

         memcpy (&context->buffer[usedspace], data, len);

         ADDINC128 (context->bitcount, len << 3);

 

         // clean up

         usedspace = freespace = 0;

         return;

      }

   }

 

   while (len >= SHA512_BLOCK_LENGTH)

   {

      // process as many complete blocks as we can

      sha512_private_transform (context, (uint64_t *) data);

      ADDINC128 (context->bitcount, SHA512_BLOCK_LENGTH << 3);

      len -= SHA512_BLOCK_LENGTH;

      data += SHA512_BLOCK_LENGTH;

   }

 

   if (len > 0)

   {

      // save leftovers

      memcpy (context->buffer, data, len);

      ADDINC128 (context->bitcount, len << 3);

   }

 

   // clean up

   usedspace = freespace = 0;

   #undef ADDINC128

   return;

 

 

static void SHA512_Final (uint8_t digest[SHA512_DIGEST_LENGTH], SHA512_CTX *context)

   #define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16)

 

   size_t usedspace;

   union { uint8_t *as_bytes; uint64_t *as_uint64s; } cast_var = { NULL };

 

   // if no digest buffer is passed, don't bother finalizing the computation

   if (digest != NULL)

   {

      usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;

 

      context->bitcount[0] = __builtin_bswap64 (context->bitcount[0]); // convert from host byte order

      context->bitcount[1] = __builtin_bswap64 (context->bitcount[1]); // convert from host byte order

 

      if (usedspace > 0)

      {

         // begin padding with a 1 bit

         context->buffer[usedspace++] = 0x80;

 

         if (usedspace <= SHA512_SHORT_BLOCK_LENGTH)

            memset (&context->buffer[usedspace], 0, SHA512_SHORT_BLOCK_LENGTH - usedspace); // set-up for the last transform

         else

         {

            if (usedspace < SHA512_BLOCK_LENGTH)

               memset (&context->buffer[usedspace], 0, SHA512_BLOCK_LENGTH - usedspace);

 

            sha512_private_transform (context, (uint64_t *) context->buffer); // do second-to-last transform

            memset (context->buffer, 0, SHA512_BLOCK_LENGTH - 2); // and set-up for the last transform

         }

      }

      else // usedspace == 0

      {

         memset (context->buffer, 0, SHA512_SHORT_BLOCK_LENGTH); // prepare for final transform

         *context->buffer = 0x80; // begin padding with a 1 bit

      }

 

      // store the length of input data (in bits)

      cast_var.as_bytes = context->buffer;

      cast_var.as_uint64s[SHA512_SHORT_BLOCK_LENGTH / 8 + 0] = context->bitcount[1];

      cast_var.as_uint64s[SHA512_SHORT_BLOCK_LENGTH / 8 + 1] = context->bitcount[0];

 

      // final transform

      sha512_private_transform (context, (uint64_t *) context->buffer);

 

      // save the hash data for output

      for (int j = 0; j < 8; j++)

         context->state[j] = __builtin_bswap64 (context->state[j]); // convert to host byte order

      memcpy (digest, context->state, SHA512_DIGEST_LENGTH);

   }

 

   // zero out state data

   memset (context, 0, sizeof (SHA512_CTX));

   #undef SHA512_SHORT_BLOCK_LENGTH

   return;

 

 

static uint8_t *SHA512 (void *data, size_t data_len, uint8_t *digest_or_NULL)

   // computes the SHA-512 hash of a block of data in one pass and write it to digest, or to a static buffer if NULL

   // returns the STRING REPRESENTATION of digest in a statically-allocated string

 

   static thread_local uint8_t static_digest[SHA512_DIGEST_LENGTH] = "";

   static thread_local char digest_as_string[2 * SHA512_DIGEST_LENGTH + 1] = "";

 

   SHA512_CTX ctx;

   size_t byte_index;

 

   SHA512_Init (&ctx);

   SHA512_Update (&ctx, data, data_len);

   if (digest_or_NULL == NULL)

      digest_or_NULL = static_digest;

   SHA512_Final (digest_or_NULL, &ctx);

 

   for (byte_index = 0; byte_index < SHA512_DIGEST_LENGTH; byte_index++)

      sprintf (&digest_as_string[2 * byte_index], "%02x", digest_or_NULL[byte_index]);

   return (digest_as_string);

 

 

static int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness)

   // computes the checksum of an IFS image or startup section, i.e. from the start of the header to the end of the trailer minus the last 4 bytes where the checksum is stored

 

   uint8_t accumulator[4] = { 0, 0, 0, 0 };

   const char *current_char_ptr;

   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)

            image_cksum += (accumulator[3] << 0) + (accumulator[2] << 8) + (accumulator[1] << 16) + (accumulator[0] << 24);

         else

            image_cksum += (accumulator[0] << 0) + (accumulator[1] << 8) + (accumulator[2] << 16) + (accumulator[3] << 24);

      current_char_ptr++;

   }

 

   return (is_foreign_endianness ? __builtin_bswap32 (-image_cksum) : -image_cksum);

 

 

static long long read_integer (const char *str)

   // reads a 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)

 

   char *endptr = NULL;

   long long ret = strtoll (str, &endptr, 0); // use strtoll() to handle hexadecimal (0x...), octal (0...) and decimal (...) bases

   if (endptr != NULL)

   {

      if ((*endptr == 'k') || (*endptr == 'K')) ret *= (size_t) 1024;

      else if ((*endptr == 'm') || (*endptr == 'M')) ret *= (size_t) 1024 * 1024;

      else if ((*endptr == 'g') || (*endptr == 'G')) ret *= (size_t) 1024 * 1024 * 1024;

      else if ((*endptr == 't') || (*endptr == 'T')) ret *= (size_t) 1024 * 1024 * 1024 * 1024; // future-proof enough, I suppose?

   }

   return (ret);

 

 

static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...)

   // this function logs hexadecimal data to an opened file pointer (or to stdout/stderr)

 

   va_list argptr;

   size_t index;

   int i;

 

   // concatenate all the arguments in one string and write it to the file

   va_start (argptr, fmt);

   vfprintf (fp, fmt, argptr);

   va_end (argptr);

 

   // for each row of howmany_columns bytes of data...

   for (index = 0; index < data_size; index += howmany_columns)

   {

      fprintf (fp, "    %05zu  ", index); // print array address of row

      for (i = 0; i < howmany_columns; i++)

         if (index + i < data_size)

            fprintf (fp, " %02X", data[index + i]); // if row contains data, print data as hex bytes

         else

            fprintf (fp, "   "); // else fill the space with blanks

      fprintf (fp, "   ");

      for (i = 0; i < howmany_columns; i++)

         if (index + i < data_size)

            fputc ((data[index + i] >= 32) && (data[index + i] < 127) ? data[index + i] : '.', fp); // now if row contains data, print data as ASCII

         else

            fputc (' ', fp); // else fill the space with blanks

      fputc ('\n', fp);

   }

 

   return; // and return

 

 

static char *binary (const uint8_t x, char char_for_zero, char char_for_one)

   // returns the binary representation of x as a string

 

   static thread_local char outstr[9] = "00000000";

   for (int i = 0; i < 8; i++)

      outstr[i] = (x & (0x80 >> i) ? char_for_one : char_for_zero);

   return (outstr);

 

 

static char *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8])

   // returns the ORed description of byte 'x' according to the description strings for each bit

 

   static thread_local char *default_bitstrings[8] = { "bit0", "bit1", "bit2", "bit3", "bit4", "bit5", "bit6", "bit7" };

   static thread_local char outstr[8 * 64] = "";

 

   outstr[0] = 0;

   for (int i = 0; i < 8; i++)

      if (x & (1 << i))

      {

         if (outstr[0] != 0)

            strcat (outstr, "|");

         strcat (outstr, ((bitwise_stringdescs != NULL) && (*bitwise_stringdescs[i] != 0) ? bitwise_stringdescs[i] : default_bitstrings[i]));

      }

   return (outstr);

 

 

static char *read_filecontents (const char *pathname, const char *search_path, 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.

 

   static thread_local 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 != 0 ? search_path : NULL);

      nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP_STR)] : NULL);

      while (token != NULL)

      {

         sprintf (final_pathname, "%.*s/%s", (int) (nextsep - token), token, pathname);

         if (access (final_pathname, 0) == 0)

            break; // if a file can indeed be found at this location, stop searching

 

         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)

   // dumps the binary contents of pathname to fp

 

   uint8_t *blob_buffer;

   size_t blob_size;

   FILE *blob_fp;

   int ret;

 

   blob_fp = fopen (pathname, "rb");

   if (blob_fp == NULL)

      return (-1); // errno is set

 

   fseek (blob_fp, 0, SEEK_END);

   blob_size = ftell (blob_fp);

   blob_buffer = malloc (blob_size);

   if (blob_buffer == NULL)

   {

      fclose (blob_fp);

      return (-1); // errno is set to ENOMEM

   }

   fseek (blob_fp, 0, SEEK_SET);

   fread (blob_buffer, 1, blob_size, blob_fp);

   fclose (blob_fp);

 

   ret = (int) fwrite (blob_buffer, 1, blob_size, fp);

   fflush (fp); // force flush to disk, because the C stream API is *buffered*

   free (blob_buffer);

   return (ret);

 

 

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;

 

   count = 0;

   if (fp != NULL)

      fwrite_or_die (&fsentry->header, 1, sizeof (fsentry->header), fp); // write the entry header (PACKED STRUCT)

   count += sizeof (fsentry->header);

   if (S_ISREG (fsentry->header.mode))

   {

      if (fp != NULL)

      {

         fwrite_or_die (&fsentry->u.file.offset, 1, sizeof (uint32_t), fp); // write offset

         fwrite_or_die (&fsentry->u.file.size,   1, sizeof (uint32_t), fp); // write size

      }

      count += 2 * sizeof (uint32_t);

      datalen = strlen (fsentry->u.file.path) + 1;

      if (fp != NULL)

         fwrite_or_die (fsentry->u.file.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)

      count += datalen;

   }

   else if (S_ISDIR (fsentry->header.mode))

   {

      datalen = strlen (fsentry->u.dir.path) + 1;

      if (fp != NULL)

         fwrite_or_die (fsentry->u.dir.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)

      count += datalen;

   }

   else if (S_ISLNK (fsentry->header.mode))

   {

      if (fp != NULL)

      {

         fwrite_or_die (&fsentry->u.symlink.sym_offset, 1, sizeof (uint16_t), fp); // write offset

         fwrite_or_die (&fsentry->u.symlink.sym_size,   1, sizeof (uint16_t), fp); // write size

      }

      count += 2 * sizeof (uint16_t);

      datalen = strlen (fsentry->u.symlink.path) + 1;

      if (fp != NULL)

         fwrite_or_die (fsentry->u.symlink.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)

      count += datalen;

      datalen = strlen (fsentry->u.symlink.contents) + 1;

      if (fp != NULL)

         fwrite_or_die (fsentry->u.symlink.contents, 1, (size_t) datalen, fp); // write null-terminated symlink contents

      count += datalen;

   }

   else

   {

      if (fp != NULL)

      {

         fwrite_or_die (&fsentry->u.device.dev,  1, sizeof (uint32_t), fp); // write dev number

         fwrite_or_die (&fsentry->u.device.rdev, 1, sizeof (uint32_t), fp); // write rdev number

      }

      count += 2 * sizeof (uint32_t);

      datalen = strlen (fsentry->u.device.path) + 1;

      if (fp != NULL)

         fwrite_or_die (fsentry->u.device.path, 1, (size_t) datalen, fp); // write null-terminated path (no leading slash)

      count += datalen;

   }

 

   if (count < fsentry->header.size)

   {

      if (fp != NULL)

         fwrite_or_die (zeropad_buffer, 1, fsentry->header.size - count, fp); // pad as necessary

      count += fsentry->header.size - count;

   }

   else if (count > fsentry->header.size)

   {

      fprintf (stderr, "ERROR: attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.\n", (size_t) fsentry->header.size, count);

      exit (1);

   }

 

   return (count);

 

 

static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)

   static thread_local char candidate_pathname[1024];

   static int inode_count = 0; // will be preincremented each time this function is called

 

   const char *original_stored_pathname = NULL;

   const elf_dynamic_section_entry_t *dynamic_entry; // dynamic section entry

   const elf_section_header_t *shdr_shstr; // section headers strings (containing ELF sections names)

   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;

   void *old_data;

   struct stat stat_buf;

   size_t table_index;

   size_t table_count;

   //uint32_t mtime = (entry_parms->m(uint32_t) time (NULL);

   uint32_t extra_ino_flags = 0;

   fsentry_t *fsentry;

 

   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 (strcmp (stored_pathname, "/proc/boot/boot") == 0) // is it the kernel ?

      {

         // HACK: for now just consider the kernel as a binary blob

         // FIXME: reimplement properly

         sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix); // fix the entry name

         stored_pathname = candidate_pathname;

         extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode

         entry_parms->st_mode = S_IFREG | 0700; // procnto requires 0700 permissions

         image_kernel_ino = extra_ino_flags | (inode_count + 1);

      }

      else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?

         image_bootscript_ino = inode_count + 1; // save boot script inode number for image header

 

      // do we already know the data for this data blob ?

      if (entry_parms->data != NULL)

      {

         entry_parms->mtime = entry_parms->mtime_for_inline_files;

         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)\n", extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->datalen);

      }

      else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?

      {

         resolved_pathname = read_filecontents (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH), &entry_parms->data, &entry_parms->datalen); // locate the file

         if (resolved_pathname == NULL)

         {

            fprintf (stderr, "fatal error: filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s\n", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));

            exit (1);

         }

         stat (resolved_pathname, &stat_buf); // can't fail

         if (entry_parms->mtime == UINT32_MAX)

            entry_parms->mtime = (uint32_t) stat_buf.st_mtime;

         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->datalen);

      }

 

      // is the file we're storing an ELF file ?

      if ((entry_parms->datalen > 52) // file is big enough to contain an ELF header

          && ((elf = (elf_header_t *) entry_parms->data) != NULL) // cast (necessary true)

          && (memcmp (ELF_STRUCT_MEMBER_STRING (elf, elf, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic

      {

         shdr_shstr = (elf_section_header_t *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_item_size) * ELF_STRUCT_MEMBER_NUMERIC (elf, 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_NUMERIC (elf, shdr_shstr, file_offset)]; // locate the start of the strings table that contains the section names

 

         // strip this ELF file

 

         // is the file we're storing a relocatable executable (i.e. a dynamic library) and should we check for its canonical name ?

         if ((ELF_STRUCT_MEMBER_NUMERIC (elf, elf, type) == 3) && entry_parms->should_autosymlink_dylib)

         {

            // we need to find the SONAME of this library

            canonical_dylib_name = NULL;

 

            // locate the sections we need (the dynamic section and its strings table)

            table_count = ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_table_len);

            shdr_dynamic = NULL;

            shdr_dynstr = NULL;

            for (table_index = 0; table_index < table_count; table_index++)

            {

               shdr = (elf_section_header_t *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_item_size) * table_index]; // quick access to section header

               elf_section_name = &shtable_strings[ELF_STRUCT_MEMBER_NUMERIC (elf, shdr, name_offset)];

               if (strcmp (elf_section_name, ".dynamic") == 0)

                  shdr_dynamic = shdr;

               else if (strcmp (elf_section_name, ".dynstr") == 0)

                  shdr_dynstr = shdr;

            }

 

            // make sure we have both the dynamic section header and its own strings table header

            if ((shdr_dynamic != NULL) && (shdr_dynstr != NULL))

            {

               dynamic_strings = (char *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (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_NUMERIC (elf, shdr_dynamic, file_offset)];

                    (ELF_STRUCT_MEMBER_NUMERIC (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 (ELF_STRUCT_MEMBER_NUMERIC (elf, dynamic_entry, tag) == ELF_DT_SONAME)

                  {

                     canonical_dylib_name = dynamic_strings + ELF_STRUCT_MEMBER_NUMERIC (elf, dynamic_entry, value.as_integer);

                     break;

                  }

 

               // do we have it ?

               if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0))

               {

                  sprintf (candidate_pathname, "%s/%s", entry_parms->prefix, canonical_dylib_name);

                  if (strcmp (candidate_pathname, stored_pathname) != 0) // claimed dylib name differs from passed name ?

                  {

                     original_stored_pathname = stored_pathname; // if so, remember to create a symlink here

                     stored_pathname = candidate_pathname;

                  }

               }

            }

         } // end if the file we're storing is a dylib

      } // end if the file we're storing is an ELF file

   }

   else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?

      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_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_parms->data);

   }

 

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

   }

   *fsentries = reallocated_ptr; // save reallocated pointer

   fsentry = &(*fsentries)[*fsentry_count]; // quick access to fs entry slot

   //fsentry->header.size = 0; // will be filled once we know it

   fsentry->header.extattr_offset = 0;

   fsentry->header.ino = extra_ino_flags | (++inode_count);

   fsentry->header.mode = entry_parms->st_mode;

   fsentry->header.gid = entry_parms->gid;

   fsentry->header.uid = entry_parms->uid;

   fsentry->header.mtime = (entry_parms->mtime == UINT32_MAX ? (uint32_t) time (NULL) : entry_parms->mtime);

   if (S_ISDIR (entry_parms->st_mode))

   {

      fsentry->u.dir.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + strlen (fsentry->u.dir.path) + 1, image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = true; // no data to save

   }

   else if (S_ISREG (entry_parms->st_mode))

   {

      fsentry->u.file.offset = WILL_BE_FILLED_LATER; // will be filled later in main() when the file's data blob will be written to the output file

      fsentry->u.file.size = (uint32_t) entry_parms->datalen;

      fsentry->u.file.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);

      fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->datalen);

      WELLMANNERED_ASSERT (fsentry->u.file.UNSAVED_databuf, "out of memory");

      memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data, entry_parms->datalen);

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.file.path) + 1, image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = false; // there *IS* data to save

   }

   else if (S_ISLNK (entry_parms->st_mode))

   {

      fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname) + 1);

      fsentry->u.symlink.sym_size = (uint16_t) entry_parms->datalen;

      fsentry->u.symlink.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);

      fsentry->u.symlink.contents = strdup (entry_parms->data);

      WELLMANNERED_ASSERT (fsentry->u.symlink.contents, "out of memory");

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint16_t) + sizeof (uint16_t) + (size_t) fsentry->u.symlink.sym_offset + fsentry->u.symlink.sym_size + 1, image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = true; // no data to save

   }

   else // necessarily a device node

   {

      fsentry->u.device.dev  = strtol (entry_parms->data, 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[0] == '/' ? &stored_pathname[1] : stored_pathname);

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.device.path), image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = true; // no data to save

   }

   (*fsentry_count)++;

 

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