WebSVN – QNX 8.QNX8 IFS tool – Diff – //ifstool.c

 #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
    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)
 // 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 char *kernelfile_pathname = NULL;         // HACK: pathname to precompiled kernel file blob to put in a bootable IFS
-static size_t kernelfile_offset = 0;             // HACK: kernel file offset in 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, fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. 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 char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded
+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
    return (count);
+}
-static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, fsentry_t *fsentry)
+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 segment_size;
+   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)
+   if (fsentry->header.ino & IFS_INO_PROCESSED_ELF)
-#ifndef PROCNTO_WIP
-      && (strstr (fsentry->u.file.path, "/procnto-smp-instr") == NULL)
-#endif // !PROCNTO_WIP
-       )
+   {
       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++)
          //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);
-         segment_size = ELF_GET_NUMERIC (elf, phdr, size_in_memory); // get this ELF segment's occupied size in memory
+         size_in_memory = ELF_GET_NUMERIC (elf, phdr, size_in_memory); // get this ELF segment's occupied size in memory
-         if (segment_size != 0) // only patch the physical address of segments that have an actual 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)
+         }
+      }
+   }
    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 char *indicative_pathname)
+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 ?
       const char *name;
       elf_section_header_t header;
       buffer_t data;
    } elf_section_t;
-   const elf_program_header_t *phdr;
    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;
+   {
       errno = ENOTSUP; // unsupported architecture: set errno to something meaningful
       return (0); // and return an error value
+   }
-   // parse the program header table, and measure the farthest offset known by this table where we'll write the reconstructed section headers table
+   // 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
+}
 static void add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
+   #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)
+   typedef struct stringarray_s
+   {
+      char **args;
+      size_t count;
+   } stringarray_t;
    static thread_local char *candidate_pathname = NULL;
    static int inode_count = 0; // will be preincremented each time this function is called
+   stringarray_t global_argv = { NULL, 0 };
+   stringarray_t global_envp = { NULL, 0 };
+   stringarray_t line_argv = { NULL, 0 };
+   stringarray_t line_envp = { NULL, 0 };
+   stringarray_t startup_argv = { NULL, 0 };
+   stringarray_t startup_envp = { NULL, 0 };
+   stringarray_t procnto_argv = { NULL, 0 };
+   stringarray_t procnto_envp = { NULL, 0 };
+   stringarray_t linker_argv = { NULL, 0 };
    const char *stored_pathname_without_leading_slash;
    const char *original_stored_pathname = NULL;
+   buffer_t current_line;
    buffer_t *shstrtab = NULL;
    const char *canonical_dylib_name;
    const char *dynamic_strings; // strings table of the ".dynamic" section
    const char *last_dirsep;
-   char *global_envstring = NULL;
+   size_t array_index;
-   size_t global_envstring_len = 0;
+   size_t line_index;
    size_t fsentry_index;
-   char *startup_name = NULL;
-   char *procnto_name = NULL;
    char *resolved_pathname;
+   char *linebit_start;
+   char *write_ptr;
+   char *read_ptr;
+   char *token;
+   char *value;
+   char *ctx;
    void *reallocated_ptr;
    void *old_data;
+   bool is_quoted_context;
+   bool is_end_of_line;
    struct stat stat_buf;
    fsentry_t *fsentry;
    int retval;
    // initial allocation (per thread)
