Subversion Repositories QNX 8.QNX8 IFS tool

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

// TODO: preboot file stripping

// TODO: startup file stripping

// standard C includes

#include <stdint.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#include <limits.h>

#include <errno.h>

#include <sys/stat.h>

#include <ctype.h>

#include <time.h>

// platform-specific includes

#ifdef _MSC_VER

#include <sys/utime.h>

#include <process.h>

#else // !_MSC_VER

#include <sys/param.h>

#include <sys/sysmacros.h>

#include <sys/wait.h>

#include <unistd.h>

#include <dirent.h>

#include <utime.h>

#endif // _MSC_VER

// own includes

#include "buffer.h"

#include "sha512.h"

#include "elffile.h"

#include "ifsfile.h"

#include "utility.h"

// compiler-specific glue

#ifndef _MSC_VER

#define sscanf_s sscanf // WARNING: TRUE FOR THIS FILE ONLY!

#endif // !_MSC_VER

// libasan (Address Sanitizer) options: this is not a daemon, so I don't care about leaks: they will be recovered by the OS at program exit

const char *__asan_default_options () { return ("detect_leaks=0"); }

// placeholder value

#define WILL_BE_FILLED_LATER 0xbaadf00d // urgh

// miscellaneous macros

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

#ifdef _WIN32

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

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

#else // !_WIN32, thus POSIX

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

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

#endif // _WIN32

#define RECORD_SEP "\x1e" // arbitrarily-chosen ASCII record separator, as a C string suitable for e.g. strtok()

// macros for constructing and destructing string arrays

#define STRINGARRAY_INIT(string_array) do { (string_array)->args = NULL; (string_array)->count = 0; } while (0)

#define STRINGARRAY_PUSH(string_array,str) do { \

      reallocated_ptr = realloc ((string_array)->args, ((string_array)->count + 1) * sizeof (char *)); \

      ASSERT_WITH_ERRNO (reallocated_ptr); \

      (string_array)->args = reallocated_ptr; \

      (string_array)->args[(string_array)->count] = ((str) != NULL ? strdup ((str)) : NULL); \

      if ((str) != NULL) \

         ASSERT_WITH_ERRNO ((string_array)->args[(string_array)->count]); \

      (string_array)->count++; \

   } while (0)

#define STRINGARRAY_FREE(string_array) do { \

      if ((string_array)->args != NULL) { \

         for (array_index = 0; array_index < (string_array)->count; array_index++) \

            if ((string_array)->args[array_index] != NULL) \

               free ((string_array)->args[array_index]); \

         free ((string_array)->args); \

         (string_array)->args = NULL; \

      } \

      (string_array)->count = 0; \

   } while (0)

// string array structure type definition

typedef struct stringarray_s

{

   char **args;

   size_t count;

} stringarray_t;

// IFS directory entry insertion parameters structure type definition

typedef struct parms_s

{

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

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

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

   int gid; // owner group ID (e.g. 0 = root)

   int st_mode; // entry type (e.g. S_IFREG for files) and permissions

   uint32_t mtime; // entry's modification time POSIX timestamp - set to UINT32_MAX to use the concerned files' mtime on the build host

   uint32_t mtime_for_inline_files; // same as above but only for files that don't exist on the build host (i.e. files with an explicit content blob)

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

   bool should_follow_symlinks; // follow symlinks

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

   bool should_keep_ld_output; // whether to keep .sym files produced by ld calls, togglable by the [+keeplinked] attribute

   bool should_ignore_duplicates; // [+|-dupignore] whether to ignore duplicates

   bool should_allow_nonexistent_files; // [+|-optional] whether to continue processing on unexistent files

   bool is_bootstrap_file; // entry has the [virtual] attribute

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

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

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

   buffer_t data; // the resolved file's own data bytes

} parms_t;

// exported globals

int verbose_level = 1; // verbosity level, can be increased with multiple -v[...] flags

// global variables used in this module only

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

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

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

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

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

static uint32_t image_align = 4; // default image alignment, as per QNX docs

static uint32_t image_kernel_ino = 0;

static uint32_t image_bootscript_ino = 0;

