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 header to end of trailer (here 0xca6fe0 or 13 266 912)

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

   uint32_t dir_offset; // offset from header to 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 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

   char prefix[MAXPATHLEN]; // install path (e.g. "proc/boot")

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

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

 

   uint8_t *precompiled_data;

   size_t precompiled_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 *buildfile_pathname = NULL; // pathname of 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 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_checksum32 (const int32_t start_value, const void *data, const size_t len); // update the sum of an array of 32-bit signed integers

static int32_t update_image_checksum (const int32_t start_value, const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image checksum to store in the image 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 int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp

static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp); // writes the given filesystem entry into fp (without its contents)

static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, const char *stored_pathname, parms_t *entry_parms, const uint8_t *data, const size_t entry_datalen); // stack up a new filesystem entry

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

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

static 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 uint8_t static_digest[SHA512_DIGEST_LENGTH] = "";

   static 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_checksum32_NOT (const int32_t start_value, const void *data, const size_t len)

   // compute the sum of an array of 32-bit signed integers

 

   const int32_t *values_array = data;

   int32_t sum = start_value;

 

   for (size_t value_index = 0; value_index < len / sizeof (int32_t); value_index++)

      sum += values_array[value_index];

 

   return (sum);

 

 

static int32_t update_checksum32 (const int32_t start_value, const void *data, const size_t data_len)

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

 

   int32_t image_cksum = start_value;

 

   int hold_index; // ST2C_4@4

   uint64_t i; // [sp+30h] [bp-10h]@3

   char *current_char_ptr; // [sp+38h] [bp-8h]@3

   char *data_start; // [sp+50h] [bp+10h]@1

   uint64_t _data_len; // [sp+58h] [bp+18h]@1

 

   data_start = data;

   _data_len = data_len;

   current_char_ptr = data_start;

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

   {

      hold_index = i & 3;

      hold_cksum_4[hold_index] = *current_char_ptr;

      if (hold_index == 3)

      {

         if (false) // endianness

            image_cksum += (hold_cksum_4[3] << 0)

            + (hold_cksum_4[2] << 8)

            + (hold_cksum_4[1] << 16)

            + (hold_cksum_4[0] << 24);

         else

            image_cksum += (hold_cksum_4[0] << 0)

            + (hold_cksum_4[1] << 8)

            + (hold_cksum_4[2] << 16)

            + (hold_cksum_4[3] << 24);

      }

      current_char_ptr++;

   }

   return (-image_cksum);

 

 

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

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

 

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

   int32_t image_cksum = start_value;

   char *current_char_ptr = data;

   size_t i;

 

   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 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 char *default_bitstrings[8] = { "bit0", "bit1", "bit2", "bit3", "bit4", "bit5", "bit6", "bit7" };

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

   free (blob_buffer);

   return (ret);

 

 