+   {
       LOG_INFO ("directory: ino 0x%x uid %d gid %d mode 0%o path \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname);
+   }
    else if (S_ISREG (entry_parms->st_mode)) // else are we storing a regular file ?
+   {
-      if (strcmp (stored_pathname, "/proc/boot/boot") == 0) // is it the kernel ?
+      if (entry_parms->is_bootstrap_file) // is it the bootstrap file ?
+      {
-         // HACK: for now just consider the kernel as a binary blob
-         // FIXME: reimplement properly
-#ifdef PROCNTO_WIP
-         char *linebit_start;
-         char *content_line;
-         char *write_ptr;
-         char *token;
-         char *value;
-         char *ctx;
-         bool is_quoted_context;
-         bool was_string_split;
          // parse each line of contents
-         ASSERT (entry_parms->data.len > 0, "kernel specification without inline contents");
+         ASSERT (entry_parms->data.size > 0, "kernel specification without inline contents");
+         // parse buffer (non-destructively) line after line
+         Buffer_Initialize (&current_line);
-         for (content_line = strtok_r (entry_parms->data.bytes, "\n", &ctx); content_line != NULL; content_line = strtok_r (NULL, "\n", ctx))
+         for (line_index = 0; Buffer_GetNthLine (&entry_parms->data, line_index, &current_line); line_index++)
+         {
+            read_ptr = current_line.bytes;
-            while (isspace (*content_line))
+            while (isspace (*read_ptr))
-               content_line++; // skip leading spaces
+               read_ptr++; // skip leading spaces
-            if ((*content_line == '#') || (*content_line == 0))
+            if ((*read_ptr == '#') || (*read_ptr == 0))
                continue; // skip comments and empty lines
             // format of a line: [attributes] [env assignation] [...] [executable] [arg] [...] [comment]
             // example: "[uid=0 gid=0 perms=0700] CONFIG_PATH=/proc/boot:/etc procnto-smp-instr -v -mr -d 0777 -u 0777"
-            //LOG_DEBUG ("parsing line: %s", content_line);
+            LOG_DEBUG ("parsing line: %s", read_ptr);
             // does this line start with an attribute block ?
-            if (*content_line == '[')
+            if (*read_ptr == '[')
+            {
-               content_line++; // skip the leading square bracket
+               read_ptr++; // skip the leading square bracket
-               linebit_start = content_line; // remember where it starts
+               linebit_start = read_ptr; // remember where it starts
                is_quoted_context = false; // reach the next unescaped closing square bracket that is not between quotes
-               while ((*content_line != 0) && !((*content_line == ']') && (content_line[-1] != '\\') && !is_quoted_context))
+               while ((*read_ptr != 0) && !((*read_ptr == ']') && (read_ptr[-1] != '\\') && !is_quoted_context))
+               {
-                  if (*content_line == '"')
+                  if (*read_ptr == '"')
                      is_quoted_context ^= true; // remember when we're between quotes
-                  else if (!is_quoted_context && (*content_line == ' '))
+                  else if (!is_quoted_context && (*read_ptr == ' '))
-                     *content_line = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
+                     *read_ptr = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
-                  content_line++; // reach the next unescaped closing square bracket
+                  read_ptr++; // reach the next unescaped closing square bracket
+               }
-               if (*content_line != ']')
+               if (*read_ptr != ']')
+               {
                   LOG ("warning", 0, "syntax error in \"%s\" line %d: unterminated attributes block (skipping)", buildfile_pathname, lineno);
                   continue; // invalid attribute block, skip line
+               }
+               is_end_of_line = (*read_ptr == 0); // see if we're at the end of line already
-               *content_line = 0; // end the attribute block so that it is a parsable C string
+               *read_ptr = 0; // end the attribute block in all cases so that it is a parsable C string
                // now parse the attribute tokens (NOTE: THE LIST OF ALLOWED ATTRIBUTES HERE IS NOT DOCUMENTED)
                token = strtok_r (linebit_start, RECORD_SEP, &ctx);
                while (token != NULL)
+               {
                   #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)
-                  if (false)
+                  if (false) {}
                   else if (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms->prefix  = (*value == '/' ? value + 1 : value); } // skip possible leading slash in prefix (NOTE: stolen pointer. Do not free.)
                   else 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, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms->perms   = (int) read_integer (value); }
                   else if (strcmp (token, "+followlink") == 0) entry_parms->should_follow_symlinks = true;
                   else LOG_WARNING ("unimplemented bootstrap executable attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, token);
                   #undef REACH_TOKEN_VALUE
                   token = strtok_r (NULL, RECORD_SEP, &ctx); // proceed to next attribute token
+               }
-               content_line++; // reach the next character
+               if (is_end_of_line)
-               while ((*content_line != 0) && isspace (*content_line))
+                  continue; // if end of line was reached, proceed to the next line
-                  content_line++; // skip leading spaces
+               else
+                  read_ptr++; // else reach the next character (after the NUL split) and continue processing the same line
             } // end of "this line starts with an attributes block"
+            // at this point we are past the attributes block
+            // reset contextual argv/envp arrays
+            line_argv.args = NULL;
+            line_argv.count = 0;
+            line_envp.args = NULL;
+            line_envp.count = 0;
-            // there's data in this line. We expect an executable OR a variable name. Read it and unescape escaped characters
+            // now read each word (or quoted group of words), unescaping escaped characters
-            while (*content_line != 0)
+            while (*read_ptr != 0)
+            {
+               while ((*read_ptr != 0) && isspace (*read_ptr))
+                  read_ptr++; // skip intermediate spaces and reach the next word
+               if (*read_ptr == '#')
+                  break; // if the rest of the line is commented out, stop parsing it and proceed to the next line
-               linebit_start = content_line; // remember the name starts here
+               linebit_start = read_ptr; // remember the word (or quoted group of words) starts here
-               write_ptr = linebit_start;
+               write_ptr = read_ptr;
-               is_quoted_context = (*content_line == '"');
+               is_quoted_context = (*read_ptr == '"'); // see if we're entering a quoted context or not
                if (is_quoted_context)
-                  content_line++; // skip a possible initial quote in the name
+                  read_ptr++; // skip a possible initial quote in the word
-               while ((*content_line != 0) && ((!is_quoted_context && (*content_line != '=') && !isspace (*content_line)) || (is_quoted_context && (*content_line == '"'))))
+               while ((*read_ptr != 0) && ((!is_quoted_context && !isspace (*read_ptr)) || (is_quoted_context && (*read_ptr == '"'))))
+               {
-                  if (*content_line == '\\')
+                  if (*read_ptr == '\\')
-                  {
-                     content_line++;
-                     *write_ptr++ = *content_line; // unescape characters that are escaped with '\'
+                     read_ptr++; // unescape characters that are escaped with '\' by advancing the read pointer
-                  }
-                  else
-                     *write_ptr++ = *content_line;
+                  *write_ptr++ = *read_ptr++; // recopy characters as we read them
-                  content_line++;
+               }
+               is_end_of_line = (*read_ptr == 0); // see if we're at the end of line already
+               *write_ptr = 0; // stop the rewritten string here
-               // we reached a closing quote, a space OR an equal sign
-               if (*content_line == '=')
-               {
-                  // it's an environment variable assignation
-                  *write_ptr++ = *content_line++; // skip the equal sign
-                  is_quoted_context = (*content_line == '"');
-                  if (is_quoted_context)
-                     content_line++; // skip a possible initial quote in the value
-                  while ((*content_line != 0) && ((!is_quoted_context && (*content_line != '=') && !isspace (*content_line)) || (is_quoted_context && (*content_line == '"'))))
+               // end of word, i.e. we reached either a closing quote or a space. The string bit has been rewritted at linebit_start without quotes and with characters unescaped.
-                  {
-                     if (*content_line == '\\')
-                     {
-                        content_line++;
-                        *write_ptr++ = *content_line; // unescape characters that are escaped with '\'
-                     }
-                     else
-                        *write_ptr++ = *content_line;
-                     content_line++;
-                  }
-                  if (*write_ptr != 0)
-                  {
-                     *write_ptr = 0; // terminate the string if necessary
-                     was_string_split = true;
-                  }
-                  else
-                     was_string_split = false;
-                  if (is_quoted_context && (*content_line == '"'))
-                     content_line++; // skip a possible final quote
-                  while ((*content_line != 0) && isspace (*content_line))
-                     content_line++; // skip spaces
+               if ((strchr (linebit_start, '=') != NULL) && (line_argv.count == 0)) // is it an assignation AND have we not started constructing argv yet?
+               {
+                  STRINGARRAY_PUSH (&line_envp, linebit_start); // linebit_start is of the form "NAME=VALUE": it's an environment variable assignation
+                  LOG_DEBUG ("collected envp: [%s]", linebit_start);
+               }
-                  // now linebit_start is of the form "NAME=VALUE"
+               else // it's an executable argument (argv)
+               {
+                  STRINGARRAY_PUSH (&line_argv, linebit_start); // linebit_start is either NOT of the form "NAME=VALUE" OR we started constructing argv: it's a command-line argument
-                  LOG_DEBUG ("assignation: [%s]", linebit_start);
+                  LOG_DEBUG ("collected argv: [%s]", linebit_start);
+               }
+               if (!is_end_of_line)
+                  read_ptr++; // if we haven't reach the end of the line yet, advance to the next character (after the NUL split)
-                  // TODO: grow global_envstring
+            } // end while (*read_ptr != 0)
-                  //reallocated_ptr = realloc (global_envstring, global_envstring_len + strlen ())
+            // we finished parsing the line
+            // did we fill an executable argv? As per QNX docs, the first executable must be startup-*, the last executable must be procnto.
+            if (line_argv.count > 0)
+            {
-                  if (was_string_split)
+               if (startup_argv.args == NULL)
+               {
-                     *write_ptr = ' '; // restore string continuity for parsing to continue
+                  startup_argv.args = line_argv.args; // relocate these pointers to the right place
-                  while ((*content_line != 0) && isspace (*content_line))
+                  startup_argv.count = line_argv.count;
+                  startup_envp.args = line_envp.args; // relocate these pointers to the right place
-                     content_line++; // skip spaces
+                  startup_envp.count = line_envp.count;
+               }
-               else // it's either a closing quote or a space
+               else
+               {
-                  *write_ptr = 0; // terminate the string
-                  if (is_quoted_context && (*content_line == '"'))
-                     content_line++; // skip a possible final quote
-                  LOG_DEBUG ("exe name: [%s]", linebit_start);
-                  while ((*content_line != 0) && isspace (*content_line))
-                     content_line++; // skip leading spaces
-                  // it's an executable name. As per QNX docs, the first executable must be startup-*, the last executable must be procnto.
+                  STRINGARRAY_FREE (&procnto_argv); // if procnto's argv was already assigned, free the previous array as we'll be replacing it with a new one
-                  if (startup_name == NULL)
-                     startup_name = strdup (linebit_start);
+                  procnto_argv.args = line_argv.args; // relocate these pointers to the right place
-                  else
-                  {
-                     if (procnto_name != NULL)
-                        free (procnto_name);
-                     procnto_name = strdup (linebit_start);
+                  procnto_argv.count = line_argv.count;
-                  }
-                  if ((*content_line == '#') || (*content_line == 0))
-                     break; // if we reach the end of the line, stop parsing
+                  STRINGARRAY_FREE (&procnto_envp); // if procnto's envp was already assigned, free the previous array as we'll be replacing it with a new one
-                  // what comes after now must be optional arguments
-                  while ((*content_line != 0) && isspace (*content_line))
+                  procnto_envp.args = line_envp.args; // relocate these pointers to the right place
-                     content_line++; // skip leading spaces
+                  procnto_envp.count = line_envp.count;
-                  // FIXME: parse executable command-line arguments
-                  break; // stop parsing once all the arguments have been read
+               }
+               line_argv.args = NULL; // void the line_argv array so as to not free it as we stole its args pointers
+               line_argv.count = 0;
+               line_envp.args = NULL; // void the line_envp array so as to not free it as we stole its args pointers
+               line_envp.count = 0;
+            }
+            else // this line contained no executable invokation, so stack up its envp assignations into the global envp array
+               for (array_index = 0; array_index < line_envp.count; array_index++)
+                  STRINGARRAY_PUSH (&global_envp, line_envp.args[array_index]);
+            // release the contextual argv/envp arrays
-         } // end of parsing
+            STRINGARRAY_FREE (&line_argv);
+            STRINGARRAY_FREE (&line_envp);
+         } // end for (line_index = 0; Buffer_GetNthLine (&entry_parms->data, line_index, &current_line); line_index++)
          free (entry_parms->data.bytes); // free the inline specification once it's parsed
          entry_parms->data.bytes = NULL;
-         entry_parms->data.len = 0;
+         entry_parms->data.size = 0;
-         ASSERT (startup_name && *startup_name, "the QNX startup executable (startup-*) is missing in this bootstrap inline specification");
+         ASSERT (startup_argv.args && startup_argv.args[0] && *startup_argv.args[0], "the QNX startup executable (startup-*) is missing in this bootstrap inline specification");
-         ASSERT (procnto_name && *procnto_name, "the QNX kernel (procnto-*) is missing in this bootstrap inline specification");
+         ASSERT (procnto_argv.args && procnto_argv.args[0] && *procnto_argv.args[0], "the QNX kernel (procnto-*) is missing in this bootstrap inline specification");
          // now we know which startup and procnto executables to use
-         LOG_DEBUG ("Startup: %s", startup_name);
+         LOG_DEBUG ("Startup: %s", startup_argv.args[0]);
-         LOG_DEBUG ("Kernel: %s", procnto_name);
+         LOG_DEBUG ("Kernel: %s",  procnto_argv.args[0]);
-         sprintf (candidate_pathname, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), procnto_name); // fix the entry name
-         stored_pathname = candidate_pathname;
-         entry_parms->extra_ino_flags |= /*IFS_INO_PROCESSED_ELF | */IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
-         entry_parms->st_mode = S_IFREG | entry_parms->perms; // apply specified procnto permissions
-         image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
          static thread_local char linker_pathname[MAXPATHLEN] = "";
          static thread_local char linker_sysroot_arg[MAXPATHLEN] = "";
          static thread_local char linker_script_pathname_arg[MAXPATHLEN] = "";
          static thread_local char procnto_buildhost_pathname[MAXPATHLEN] = "";
          static thread_local char procnto_sym_filename[MAXPATHLEN] = "";
+         buffer_t bootargs_buffer = { 0 };
+         char *bootargs_location;
          // construct the arguments that are based on environment variables (infer QNX_HOST from QNX_TARGET)
 #if defined(_WIN32)
-         sprintf (linker_pathname, "%s/../../host/win64/x86_64/usr/bin/%s-ld.exe", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0")); // Win32: note the .exe extension
+         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/win64/x86_64/usr/bin/%s-ld.exe", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0")); // Win32: note the .exe extension
 #elif defined(__linux__)
-         sprintf (linker_pathname, "%s/../../host/linux/x86_64/usr/bin/%s-ld", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
+         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/linux/x86_64/usr/bin/%s-ld", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
 #elif defined(__QNXNTO__)
-         sprintf (linker_pathname, "%s/../../host/qnx8/x86_64/usr/bin/%s-ld", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
+         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/qnx8/x86_64/usr/bin/%s-ld", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
 #else // wtf are you building this on?
 #error Please port the GNU linker x86_64-pc-nto-qnx8.0.0-ld and aarch64-unknown-nto-qnx8.0.0-ld to your host architecture first before compiling ifstool.
 #endif
          ASSERT (access (linker_pathname, 0) == 0, "host cross-linker for QNX8 \"%s\" not found", linker_pathname);
-         sprintf (linker_sysroot_arg, "--sysroot=%s/%s/", QNX_TARGET, image_processor);
+         sprintf_s (linker_sysroot_arg, sizeof (linker_sysroot_arg), "--sysroot=%s/%s/", QNX_TARGET, image_processor);
-         sprintf (linker_script_pathname_arg, "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);
+         sprintf_s (linker_script_pathname_arg, sizeof (linker_script_pathname_arg), "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);
-         resolved_pathname = resolve_pathname (procnto_name, entry_parms->search); // locate the procnto kernel location
+         resolved_pathname = resolve_pathname (procnto_argv.args[0], entry_parms->search); // locate the procnto kernel location
-         ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_name);
+         ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_argv.args[0]);
-         strcpy (procnto_buildhost_pathname, resolved_pathname);
+         strcpy_s (procnto_buildhost_pathname, sizeof (procnto_buildhost_pathname), resolved_pathname);
-         sprintf_s (procnto_sym_filename, sizeof (procnto_sym_filename), "%s.sym%s", procnto_name, sym_suffix);
+         sprintf_s (procnto_sym_filename, sizeof (procnto_sym_filename), "%s.sym%s", procnto_argv.args[0], sym_suffix);
-         const char *linker_argv[] = // construct the linker invokation argv
+         // construct the linker invokation command-line arguments array (argv)
-         {
+         STRINGARRAY_INIT (&linker_argv);
-            strrchr (linker_pathname, '/') + 1, // "${TARGET_TRIPLE}-ld"
+         STRINGARRAY_PUSH (&linker_argv, strrchr (linker_pathname, '/') + 1); // "${TARGET_TRIPLE}-ld"
-            linker_sysroot_arg, // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"
+         STRINGARRAY_PUSH (&linker_argv, linker_sysroot_arg); // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"
-            linker_script_pathname_arg, // "-T${QNX_TARGET}/${TARGET_CPU}/lib/nto.link"
+         STRINGARRAY_PUSH (&linker_argv, linker_script_pathname_arg); // "-T${QNX_TARGET}/${TARGET_CPU}/lib/nto.link"
-            "--section-start",
+         STRINGARRAY_PUSH (&linker_argv, "--section-start");
-            ".text=0xffff800000001000",
+         STRINGARRAY_PUSH (&linker_argv, ".text=0xffff800000001000");
-            "--no-relax",
+         STRINGARRAY_PUSH (&linker_argv, "--no-relax");
-            procnto_buildhost_pathname, // "${QNX_TARGET}/${TARGET_CPU}/boot/sys/procnto-smp-instr"
+         STRINGARRAY_PUSH (&linker_argv, procnto_buildhost_pathname); // "${QNX_TARGET}/${TARGET_CPU}/boot/sys/procnto-smp-instr"
-            "-o",
+         STRINGARRAY_PUSH (&linker_argv, "-o");
-            procnto_sym_filename, // "procnto-smp-instr.sym"
+         STRINGARRAY_PUSH (&linker_argv, procnto_sym_filename); // "procnto-smp-instr.sym"
-            NULL
+         STRINGARRAY_PUSH (&linker_argv, NULL); // don't forget to terminate the argv array with a NULL pointer
-         };
          if (verbose_level > 2)
+         {
             fprintf (stderr, "ifstool: calling:");
-            for (table_index = 0; table_index < sizeof (linker_argv) / sizeof (linker_argv[0]) - 1; table_index++)
+            for (array_index = 0; array_index < linker_argv.count - 1; array_index++)
-               fprintf (stderr, " '%s'", linker_argv[table_index]);
+               fprintf (stderr, " '%s'", linker_argv.args[array_index]);
             fputc ('\n', stderr);
+         }
+#ifdef _WIN32
-         _spawnv (_P_WAIT, linker_pathname, linker_argv); // spawn the linker and produce a stripped procnto (wait for completion)
+         _spawnv (_P_WAIT, linker_pathname, linker_argv.args); // spawn the linker and produce a stripped procnto (wait for completion)
+#else // !_WIN32, thus POSIX
+         do {
+            int status;
+            pid_t pid = fork (); // duplicate ourselves so as to create a new process
+            ASSERT_WITH_ERRNO (pid != -1);
+            if (pid == 0)
+            {
+               execv (linker_pathname, linker_argv); // spawn the child process
+               DIE_WITH_EXITCODE (1, "execve() failed"); // exec never returns
+            }
+            else
+               waitpid (pid, &status, 0); // wait for the child to finish
+         } while (0);
+#endif // _WIN32
+         STRINGARRAY_FREE (&linker_argv);
          if (!Buffer_ReadFromFile (&entry_parms->data, procnto_sym_filename)) // load the output file
             DIE_WITH_EXITCODE (1, "the host cross-linker failed to produce a readable stripped \"%s\" kernel: %s", procnto_sym_filename, strerror (errno));
          if (!entry_parms->should_keep_ld_output)
             unlink (procnto_sym_filename); // remove the linker output file if we want to
+         // save the boot arguments. The magic to look for is "ddpvbskr" -- whatever that means
+         if ((bootargs_location = Buffer_FindFirstByteArray (&entry_parms->data, "ddpvbskr")) == NULL)
+            DIE_WITH_EXITCODE (1, "unable to find boot args location in the stripped \"%s\" kernel", stored_pathname);
+         Buffer_InitWithSize (&bootargs_buffer, sizeof (bootargs_entry_t)); // prepare a boot args entry
+         ((bootargs_entry_t *) bootargs_buffer.bytes)->argc = (uint8_t) procnto_argv.count;
+         ((bootargs_entry_t *) bootargs_buffer.bytes)->envc = (uint8_t) (global_envp.count + procnto_envp.count);
+         ((bootargs_entry_t *) bootargs_buffer.bytes)->shdr_addr = (uint32_t) (image_base + bootfile_size); // same value as startup_header.image_paddr (which is not set yet) (TODO: support 64-bit shdr_addr offsets -- see comment in bootargs_entry_t struct)
+         for (array_index = 0; array_index < procnto_argv.count; array_index++)
+            ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, procnto_argv.args[array_index], strlen (procnto_argv.args[array_index]) + 1)); // append string including NUL terminator
+         for (array_index = 0; array_index < global_envp.count; array_index++)
+            ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, global_envp.args[array_index], strlen (global_envp.args[array_index]) + 1)); // append string including NUL terminator
+         for (array_index = 0; array_index < procnto_envp.count; array_index++)
+            ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, procnto_envp.args[array_index], strlen (procnto_envp.args[array_index]) + 1)); // append string including NUL terminator
+         ((bootargs_entry_t *) bootargs_buffer.bytes)->size_hi = (uint8_t) ((bootargs_buffer.size >> 8) & 0xff);
+         ((bootargs_entry_t *) bootargs_buffer.bytes)->size_lo = (uint8_t) ((bootargs_buffer.size >> 0) & 0xff);
+         ASSERT_WITH_ERRNO (Buffer_WriteBufferAt (&entry_parms->data, (size_t) bootargs_location - (size_t) entry_parms->data.bytes, &bootargs_buffer));
+         Buffer_Forget (&bootargs_buffer); // release the boot args buffer once it's written
          // now strip this prelinked ELF kernel file