#if defined(__x86_64__)

static char image_processor[16] = "x86_64"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

static char image_processor_base[16] = "x86_64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

#elif defined(__aarch64__)

static char image_processor[16] = "aarch64le"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

static char image_processor_base[16] = "aarch64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

#else // unknown platform

#error Please port ifstool to this platform

#endif

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

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

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

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

static char *SEARCH_PATH = NULL; // mallocated string of search paths, populated by the -r command-line argument

static char **saved_ELF_sections = NULL; // mallocated array of const strings, populated by the -s command-line argument

static size_t saved_ELF_section_count = 0; // number of elements in the saved_ELF_sections array

static char *sym_suffix = ""; // .sym files extra suffix, settable with the -a command-line argument

// bootable IFS support

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

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

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

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

static size_t kernelfile_offset = 0x32000;       // kernel file offset in the IFS (is it ever supposed to change?)

// exported function prototypes

int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer

// prototypes of local functions

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 char *resolve_envvars (const char *str); // resolves environment variables in str and replaces them with their value, or an empty string if undefined. Returns a mallocated string (caller frees)

static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar); // locates pathname among the known search paths and returns a pointer to the resolved pathname (static string)

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

static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs_data, const size_t write_offset, const fsentry_t *fsentry); // writes the given filesystem entry (without its contents) to the IFS buffer

static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, const fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer

static int Buffer_StripELFFile (buffer_t *file, const char **saved_sections, const size_t saved_section_count, const bool should_align_segsize_with_ramsize, const char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded

static void add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // stack up a new filesystem entry in the the fsentries array

static void add_directory_contents_recursively (fsentry_t **fsentries, size_t *fsentry_count, const char *dir_pathname, const size_t start_pathname_len, parms_t *default_parms); // adds the contents of the directory pointed to by dir_pathname to the fsentries array, recursively

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

static void parse_line (FILE *buildfile_fp, char *line_buffer, fsentry_t **fsentries, size_t *fsentry_count, parms_t *default_parms); // parses a line in the build file and make the relevant changes to the fsentries array

// imported function prototypes

extern int dump_ifs_info (const char *ifs_pathname, bool want_everything); // [implemented in ifsdump.c] dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error

extern int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // [implemented in ifsdump.c] dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error

extern int dump_file_hex (const char *pathname); // [implemented in ifsdump.c] dumps the contents of pathname to stdout in mixed hexadecimal + ASCII (hex editor) format

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

{

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

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

   const char *current_char_ptr;

   int32_t image_cksum;

   size_t i;

   image_cksum = 0;

   current_char_ptr = data;

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

   {

      accumulator[i % 4] = *current_char_ptr;

      if (i % 4 == 3)

         if (is_foreign_endianness)

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

         else

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

      current_char_ptr++;

   }

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

}

static long long read_integer (const char *str)

{

   // reads a number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)

   char *endptr = NULL;

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

   if (endptr != NULL)

   {

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

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

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

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

   }

   return (ret);

}

static char *resolve_envvars (const char *str)

{

   // resolves environment variables in str and replaces them with their value, or an empty string if undefined

   // returns a mallocated string (caller frees), or dies with errno

   signed int erase_index;

   void *reallocated_ptr;

   size_t replacement_len;

   size_t middlebit_len;

   size_t old_str_len;

   size_t new_str_len;

   size_t endbit_len;

   char erased_char;

   char *resolved_str;

   char *replacement;

   char *varname;

   char *endbit;

   char *token;

   resolved_str = strdup (str); // have a working copy of the input string

   ASSERT_WITH_ERRNO (resolved_str);

   while ((((token = strstr (resolved_str, "${")) != NULL) && ((endbit = strchr (token, '}')) != NULL)) // look for variables in the "${VARNAME}" format *AND* in "$VARNAME" format

          || (((token = strstr (resolved_str, "$")) != NULL) && ((middlebit_len = strspn (token, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")) != strlen (token))))

   {

      if (token[1] == '{') // "${VARNAME}" format

      {

         endbit++; // locate where the end bit begins

         varname = token + 2; // skip the leading two characters: "${"

         erase_index = -1; // we shall split the string at the character that's *just before* where the end bit starts

      }

      else // "$VARNAME" format

      {

         endbit = &token[middlebit_len]; // locate where the end bit begins

         varname = token + 1; // skip the leading '$'

         erase_index = 0; // we shall split the string at the character that's *right where* the end bit starts

      }

      old_str_len = strlen (resolved_str); // measure current string length

      endbit_len = strlen (endbit); // measure the length of the end bit (skip the closing curly brace)

      erased_char = endbit[erase_index]; // remember which is the character we're going to erase

      endbit[erase_index] = 0; // split the string at the end of the variable name

      if (strcmp (varname, "PFS") == 0)

         replacement = PATH_SEP; // special case: if it's the PFS variable, select ":" or ";" based on the host platform

      else

         replacement = getenv (varname); // peek at the environment for its value

      if (replacement == NULL)

         replacement = ""; // if this variable isn't defined, fallback to an empty string, just like what a UNIX shell does

      endbit[erase_index] = erased_char; // put the erased character back

      replacement_len = strlen (replacement); // measure replacement length

      new_str_len = (size_t) token - (size_t) resolved_str + replacement_len + endbit_len; // measure updated string len

      if (new_str_len > old_str_len)

      {

         reallocated_ptr = realloc (resolved_str, new_str_len + 1); // grow it if necessary

         ASSERT_WITH_ERRNO (reallocated_ptr);

         token = &((char *) reallocated_ptr)[token - resolved_str]; // fix the pointers that may have moved

         endbit = &((char *) reallocated_ptr)[endbit - resolved_str]; // fix the pointers that may have moved

         resolved_str = reallocated_ptr;

      }

      memmove (token + replacement_len, endbit, endbit_len + 1); // move the end bit to its final location (including its nul terminator)

      memcpy (token, replacement, replacement_len); // and patch the replacement in between

   }

   return (resolved_str); // finished, return the mallocated resolved string (caller frees)

}

static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar)

{

   // locates pathname among search path and returns resolved pathname (static buffer) or NULL.

   typedef struct default_path_s { bool uses_processor_base; char *subpath; } default_path_t;

   static const default_path_t default_paths[] =

   {

      { false, "/sbin"     }, // prefix with $PROCESSOR/

      { false, "/usr/sbin" }, // prefix with $PROCESSOR/

      { false, "/boot/sys" }, // prefix with $PROCESSOR/

      { true,  "/boot/sys" }, // prefix with $PROCESSOR_BASE/

      { false, "/bin"      }, // prefix with $PROCESSOR/

      { false, "/usr/bin"  }, // prefix with $PROCESSOR/

      { false, "/lib"      }, // prefix with $PROCESSOR/

      { false, "/lib/dll"  }, // prefix with $PROCESSOR/

      { false, "/usr/lib"  }  // prefix with $PROCESSOR/

   };

   static thread_local char *resolved_pathname = NULL;

   char *pathname_without_envvars;

   char *resolved_search_path;

   size_t defaultpath_index;

   struct stat stat_buf;

   char *nextsep;

   char *token;

   // resolve possible environment variables in pathname

   pathname_without_envvars = resolve_envvars (pathname);

   // NOTE: the QNX documentation states:

   // "- If path starts with a slash (/) on a Linux development host, or a disk volume label (i.e., drive letter and a colon) followed by a backslash (\) on a Windows host, the path is absolute and mkifs looks for the file at that exact host location. [...]

   //  - If path contains a slash or backslash character that's not at the start, the path is relative and mkifs tries to resolve it relative to the current working directory (CWD).

   //  - If path does not contain a directory separator or the file could not be found relative to the CWD, mkifs tries to resolve it relative to all directories given in the search attribute, in succession."

   // is it an absolute pathname (POSIX and Windows variants) ?

   if (IS_DIRSEP (pathname_without_envvars[0])

#ifdef _WIN32

       || (isalpha (pathname_without_envvars[0]) && (pathname_without_envvars[1] == ':') && IS_DIRSEP (pathname_without_envvars[2]))

#endif // _WIN32

       )

      return (pathname_without_envvars); // in this case, it MUST exist at its designated location

   // else is it a relative pathname ?

   else if (((strchr (pathname_without_envvars, '/') != NULL)

#ifdef _WIN32

             || (strchr (pathname_without_envvars, '\\') != NULL)

#endif // _WIN32

            ) && (stat (pathname_without_envvars, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))

      return (pathname_without_envvars); // in this case, see if it exists relatively to the current working directory, and if it does, return it

   // what we've been given is just a basename, so search it among the search paths we have

   // QNX docs:

   // When searching for host files to be included in the image, search the default paths used for storing binaries within the specified directory before searching the default paths within $QNX_TARGET.

   // You can define multiple -r options; each adds a set of paths to search for files.

   // The -r options are evaluated from left to right meaning the paths prefixed with the first (leftmost) rootdir are searched first, then those prefixed with the second rootdir, and so on.

   // Normally, mkifs searches any paths defined in $MKIFS_PATH when it was called and then the default paths within $QNX_TARGET.

   // The default paths are based on the CPU architecture specified by $PROCESSOR and $PROCESSOR_BASE.

   // If you specify -r options, mkifs searches the default paths prefixed with each dir variable before searching those within $QNX_TARGET.

   // These paths are:

   //   dir/${PROCESSOR}/sbin

   //   dir/${PROCESSOR}/usr/sbin

   //   dir/${PROCESSOR}/boot/sys

   //   dir/${PROCESSOR_BASE}/boot/sys

   //   dir/${PROCESSOR}/bin

   //   dir/${PROCESSOR}/usr/bin

   //   dir/${PROCESSOR}/lib

   //   dir/${PROCESSOR}/lib/dll

   //   dir/${PROCESSOR}/usr/lib

   // NOTE: The structure of the directory paths under dir must be identical to that of the default paths under $QNX_TARGET, but the root dir itself may be any path you choose.

   // For example, if you wanted to include /scratch/aarch64le/sbin/devb-sata, you would specify a -r option like this:

   //   -r /scratch

   // Note that you don't include $PROCESSOR or $PROCESSOR_BASE in dir.

   //  - search all paths in explicit path/[default paths] (if explicit path supplied)

   //  - search all paths in (-r flags if have some|MKIFS_PATH)/[default paths] (if no explicit path supplied)

   //  - search all paths in $QNX_TARGET/[default paths]

   // initial allocation (per thread)

   if (resolved_pathname == NULL)

   {

      resolved_pathname = malloc (MAXPATHLEN);

      ASSERT_WITH_ERRNO (resolved_pathname);

   }

   // if no file-specific explicit search path was supplied, use the path list supplied by the -r command-line arguments, else fallback to MKIFS_PATH if we don't have any

   if (search_paths_or_NULL_for_MKIFS_PATH_envvar == NULL)

      search_paths_or_NULL_for_MKIFS_PATH_envvar = (SEARCH_PATH != NULL ? SEARCH_PATH : getenv ("MKIFS_PATH"));

   // construct a potential final path using each element of the search path

   if (search_paths_or_NULL_for_MKIFS_PATH_envvar != NULL)

   {

      // the first step is to resolve all environment variables in the search path

      resolved_search_path = resolve_envvars (search_paths_or_NULL_for_MKIFS_PATH_envvar);

      // now split this search path string into multiple tokens and process them one after the other

      token = (*resolved_search_path != 0 ? resolved_search_path : NULL);

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

      while (token != NULL)

      {

         // look under this search path at each of the known subpaths

         for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)

         {

            sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s/%s/%s", (int) (nextsep - token), token, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname_without_envvars);

            if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))

            {

               free (pathname_without_envvars);

               return (resolved_pathname); // if a file can indeed be found at this location, stop searching

            }

         }

         token = (*nextsep != 0 ? nextsep + 1 : NULL);

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

      }

   }

   // file not found in search paths: look under QNX_TARGET at each of the known subpaths

   for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)

   {

      sprintf_s (resolved_pathname, MAXPATHLEN, "%s/%s/%s/%s", QNX_TARGET, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname_without_envvars);

      if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))

      {

         free (pathname_without_envvars);

         return (resolved_pathname); // if a file can indeed be found at this location, stop searching

      }

   }

   free (pathname_without_envvars);

   errno = ENOENT; // we exhausted all possibilities

   return (NULL); // file not found, return with ENOENT

}

