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

   {

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

      {

         uint32_t offset; // offset from header

         uint32_t size;

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

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

      } file;

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

      {

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

      } dir;

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

      {

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

         uint16_t sym_size; // strlen (contents)

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

         char *contents; // null terminated symlink contents

      } symlink;

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

      {

         uint32_t dev;

         uint32_t rdev;

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

      } device;

   } u;

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

} fsentry_t;

 

 

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

 

 

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;

 

 

 

 

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

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

} 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 int update_checksum_int32s (const int32_t start_value, const int32_t *data, const size_t len); // update the sum of an array of 32-bit signed integers

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

   // computes the SHA-512 hash of a block of data in one pass and write it to digest

 

   SHA512_CTX ctx;

   SHA512_Init (&ctx);

   SHA512_Update (&ctx, data, data_len);

   SHA512_Final (digest, &ctx);

   return (digest);

 

 

static int update_checksum_int32s (const int32_t start_value, const int32_t *data, const size_t len)

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

 

   size_t byte_index;

   int32_t sum = start_value;

   for (byte_index = 0; byte_index < len; byte_index += sizeof (int32_t))

      sum += *data++;

   return (sum);

 

 

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 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 = 0;

   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

            if (stat ("procnto-smp-instr.bin", &stat_buf) != 0)

            {

               fprintf (stderr, "fatal error: unable to read procnto-smp-instr.bin\n");

               exit (1);

            }

            data_len = stat_buf.st_size;

            mtime = (uint32_t) time (NULL);

            data_buffer = malloc (data_len);

            if (data_buffer == NULL)

            {

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

               exit (1);

            }

            fp = fopen ("procnto-smp-instr.bin", "rb");

            fread (data_buffer, 1, data_len, fp);

            fclose (fp);

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

            stored_pathname = candidate_pathname;

            extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE;

            image_kernel_ino = extra_ino_flags | (inode_count + 1);

         }

         else if (entry_parms->should_compile_contents_as_startup_script) // should we compile this contents as a startup script ?

         {

            // HACK: for now just use a precompiled script

            // FIXME: replace this with a true compilation with the rules defined above

            data_buffer = malloc (INITIAL_STARTUP_SCRIPT_LEN);

            if (data_buffer == NULL)

            {

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

               exit (1);

            }

            memcpy (data_buffer, INITIAL_STARTUP_SCRIPT, INITIAL_STARTUP_SCRIPT_LEN);

            data_len = INITIAL_STARTUP_SCRIPT_LEN;

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

         }

         else // else it's an explicit blob of some other sort

         {

            data_len = entry_datalen;

            mtime = (uint32_t) time (NULL);

 

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

      mtime = (uint32_t) time (NULL);

 

      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

 

   fsentry_t *entry_a = (fsentry_t *) a;

   fsentry_t *entry_b = (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 alphabetically by pathname

 

   fsentry_t *entry_a = (fsentry_t *) a;

   fsentry_t *entry_b = (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)

 

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

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

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

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

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

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

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

   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

   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 image_bootfile[MAXPATHLEN];

   size_t image_bootfilesize = 0;

   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;

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

         want_help = true;

      else if (buildfile_pathname == NULL)

         buildfile_pathname = argv[arg_index];

      else if (ifs_pathname == NULL)

         ifs_pathname = argv[arg_index];

   }

 

   // do we not have enough information to run ?

   if (want_help || (ifs_pathname == NULL) || (!want_info && (buildfile_pathname == NULL)))

   {

      if (want_help)

         fprintf (stdout, "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");

      else

         fprintf (stderr, "error: missing parameters\n");

      fprintf ((want_help ? stdout : stderr), "usage:\n");

      fprintf ((want_help ? stdout : stderr), "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] <buildfile> <outfile>\n");

      fprintf ((want_help ? stdout : stderr), "    ifstool --info <ifs file>\n");

      fprintf ((want_help ? stdout : stderr), "    ifstool --help\n");

      exit (want_help ? 0 : 1);

   }

 

   // make sure we have ${QNX_TARGET} pointing somewhere

   QNX_TARGET = getenv ("QNX_TARGET");

   if (QNX_TARGET == NULL)

   {

      fprintf (stderr, "error: the QNX_TARGET environment variable is not set\n");

      exit (1);

   }

   else if (access (QNX_TARGET, 0) != 0)

   {

      fprintf (stderr, "error: the QNX_TARGET environment variable doesn't point to an existing directory\n");

      exit (1);

   }

 

   // open build file

   buildfile_fp = fopen (buildfile_pathname, "rb");

   if (buildfile_fp == NULL)

   {

      fprintf (stderr, "error: unable to open build file \"%s\" for reading (%s)\n", buildfile_pathname, strerror (errno));

      exit (1);

   }

 

   // stack up filesystem entries

   memcpy (&entry_parms, &default_parms, sizeof (default_parms));

   entry_parms.st_mode = S_IFDIR | default_parms.dperms;

   add_fsentry (&fsentries, &fsentry_count, "", &entry_parms, NULL, 0); // add the root dir first

 

   while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)

   {

      lineno++; // keep track of current line number

      //fprintf (stderr, "read buildfile line %d: {%s}\n", lineno, line_buffer);

 

      line_ptr = line_buffer;

      while ((*line_ptr != 0) && isspace (*line_ptr))

         line_ptr++; // skip leading spaces

 

      if ((*line_ptr == 0) || (*line_ptr == '#'))

         continue; // skip empty or comment lines

 

      string_len = (int) strlen (line_buffer);

      if ((string_len > 0) && (line_buffer[string_len - 1] == '\n'))

         line_buffer[string_len - 1] = 0; // chop off newline for easier debug output

 

      // reset entry values

      memcpy (&entry_parms, &default_parms, sizeof (default_parms));

 

      //fprintf (stderr, "parsing buildfile line %d: [%s]\n", lineno, line_ptr);

 

      // does this line start with an attribute block ?

      if (*line_ptr == '[')

      {

         line_ptr++; // skip the leading square bracket

         directiveblock_start = line_ptr; // remember where it starts

         is_quoted_context = false;

         while ((*line_ptr != 0) && !((*line_ptr == ']') && (line_ptr[-1] != '\\')))

         {

            if (*line_ptr == '"')

               is_quoted_context ^= true; // remember when we're between quotes

            else if (!is_quoted_context && (*line_ptr == ' '))

               *line_ptr = RECORD_SEP; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting

            line_ptr++; // reach the next unescaped closing square bracket

         }

         if (*line_ptr != ']')

         {

            fprintf (stderr, "warning: syntax error in \"%s\" line %d: unterminated attributes block (skipping)\n", buildfile_pathname, lineno);

            continue; // invalid attribute block, skip line

         }

         *line_ptr = 0; // end the attribute block so that it is a parsable C string

 

         // now parse the attribute tokens

         // DOCUMENTATION: https://www.qnx.com/developers/docs/8.0/com.qnx.doc.neutrino.utilities/topic/m/mkifs.html#mkifs__description

         token = strtok (directiveblock_start, RECORD_SEP_STR);

         while (token != NULL)

         {

            // evaluate attribute token

            #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)

            if      (strncmp (token, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.uid     = (int) read_integer (value); }

            else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.gid     = (int) read_integer (value); }

            else if (strncmp (token, "dperms=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms.dperms  = (int) read_integer (value); }

            else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms.perms   = (int) read_integer (value); }

            else if (strncmp (token, "type=",    5) == 0) { REACH_TOKEN_VALUE (); entry_parms.st_mode = (strcmp (value, "dir") == 0 ? S_IFDIR : (strcmp (value, "file") == 0 ? S_IFREG : (strcmp (value, "link") == 0 ? S_IFLNK : (strcmp (value, "fifo") == 0 ? S_IFIFO : (fprintf (stderr, "warning: invalid 'type' attribute in \"%s\" line %d: '%s', defaulting to 'file'\n", buildfile_pathname, lineno, value), S_IFREG))))); }

            else if (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); strcpy (entry_parms.prefix, (*value == '/' ? value + 1 : value)); } // skip possible leading slash in prefix

            else if (strncmp (token, "image=",   6) == 0) { REACH_TOKEN_VALUE ();

               image_base = (uint32_t) read_integer (value); // read image base address

               if ((sep = strchr (value, '-')) != NULL) image_end       = (uint32_t) read_integer (sep + 1); // if we have a dash, read optional image end (FIXME: check this value and produce an error in the relevant case. Not important.)

               if ((sep = strchr (value, ',')) != NULL) image_maxsize   = (uint32_t) read_integer (sep + 1); // if we have a comma, read optional image max size

               if ((sep = strchr (value, '=')) != NULL) image_totalsize = (uint32_t) read_integer (sep + 1); // if we have an equal sign, read optional image padding size

               if ((sep = strchr (value, '%')) != NULL) image_align     = (uint32_t) read_integer (sep + 1); // if we have a modulo sign, read optional image aligmnent

               fprintf (stderr, "info: image 0x%x-0x%x maxsize %d totalsize %d align %d\n", image_base, image_end, image_maxsize, image_totalsize, image_align);

            }

            else if (strncmp (token, "virtual=", 8) == 0) { REACH_TOKEN_VALUE ();

               if ((bootfile_pathname == NULL) || (startupfile_pathname == NULL) || (kernelfile_pathname == NULL)) // HACK until I figure out how to re-create them

               {

                  fprintf (stderr, "error: creating bootable images require the --bootfile, --startupfile and --kernelfile command-line options in \"%s\" line %d\n", buildfile_pathname, lineno);

                  exit (1);

               }

               if ((sep = strchr (value, ',')) != NULL) // do we have a comma separating (optional) processor and boot file name ?

               {

                  *sep = 0;

                  strcpy (image_processor, value); // save processor

                  value = sep + 1;

               }

               //sprintf (image_bootfile, "%s/%s/boot/sys/%s.boot", QNX_TARGET, image_processor, value); // save preboot file name (FIXME: we should search in MKIFS_PATH instead of this. Not important.)

               strcpy (image_bootfile, bootfile_pathname); // FIXME: HACK

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

               {

                  fprintf (stderr, "error: unable to stat the boot file \"%s\" specified in \"%s\" line %d: %s\n", image_bootfile, buildfile_pathname, lineno, strerror (errno));

                  exit (1);

               }

               image_bootfilesize = stat_buf.st_size; // save preboot file size

               fprintf (stderr, "info: processor \"%s\" bootfile \"%s\"\n", image_processor, image_bootfile);

            }

            else if (strcmp (token, "+script") == 0) entry_parms.should_compile_contents_as_startup_script = true;

            else fprintf (stderr, "warning: unimplemented attribute in \"%s\" line %d: '%s'\n", buildfile_pathname, lineno, token);