-         Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, 1, stored_pathname); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info")
+         ASSERT_WITH_ERRNO (Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, 1, true, stored_pathname)); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info", and align the segment size in file with the size it occupies in memory)
+         sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), procnto_argv.args[0]); // fix the entry name
+         stored_pathname = candidate_pathname;
-         entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
+         entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // mark this inode as a preprocessed *bootstrap* ELF file
+         entry_parms->st_mode = S_IFREG | entry_parms->perms; // procnto is a regular file
+         image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
-#else // !PROCNTO_WIP
-         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
-         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
-         /* HACK */
-         /* HACK */ sprintf_s (candidate_pathname, MAXPATHLEN, "%s/procnto-smp-instr", (entry_parms->prefix != NULL ? entry_parms->prefix : "")); // HACK: fix the entry name
-         /* HACK */ stored_pathname = candidate_pathname;
-         /* HACK */ entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
-         /* HACK */ entry_parms->st_mode = S_IFREG | 0700; // procnto requires 0700 permissions
+         STRINGARRAY_FREE (&procnto_argv); // release procnto's argv array
-         /* HACK */ image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
-         /* HACK */ free (entry_parms->data.bytes); // discard inline contents
+         STRINGARRAY_FREE (&procnto_envp); // release procnto's envp array
-         /* HACK */ Buffer_Initialize (&entry_parms->data);
+         STRINGARRAY_FREE (&global_envp); // release the global envp array
-         /* HACK */ if (!Buffer_ReadFromFile (&entry_parms->data, kernelfile_pathname)) // read kernel file as a precompiled binary blob
-         /* HACK */ {
-         /* HACK */    fprintf (stderr, "fatal error: unable to read precompiled kernel file \"%s\" specified in --kernelfile argument\n", kernelfile_pathname);
-         /* HACK */    exit (1);
-         /* HACK */ }
-         /* HACK */
-         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
-         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
-#endif // PROCNTO_WIP
+      }
       else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?
          image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
       // do we already know the data for this data blob ?
          } // end if the file we're storing is a dylib
          // now strip this ELF file if necessary
          if (!(entry_parms->extra_ino_flags & IFS_INO_PROCESSED_ELF))