static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs, const size_t write_offset, const fsentry_t *fsentry)

{

   // writes a directory entry in the image filesystem buffer pointed to by ifs at write_offset (or fakes so if ifs is NULL)

   // and return the number of bytes written (or that would have been written)

   static const uint8_t zeropad_buffer[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";

   size_t datalen;

   size_t count;

   count = 0;

   if (ifs != NULL)

      ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->header, sizeof (fsentry->header))); // write the entry header (PACKED STRUCT)

   count += sizeof (fsentry->header);

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

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.file.offset, sizeof (uint32_t))); // write offset

      count += sizeof (uint32_t);

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.file.size,   sizeof (uint32_t))); // write size

      count += sizeof (uint32_t);

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

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.file.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

   }

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

   {

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

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.dir.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

   }

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

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.symlink.sym_offset, sizeof (uint16_t))); // write offset

      count += sizeof (uint16_t);

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.symlink.sym_size,   sizeof (uint16_t))); // write size

      count += sizeof (uint16_t);

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

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.symlink.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

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

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.symlink.contents, datalen)); // write null-terminated symlink contents

      count += datalen;

   }

   else

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.device.dev,  sizeof (uint32_t))); // write dev number

      count += sizeof (uint32_t);

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.device.rdev, sizeof (uint32_t))); // write rdev number

      count += sizeof (uint32_t);

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

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.device.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

   }

   ASSERT (count <= fsentry->header.size, "attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.", (size_t) fsentry->header.size, count);

   if (count < fsentry->header.size)

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, zeropad_buffer, fsentry->header.size - count)); // pad as necessary

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

   }

   return (count);

}