static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp)

   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 (&fsentry->header, sizeof (fsentry->header), 1, fp); // write the entry header (PACKED STRUCT)

   count += sizeof (fsentry->header);

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

   {

      if (fp != NULL)

      {

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

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

      }

      count += 2 * sizeof (uint32_t);

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

      if (fp != NULL)

         fwrite (fsentry->u.file.path, (size_t) datalen, 1, 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 (fsentry->u.dir.path, (size_t) datalen, 1, fp); // write null-terminated path (no leading slash)

      count += datalen;

   }

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

   {

      if (fp != NULL)

      {

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

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

      }

      count += 2 * sizeof (uint16_t);

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

      if (fp != NULL)

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

      count += datalen;

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

      if (fp != NULL)

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

      count += datalen;

   }

   else

   {

      if (fp != NULL)

      {

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

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

      }

      count += 2 * sizeof (uint32_t);

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

      if (fp != NULL)

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

      count += datalen;

   }

 

   if ((fp != NULL) && (count % image_align != 0))

      fwrite (zeropad_buffer, count % image_align, 1, fp); // pad as necessary

   count = ROUND_TO_UPPER_MULTIPLE (count, image_align);

 

   return (count);

 

 

static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, const char *stored_pathname, parms_t *entry_parms, const uint8_t *entry_data, const size_t entry_datalen)

   static char candidate_pathname[1024];

   static char *MKIFS_PATH = NULL;

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

 

   void *reallocated_ptr;

   char processor_base[16];

   struct stat stat_buf;

   uint8_t *data_buffer = NULL;

   size_t data_len = 0;

   uint32_t mtime = (uint32_t) time (NULL);

   uint32_t extra_ino_flags = 0;

   fsentry_t *fsentry;

   char *token;

   FILE *fp;

 

   if (S_ISDIR (entry_parms->st_mode)) // are we storing a directory ?

   {

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

   }

   else if (S_ISREG (entry_parms->st_mode)) // else are we storing a regular file ?

   {

      if ((entry_data != NULL) && (entry_datalen > 0)) // was an explicit contents blob supplied ?

      {

         if (strcmp (stored_pathname, "proc/boot/boot") == 0) // is it the kernel ?

         {

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

            // FIXME: reimplement properly

            data_len = entry_datalen;

            data_buffer = malloc (data_len);

            if (data_buffer == NULL)

            {

               fprintf (stderr, "fatal error: out of memory\n");

               exit (1);

            }

            memcpy (data_buffer, entry_data, data_len);

 

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

            stored_pathname = candidate_pathname;

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

            image_kernel_ino = extra_ino_flags | (inode_count + 1);

         }

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

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

 

         // should we substitute precompiled data to this data blob ?

         if ((entry_parms->precompiled_data != NULL) && (entry_parms->precompiled_datalen > 0))

         {

            data_len = entry_parms->precompiled_datalen;

            data_buffer = malloc (data_len);

            if (data_buffer == NULL)

            {

               fprintf (stderr, "fatal error: out of memory\n");

               exit (1);

            }

            memcpy (data_buffer, entry_parms->precompiled_data, data_len);

         }

         else // else use the supplied data blob

         {

            data_len = entry_datalen;

            data_buffer = malloc (data_len);

            if (data_buffer == NULL)

            {

               fprintf (stderr, "fatal error: out of memory\n");

               exit (1);

            }

            memcpy (data_buffer, entry_data, data_len);

         }

 

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

      }

      else if ((entry_data != NULL) && (entry_data[0] != 0)) // else entry_datalen == 0, was some sort of pathname supplied ?

      {

         // is it an absolute pathname ?

         if (IS_DIRSEP (entry_data[0])

             || (isalpha (entry_data[0])

                 && (entry_data[1] == ':')

                 && IS_DIRSEP (entry_data[2])))

         {

            // in this case, it MUST exist at its designated location (either absolute or relative to the current working directory)

            strcpy (candidate_pathname, entry_data);

            if (stat (candidate_pathname, &stat_buf) != 0)

            {

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

               exit (1);

            }

         }

         else // the path is relative, search it among the search paths we have

         {

            // is the search path NOT defined ?

            if (entry_parms->search[0] == 0)

            {

               // initialize the default search path in MKIFS_PATH

               if (MKIFS_PATH == NULL)

               {

                  MKIFS_PATH = getenv ("MKIFS_PATH"); // look in the environment first, and construct a default one if not supplied

                  if (MKIFS_PATH == NULL)

                  {

                     strcpy (processor_base, image_processor); // construct PROCESSOR_BASE

                     token = strchr (processor_base, '-');

                     if (token != NULL)

                        *token = 0; // split anything from the first dash onwards

                     data_len = strlen (processor_base);

                     if ((data_len > 2) && ((processor_base[data_len - 2] == 'b') || (processor_base[data_len - 2] == 'l')) && (processor_base[data_len - 1] == 'e'))

                        processor_base[data_len - 2] = 0; // if it ends with "le" or "be", strip that too

 

                     MKIFS_PATH = malloc (10 * MAXPATHLEN); // construct a default MKIFS_PATH now

                     if (MKIFS_PATH == NULL)

                     {

                        fprintf (stderr, "fatal error: out of memory\n");

                        exit (1);

                     }

                     sprintf (MKIFS_PATH, ".|%s/%s/sbin|%s/%s/usr/sbin|%s/%s/boot/sys|%s/%s/boot/sys|%s/%s/bin|%s/%s/usr/bin|%s/%s/lib|%s/%s/lib/dll|%s/%s/usr/lib", // use a platform-agnostic character as path separator

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, processor_base,

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, image_processor,

                                          QNX_TARGET, image_processor);

                  }

               } // at this point MKIFS_PATH is defined

 

               strcpy (entry_parms->search, MKIFS_PATH); // if entry search path is not defined, use the contents of MKIFS_PATH

            }

 

            // convert path separators in the MKIFS_PATH environment variable into something platform-agnostic

            for (token = entry_parms->search; *token != 0; token++)

               if (*token == PATH_SEP)

                  *token = '|';

 

            token = strtok (entry_parms->search, "|");

            while (token != NULL)

            {

               sprintf (candidate_pathname, "%s/%s", token, entry_data);

               if (stat (candidate_pathname, &stat_buf) == 0)

                  break;

               token = strtok (NULL, "|");

            }

            if (token == NULL)

            {

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

               exit (1);

            }

         }

 

         data_len = stat_buf.st_size;

         mtime = (uint32_t) stat_buf.st_mtime;

 

         data_buffer = malloc (data_len);

         if (data_buffer == NULL)

         {

            fprintf (stderr, "fatal error: out of memory\n");

            exit (1);

         }

         fp = fopen (candidate_pathname, "rb");

         fread (data_buffer, 1, data_len, fp);

         fclose (fp);

 

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

      }

   }

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

   {

      data_len = strlen (entry_data);

 

      data_buffer = malloc (data_len + 1);

      if (data_buffer == NULL)

      {

         fprintf (stderr, "fatal error: out of memory\n");

         exit (1);

      }

      memcpy (data_buffer, entry_data, data_len + 1); // copy including null terminator

 

      fprintf (stderr, "symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, data_buffer);

   }

   else // we must be storing a FIFO

   {

      if (strchr (entry_data, ':') == NULL)

      {

         fprintf (stderr, "fatal error: device entry \"%s\" malformed (no 'dev:rdev' pair)\n", stored_pathname);

         exit (1);

      }

 

      fprintf (stderr, "fifo: ino 0x%x uid %d gid %d mode 0%o path \"%s\" dev rdev %s)\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_data);

   }

 

   // reallocate 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 = mtime;

   if (S_ISDIR (entry_parms->st_mode))

   {

      fsentry->u.dir.path = strdup (stored_pathname);

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

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

   }

   else if (S_ISREG (entry_parms->st_mode))

   {

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

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

      fsentry->u.file.path = strdup (stored_pathname);

      fsentry->u.file.UNSAVED_databuf = data_buffer;

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

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

   }

   else if (S_ISLNK (entry_parms->st_mode))

   {

      fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname) + 1);

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

      fsentry->u.symlink.path = strdup (stored_pathname);

      fsentry->u.symlink.contents = data_buffer;

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

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

   }

   else

   {

      fsentry->u.device.dev  = strtol (entry_data, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers

      fsentry->u.device.rdev = strtol (strchr (entry_data, ':') + 1, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers

      fsentry->u.device.path = strdup (stored_pathname);

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

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

   }

   (*fsentry_count)++;

   return (*fsentry_count);

 

 

static int fsentry_compare_pathnames_cb (const void *a, const void *b)

   // qsort() callback that compares two imagefs filesystem entries and sort them alphabetically by pathname

 

   const fsentry_t *entry_a = (const fsentry_t *) a;

   const fsentry_t *entry_b = (const fsentry_t *) b;

   const char *pathname_a = (S_ISDIR (entry_a->header.mode) ? entry_a->u.dir.path : (S_ISREG (entry_a->header.mode) ? entry_a->u.file.path : (S_ISLNK (entry_a->header.mode) ? entry_a->u.symlink.path : entry_a->u.device.path)));

   const char *pathname_b = (S_ISDIR (entry_b->header.mode) ? entry_b->u.dir.path : (S_ISREG (entry_b->header.mode) ? entry_b->u.file.path : (S_ISLNK (entry_b->header.mode) ? entry_b->u.symlink.path : entry_b->u.device.path)));

   return (strcmp (pathname_a, pathname_b));

 

 

static int fsentry_compare_sizes_cb (const void *a, const void *b)

   // qsort() callback that compares two imagefs filesystem entries and sort them by increasing data size

 

   const fsentry_t *entry_a = (const fsentry_t *) a;

   const fsentry_t *entry_b = (const fsentry_t *) b;

   const int32_t size_a = (S_ISREG (entry_a->header.mode) ? entry_a->u.file.size : 0); // only files (i.e. entries wearing the S_IFREG flag) have a separate data block

   const int32_t size_b = (S_ISREG (entry_b->header.mode) ? entry_b->u.file.size : 0); // only files (i.e. entries wearing the S_IFREG flag) have a separate data block

   return ((int) size_b - (int) size_a);

 

 

int main (int argc, char **argv)

   // program entrypoint

 

   #define PAD_OUTFILE_TO(val) do { curr_offset = ftell (fp); while (curr_offset < (val)) { putc (0, fp); curr_offset++; } } while (0)

 

   static startup_header_t startup_header = { 0 }; // output IFS's startup header

   static startup_trailer_v2_t startup_trailer = { 0 }; // output IFS's startup trailer (version 2, with SHA-512 checksum and int32 checksum)

   static image_header_t image_header = { 0 }; // output IFS's imagefs header

   static image_trailer_v2_t image_trailer = { 0 }; // output IFS's imagefs trailer (version 2, with SHA-512 checksum and int32 checksum)

   static fsentry_t *fsentries = NULL; // output IFS's filesystem entries

   static size_t fsentry_count = 0; // number of entries in the IFS filesystem

   static parms_t default_parms = { 0755, 0644, 0, 0, S_IFREG, "/proc/boot", false, "", NULL, 0 }; // default parameters for a filesystem entry

   static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)

 

   // bootable IFS support

   char *bootfile_pathname = NULL;           // HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS

   size_t bootfile_size = 0;                 // HACK: size of the bootcode binary blob file to put at the start of a bootable IFS

   char *startupfile_pathname = NULL;        // HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS

   size_t startupfile_ep_from_imagebase = 0; // HACK: startup code entrypoint offset from image base for a bootable IFS

   char *kernelfile_pathname = NULL;         // HACK: pathname to precompiled kernel file blob to put in a bootable IFS

   size_t kernelfile_offset = 0;             // HACK: kernel file offset in bootable IFS

 

   char path_in_ifs[MAXPATHLEN];

   char *ifs_pathname = NULL;

   void *reallocated_ptr;

   struct stat stat_buf;

   size_t startuptrailer_offset;

   size_t startupheader_offset;

   size_t imgtrailer_offset;

   size_t imgheader_offset;

   size_t imgdir_offset;

   size_t imgdir_size;

   size_t final_size;

   size_t fsentry_index;

   size_t curr_offset;

   size_t blob_datasize; // mallocated size

   size_t blob_datalen; // used size

   uint8_t *blob_data = NULL; // mallocated

   char *line_ptr;

   char *directiveblock_start;

   char *write_ptr;

   char *token;

   char *value;

   char *sep;

   //char *ctx;

   int arg_index;

   bool is_quoted_context = false;

   bool is_escaped_char = false;

   bool want_info = false;

   bool want_help = false;

   bool is_foreign_endianness;

   int string_len;

   int read_char;

   FILE *buildfile_fp;

   FILE *fp;

 

   // parse arguments

   for (arg_index = 1; arg_index < argc; arg_index++)

   {

      if ((strcmp (argv[arg_index], "--bootfile") == 0) && (arg_index + 1 < argc)) // --bootfile path/to/blob.bin

         bootfile_pathname = argv[++arg_index];

      else if ((strcmp (argv[arg_index], "--startupfile") == 0) && (arg_index + 1 < argc)) // --startupfile path/to/blob.bin@0x1030

      {

         sep = strchr (argv[++arg_index], '@');

         if ((sep == NULL) || (sep[1] == 0))

         {

            fprintf (stderr, "error: the --startupfile arguments expects <pathname>@<entrypoint_from_image_base>\n");

            exit (1);

         }

         *sep = 0;

         startupfile_pathname = argv[arg_index];

         startupfile_ep_from_imagebase = (size_t) read_integer (sep + 1);

      }

      else if ((strcmp (argv[arg_index], "--kernelfile") == 0) && (arg_index + 1 < argc)) // --kernelfile path/to/blob.bin@0x32000

      {

         sep = strchr (argv[++arg_index], '@');

         if ((sep == NULL) || (sep[1] == 0))

         {

            fprintf (stderr, "error: the --kernelfile arguments expects <pathname>@<fileoffset>\n");

            exit (1);

         }

         *sep = 0;

         kernelfile_pathname = argv[arg_index];

         kernelfile_offset = (size_t) read_integer (sep + 1);

      }

      else if (strcmp (argv[arg_index], "--info") == 0)

         want_info = true;

      else if ((strcmp (argv[arg_index], "-?") == 0) || (strcmp (argv[arg_index], "--help") == 0))