+         {
-            Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, saved_ELF_section_count, stored_pathname); // strip the ELF file à la mkifs
+            Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, saved_ELF_section_count, false, stored_pathname); // strip the ELF file à la mkifs
             entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
          } // end if the file is not yet a processed ELF
       } // end if the file we're storing is an ELF file
       #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file
+   }
             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
             LOG_INFO ("image 0x%x-0x%x maxsize %d totalsize %d align %d", 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
+            if ((bootfile_pathname == NULL) || (startupfile_pathname == NULL)) // HACK until I figure out how to re-create them
                DIE_WITH_EXITCODE (1, "creating bootable images require the --bootfile, --startupfile and --kernelfile command-line options in \"%s\" line %d", buildfile_pathname, lineno);
             if ((sep = strchr (value, ',')) != NULL) // do we have a comma separating (optional) processor and boot file name ?
+            {
                *sep = 0;
                strcpy_s (image_processor, sizeof (image_processor), value); // save processor
             //strcpy (image_bootfile, bootfile_pathname); // FIXME: HACK
             if (stat (bootfile_pathname, &stat_buf) != 0)
                DIE_WITH_EXITCODE (1, "unable to stat the boot file \"%s\" specified in \"%s\" line %d: %s", bootfile_pathname, buildfile_pathname, lineno, strerror (errno));
             bootfile_size = stat_buf.st_size; // save preboot file size
             LOG_INFO ("processor \"%s\" bootfile \"%s\"\n", image_processor, bootfile_pathname);
-#if 1
-            // ######################################################################################################################################################################################################################################
-            // # FIXME: figure out how to re-create it: linker call involved
-            // # $ x86_64-pc-nto-qnx8.0.0-ld --sysroot=${QNX_TARGET}/x86_64/ -T${QNX_TARGET}/x86_64/lib/nto.link --section-start .text=0xffff800000001000 --no-relax ${QNX_TARGET}/x86_64/boot/sys/procnto-smp-instr -o procnto-smp-instr.sym.UNSTRIPPED
-            // ######################################################################################################################################################################################################################################
-//               if (!Buffer_ReadFromFile (&entry_parms.data, kernelfile_pathname))
-//                  DIE_WITH_EXITCODE (1, "unable to read precompiled kernel file \"%s\" specified in --kernelfile argument: %s", kernelfile_pathname, strerror (errno));
-#else // nonworking
-            strcpy (path_on_buildhost, "procnto-smp-instr");
+            entry_parms.is_bootstrap_file = true;
-#endif // nonworking
+         }
          else if (strncmp (token, "mtime=", 6) == 0) { REACH_TOKEN_VALUE (); if (strcmp (value, "*") == 0) entry_parms.mtime = UINT32_MAX; else {
                // value *must* be "YYYY-MM-DD-HH:MM:SS" by specification
                memset (&utc_time, 0, sizeof (utc_time));
                if (sscanf_s (value, "%u-%u-%u-%u:%u:%u", &utc_time.tm_year, &utc_time.tm_mon, &utc_time.tm_mday, &utc_time.tm_hour, &utc_time.tm_min, &utc_time.tm_sec) != 6)
             DIE_WITH_EXITCODE (1, "the --startupfile arguments expects <pathname>@<entrypoint_from_image_base>");
          *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
+      else if ((strcmp (argv[arg_index], "--kerneloffs") == 0) && (arg_index + 1 < argc)) // --kerneloffs 0x32000 (undocumented)
-      {
-         sep = strchr (argv[++arg_index], '@');
-         if ((sep == NULL) || (sep[1] == 0))
-            DIE_WITH_EXITCODE (1, "the --kernelfile arguments expects <pathname>@<fileoffset>");
-         *sep = 0;
-         kernelfile_pathname = argv[arg_index];
-         kernelfile_offset = (size_t) read_integer (sep + 1);
+         kernelfile_offset = (size_t) read_integer (argv[++arg_index]);
-      }
       else if ((strcmp (argv[arg_index], "-a") == 0) && (arg_index + 1 < argc)) // -a suffix
          sym_suffix = argv[++arg_index];
       else if (strcmp (argv[arg_index], "-n") == 0)
          default_parms.mtime_for_inline_files = 0; // inline files should have a mtime set to zero
       else if (strcmp (argv[arg_index], "-nn") == 0)
          saved_ELF_sections = reallocated_ptr;
          saved_ELF_sections[saved_ELF_section_count++] = argv[++arg_index]; // stack up another ELF section name to preserve
+      }
       else if ((strcmp (argv[arg_index], "-?") == 0) || (strcmp (argv[arg_index], "--help") == 0))
          want_help = true;
-      else if (first_pathname == NULL)
+      else if ((first_pathname == NULL) && (*argv[arg_index] != '-'))
          first_pathname = argv[arg_index];
-      else if (second_pathname == NULL)
+      else if ((second_pathname == NULL) && (*argv[arg_index] != '-'))
          second_pathname = argv[arg_index];
-      else if (third_pathname == NULL)
+      else if ((third_pathname == NULL) && (*argv[arg_index] != '-'))
          third_pathname = argv[arg_index];
       else
          DIE_WITH_EXITCODE (1, "unrecognized option: '%s'", argv[arg_index]);
+   }
    // else do we want to strip an ELF file ? if so, do so
    else if (want_strip)
+   {
       buffer_t file;
       ASSERT (Buffer_ReadFromFile (&file, first_pathname), "can't open \"%s\" for reading: %s", first_pathname, strerror (errno));
-      ASSERT (Buffer_StripELFFile (&file, (const char **) saved_ELF_sections, saved_ELF_section_count, first_pathname), "error stripping \"%s\": %s", first_pathname, strerror (errno));
+      ASSERT (Buffer_StripELFFile (&file, (const char **) saved_ELF_sections, saved_ELF_section_count, false, first_pathname), "error stripping \"%s\": %s", first_pathname, strerror (errno));
       ASSERT_WITH_ERRNO (Buffer_WriteToFile (&file, (second_pathname != NULL ? second_pathname : "<stdout>")));
       exit (0);
+   }
    // we want to CREATE an IFS file
       curr_offset += fsentries[fsentry_index].header.size; // advance to the next one
+   }
    ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&ifs.data, "\0\0\0\0")); // there seems to be 4 bytes of padding after the image directory
    imgdir_size = ifs.data.size - ifs.offsets.imagedir; // measure image dir size and save it for future use
