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

// TODO: boot script compiler

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

#define INITIAL_STARTUP_SCRIPT \

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

   "\x34\x00" /*size*/ "\x04" /*type*/ "\x00" /*spare*/ "/proc/boot/ldqnx-64.so.2\0" "/usr/lib/ldqnx-64.so.2\0" \

   /* sh /proc/boot/startup.sh */ \

   "\x88\x00" /*size*/ "\x00" /*type*/ "\x00" /*spare*/ "\x00" /*CPU mask*/ "\x00" /*flags*/ "\x00\x00" /*reserved*/ "\x00" /*policy*/ "\x00" /*priority*/ "\02" /*argc*/ "\x02" /*envc*/ "sh\0" /*executable*/ "sh\0" "/proc/boot/startup.sh\0" /*argv*/ "PATH=/sbin:/usr/sbin:/bin:/usr/bin:/proc/boot\0" "LD_LIBRARY_PATH=/proc/boot:/lib:/lib/dll:/usr/lib\0" /*envp*/ \

   /* display_msg "Startup complete */ \

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

   /* trailer */ \

   "\x00\x00\x00\x00"

// 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;           // HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS

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

static char *startupfile_pathname = NULL;        // 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; // 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_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_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;

   void *reallocated_ptr;

   char *resolved_search_path;

   char *replacement;

   size_t old_searchpath_len;

   size_t new_searchpath_len;

   size_t replacement_len;

   size_t middlebit_len;

   size_t endbit_len;

   size_t defaultpath_index;

   struct stat stat_buf;

   int erase_index;

   char erased_char;

   char *varname;

   char *nextsep;

   char *endbit;

   char *token;

   // initial allocation (per thread)

   if (resolved_pathname == NULL)

   {

      resolved_pathname = malloc (MAXPATHLEN);

      ASSERT_WITH_ERRNO (resolved_pathname);

   }

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

   if (IS_DIRSEP (pathname[0])

#ifdef _WIN32

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

#endif // _WIN32

       )

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

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

   {

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

      // 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 = strdup (search_paths_or_NULL_for_MKIFS_PATH_envvar);

         ASSERT_WITH_ERRNO (resolved_search_path);

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

                || (((token = strstr (resolved_search_path, "$")) != 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_searchpath_len = strlen (resolved_search_path); // 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

            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_searchpath_len = (size_t) token - (size_t) resolved_search_path + replacement_len + endbit_len; // measure updated search path len

            if (new_searchpath_len > old_searchpath_len)

            {

               reallocated_ptr = realloc (resolved_search_path, new_searchpath_len + 1); // grow it if necessary

               ASSERT_WITH_ERRNO (reallocated_ptr);

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

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

               resolved_search_path = 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

         }

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

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

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

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

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

      }

   }

   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

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

   }

   if (new_shdrtable_offset_method2 > new_shdrtable_offset)

      LOG_DEBUG ("METHOD2: %llx > %llx", new_shdrtable_offset_method2, new_shdrtable_offset);*/

   //new_shdrtable_offset = ROUND_TO_UPPER_MULTIPLE (new_shdrtable_offset, page_size); // round to page size

   // re-create the section header table

   ADD_SECTION (".shstrtab", &elf_section); // the first section will be the section names strings table

   ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&elf_section->data, "\0")); // initialize an empty section headers strings table

   ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&elf_section->data, ".shstrtab\0")); // append ".shstrtab" *INCLUDING* its null terminator

   // go through the saved sections array and see if such an ELF section is present in the ELF file

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

      if ((shdr = elf_get_section_header_by_name (ELFHDR, saved_sections[array_index])) != NULL) // does this ELF have such a section ?

      {

         ADD_SECTION (saved_sections[array_index], &elf_section); // yes, so save it

         sectiondata_start = ELF_GET_NUMERIC (ELFHDR, shdr, file_offset); // identify section data start offset

         sectiondata_size = ELF_GET_NUMERIC (ELFHDR, shdr, size); // identify section data length

         if (sectiondata_start + sectiondata_size >= new_shdrtable_offset) // should this section be moved ?

            ASSERT_WITH_ERRNO (Buffer_InitWithData (&elf_section->data, &file->bytes[sectiondata_start], sectiondata_size)); // have a copy of this section's data

         else

            Buffer_Initialize (&elf_section->data); // this section is located before the place where we'll write the new section headers table, thus it doesn't need to be moved

         //LOG_DEBUG ("%s: section '%s' start 0x%llx len 0x%llx", indicative_pathname, saved_ELF_sections[array_index], (unsigned long long) sectiondata_start, (unsigned long long) sectiondata_size);

         // prepare this section's "fixed" header

         memcpy (&elf_section->header, shdr, ELF_STRUCT_SIZE (ELFHDR, shdr)); // have a copy of the old section header first

         ELF_SET_NUMERIC (ELFHDR, &elf_section->header, name_offset, Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (&elf_sections[0].data, elf_section->name)); // make sure this section name is in the ELF sections section header strings table and update the relative offset of the section name

      }

   // jump over the new section headers table and write the saved sections data after the section headers table

   file->size = new_shdrtable_offset + (1 + elf_section_count) * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header); // start by truncating the ELF file: assume there are no sections beyond the section headers table until known otherwise

   for (table_index = 1; table_index < elf_section_count; table_index++)

   {

      elf_section = &elf_sections[table_index]; // quick access to ELF section about to be written

      if (elf_section->data.bytes != NULL) // was this section data backed up waiting to be relocated ?

      {

         ELF_SET_NUMERIC (ELFHDR, &elf_section->header, file_offset, file->size); // fix section offset

         Buffer_AppendBuffer (file, &elf_section->data); // append this section's data to the ELF file

      }

   }

   // write the section header strings table as the last section

   elf_section = &elf_sections[0]; // quick access to ELF section about to be written

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, name_offset, Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (&elf_sections[0].data, elf_section->name)); // update the relative offset of the section name

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, type, ELF_SECTIONTYPE_STRINGTABLE); // section type (SHT_STRTAB)