static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, const fsentry_t *fsentry)

{

   // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer

   elf_program_header_t *phdr;

   elf_header_t *elf;

   size_t fixed_physical_addr;

   size_t corrective_offset;

   //size_t segment_type;

   size_t size_in_memory;

   size_t table_index;

   size_t table_count;

   size_t data_offset;

   ASSERT (S_ISREG (fsentry->header.mode), "function called for invalid dirent"); // consistency check

   data_offset = ifs_data->size; // see where we are

   // is the file we're storing a preprocessed ELF file ?

   if (fsentry->header.ino & IFS_INO_PROCESSED_ELF)

   {

      elf = (elf_header_t *) fsentry->u.file.UNSAVED_databuf; // quick access to ELF header

      table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers

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

      {

         phdr = (elf_program_header_t *) &fsentry->u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header

         //segment_type = ELF_GET_NUMERIC (elf, phdr, segment_type); // get segment type

         //if (!((segment_type >= 2) && (segment_type <= 7) || ((segment_type >= 0x6474e550) && (segment_type <= 0x6474e552)) || (segment_type == 0x70000001)))

         //   continue; // NOTE: only certain segments types must be corrected

         corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);

         size_in_memory = ELF_GET_NUMERIC (elf, phdr, size_in_memory); // get this ELF segment's occupied size in memory

         if (size_in_memory != 0) // only patch the physical address of segments that have an actual size in memory

         {

            fixed_physical_addr = ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + data_offset - corrective_offset;

            ELF_SET_NUMERIC (elf, phdr, physical_addr, fixed_physical_addr); // patch the physical address member of the program header table (NOTE: data_offset is the location where the file data is about to be written)

         }

      }

   }

   ASSERT_WITH_ERRNO (Buffer_Append (ifs_data, fsentry->u.file.UNSAVED_databuf, fsentry->u.file.size)); // write file data blob

   return (ifs_data->size - data_offset); // return the number of bytes written

}

static inline size_t Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (buffer_t *buffer, const char *str)