-   // is it a bootable image with a kernel file ?
+   // is it a bootable image with a startup file ?
-   if ((startupfile_pathname != NULL) && (kernelfile_pathname != NULL))
+   if (startupfile_pathname != NULL)
+   {
       // start by writing the startup script data blob, if we have one
       for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
          if (fsentries[fsentry_index].header.ino == image_bootscript_ino)
             break; // locate the startup script directory entry
       if (fsentry_index < fsentry_count) // found it ?
+      {
          if (ifs.data.size + fsentries[fsentry_index].u.file.size >= kernelfile_offset)
-            DIE_WITH_EXITCODE (1, "the compiled startup script is too big (%zd bytes, max is %zd) to fit at current offset %zd", (size_t) fsentries[fsentry_index].u.file.size, kernelfile_offset - ifs.data.size, ifs.data.size);
+            DIE_WITH_EXITCODE (1, "the compiled startup script is too big (%zd bytes, max is %zd) to fit at current offset %zd. Use --kerneloffs <addr> to relocate (warning: untested)", (size_t) fsentries[fsentry_index].u.file.size, kernelfile_offset - ifs.data.size, ifs.data.size);
          fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // save file data blob offset in file structure
          Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write file data
          fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
       // now write the QNX kernel
       for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
          if (fsentries[fsentry_index].header.ino == image_kernel_ino)
             break; // locate the kernel directory entry (can't fail)
       fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // save file data blob offset in file structure
-#ifdef PROCNTO_WIP
-      // is the kernel we're storing a preprocessed ELF kernel ?
-      if (fsentries[fsentry_index].header.ino & IFS_INO_PROCESSED_ELF)
-      {
-         elf = (elf_header_t *) fsentries[fsentry_index].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 *) &fsentries[fsentry_index].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
-            corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);
-            if (ELF_GET_NUMERIC (elf, phdr, size_in_memory) != 0) // only patch the physical address of segments that have an actual size in memory
-               ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + ifs.data.size - corrective_offset); // patch the physical address member of the program header table (NOTE: ifs.data.size is the location where the file data is about to be written)
-         }
-      }
-#endif // PROCNTO_WIP
       Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write kernel file data
       fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+   }
    // then write all the other files by increasing inode number: ELF files first

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool//ifstool.c – Rev 19 → 20