{

   // helper function used in add_fsentry(): locates or appends str to buffer and returns its relative offset in the buffer

   size_t str_len_including_terminator = strlen (str) + 1;

   void *occurrence = Buffer_FindFirst (buffer, str, str_len_including_terminator);

   if (occurrence == NULL)

   {

      ASSERT_WITH_ERRNO (Buffer_Append (buffer, str, str_len_including_terminator));

      occurrence = Buffer_FindFirst (buffer, str, str_len_including_terminator);

      ASSERT_WITH_ERRNO (occurrence);

   }

   return (Buffer_OffsetOf (buffer, occurrence)); // can't fail

}

static int Buffer_StripELFFile (buffer_t *file, const char **saved_sections, const size_t saved_section_count, const bool should_align_segsize_with_ramsize, const char *indicative_pathname)

{

   // NOTE: for each ELF file, mkifs

   // -> alters the program header table and offsets each p_addr (physical address) member by <image_base> plus the current file offset (this cannot be done right now, will need to be done once they are known)

   // -> throws away and reconstructs the sections table by keeping only the sections that are in the program header, and writes the section table at the start of the first thrown-away section

   // FIXME: what if a thrown away section is located between two program segments ? are they collapsed, moving the segments beyond it one slot down ?

   // reconstructed ELF:

   // ==== START OF FILE ====

   // ELF header

   // program header table

   //  (same sections, just p_addr offset changed)

   // section data 5 (named ".note.gnu.build-id")

   //  "............GNU....ZY.....c.o..l"

   // PROGRAM

   // sections table

   // + section 1: ALL ZEROES

   // + section 2: fileoffs 0x21a8 size 0xfd --> "QNX_info" --> QNX binary description: "NAME=pci_debug2.so.3.0\nDESCRIPTION=PCI Server System Debug Module\nDATE=2023/11/19-10:01:13-EST\nSTATE=lookup\nHOST=docker-n1.bts.rim.net\nUSER=builder\nVERSION=QNXOS_main\nTAGID=QNXOS_800-135\nPACKAGE=com.qnx.qnx800.target.pci.debug/3.0.0.00135T202311191043L\n"

   // + section 3: fileoffs 0x22a5 size 0x1c --> ".gnu_debuglink" --> indicates the debug file and its checksum: "pci_debug2.so.3.0.sym" "\0\0\0" "VX2p"

   // + section 4: fileoffs 0x22c1 size 0x2ad --> "QNX_usage" --> HELP TEXT: "\n-------------------------------------------------------------------------------\n%C\n\nThis module implements debug logging for all PCI server modules. It is\nincluded by setting the environment variable PCI_DEBUG_MODULE and uses\nthe slogger2 APIs.\nNOTE:.On systems which support slogger2, you are encouraged to use this module.instead of pci_debug.so...Release History.---------------..3.0 - This module is functionally equivalent to the previous 2.x version.      however it is incompatible with all pre v3.x PCI components..2.1 - fixes a bug whereby if slogger2 is not running and the PCI_DEBUG_MODULE.      environment variable is set, the client will SIGSEGV..2.0 - initial release.."

   // + section 5: fileoffs 0x190 size 0x32 --> ".note.gnu.build-id" --> GNU build ID

   // + section 6: fileoffs 0x256e size 0x40 --> ".shstrtab" --> sections names strings table

   // section data 2 (named "QNX_info")

   //  (QNX binary description)

   // section data 3 (named ".gnu_debuglink")

   //  (debug file)

   // section data 4 (named "QNX_usage")

   //  (help text)

   // section data 6 (named ".shstrtab")

   //  "\0"

   //  ".shstrtab\0"

   //  "QNX_info\0"

   //  ".gnu_debuglink\0"

   //  "QNX_usage\0"

   //  ".note.gnu.build-id\0"

   // ==== END OF FILE ====

   #define ELFHDR ((elf_header_t *) file->bytes) // this convenient definition will make sure the ELF header points at the right location, even after entry_parms.data->byte is reallocated

   #define ADD_SECTION(section_name,section_ptr) do { \

      void *reallocated_ptr = realloc (elf_sections, (elf_section_count + 1) * sizeof (elf_section_t)); \

      ASSERT_WITH_ERRNO (reallocated_ptr); \

      elf_sections = reallocated_ptr; \

      elf_sections[elf_section_count].name = (section_name); \

      Buffer_Initialize (&elf_sections[elf_section_count].data); \

      *(section_ptr) = &elf_sections[elf_section_count]; \

      elf_section_count++; \

   } while (0)

   typedef struct elf_section_s

   {

      const char *name;

      elf_section_header_t header;

      buffer_t data;

   } elf_section_t;

   const elf_section_header_t *shdr;

   elf_program_header_t *phdr;

   elf_program_header_t *other_phdr;

   elf_section_t *elf_sections = NULL; // mallocated

   elf_section_t *elf_section = NULL;

   size_t elf_section_count = 0;

   size_t new_shdrtable_offset;

   size_t new_shdrtable_len;

   size_t sectiondata_start;

   size_t sectiondata_size;

   size_t size_in_memory;

   size_t size_in_file;

   size_t file_offset;

   size_t array_index;

   size_t table_index;

   size_t table_count;

   size_t page_size;

   // find out the platform page size

   if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_X86_64)

      page_size = 4 * 1024; // 4 kb pages on Intel processors

   else if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_AARCH64)

      page_size = 16 * 1024; // 16 kb pages on ARM64

   else

   {

      errno = ENOTSUP; // unsupported architecture: set errno to something meaningful

      return (0); // and return an error value

   }

   // if we should align the segment sizes in the ELF file with their occupied memory size (such is the case for e.g. procnto), do that first

   table_count = ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_len); // get the number of program headers

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

   {

      phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // quick access to program header

      file_offset    = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset); // get this ELF segment's start offset in the ELF file

      size_in_memory = ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory); // get this ELF segment's occupied size in memory

      size_in_file   = ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // get this ELF segment's occupied size in the ELF file

      if (should_align_segsize_with_ramsize && (size_in_memory != size_in_file)) // should we align this segment's file size with its claimed RAM size ? (such is the case for e.g. procnto)

      {

         if (size_in_memory > size_in_file) // is it bigger ? if so, make sure we won't be overwriting other segments beyond this one

         {

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

            {

               other_phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * array_index]; // quick access to program header

               if (other_phdr == phdr)

                  continue; // skip self

               if (ELF_GET_NUMERIC (ELFHDR, other_phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, other_phdr, size_in_file) < file_offset)

                  continue; // skip segments that are located before this one

               if (ELF_GET_NUMERIC (ELFHDR, other_phdr, file_offset) > file_offset + size_in_memory)

                  continue; // skip segments that are located after this one, including its corrected size

               DIE_WITH_EXITCODE (1, "remapping ELF segment would overwrite segment #%zd in the same file", array_index);

            }

            // finally, memset() the extra area

            Buffer_WriteAt (file, file_offset + size_in_memory, NULL, 0); // reallocate the ELF file data buffer if necessary

            phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // restore access to program header (which may have moved)

            memset (&file->bytes[file_offset + size_in_file], 0, size_in_memory - size_in_file); // and write zeroes over the extra space

         }

         ELF_SET_NUMERIC (ELFHDR, phdr, size_in_file, size_in_memory); // patch this segment's size in the ELF file so that it matches the RAM size

      }

   }

   // now parse the program header table, and measure the farthest offset known by this table where we'll write the reconstructed section headers table

   new_shdrtable_offset = 0;

   table_count = ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_len);

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

   {

      phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // quick access to program header

      if (ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file) > new_shdrtable_offset)

         new_shdrtable_offset = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // keep track of the farthest offset known by the program headers table

   }

   /*

   size_t new_shdrtable_offset_method2 = 0;

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

   {

      phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // quick access to program header

      size_t segment_type = ELF_GET_NUMERIC (ELFHDR, phdr, segment_type); // get segment type

      if (!((segment_type >= 2) && (segment_type <= 7)))

         continue; // NOTE: only certain segments types must be corrected

      if (ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory) > new_shdrtable_offset_method2)

         new_shdrtable_offset_method2 = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory);

   }