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

    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[MAXPATHLEN]; // install path (e.g. "proc/boot")
+   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 is_compiled_bootscript; // entry has [+script] attribute
    int extra_ino_flags; // bitmap of extra inode flags (IFS_INO_xxx)
-   char search[10 * MAXPATHLEN]; // binary search path (the default one will be constructed at startup)
+   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;
 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 *MKIFS_PATH = NULL; // value of the $MKIFS_PATH environment variable (may contain references to $QNX_TARGET). Initialized by this program if empty.
+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
 // 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
 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_path); // locates pathname among MKIFS_PATH and returns a pointer to the resolved pathname (static string)
+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 int Buffer_StripELFFile (buffer_t *file, 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 char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded
 static size_t 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
 static int fsentry_compare_pathnames_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by pathnames
-static void update_MKIFS_PATH (const char *processor);
+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
+   }
    return (ret);
+}
-static char *resolve_pathname (const char *pathname, const char *search_path)
+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;
+   size_t defaultpath_index;
    struct stat stat_buf;
    const char *nextsep;
    const char *token;
    // initial allocation (per thread)
       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
-   if (IS_DIRSEP (pathname[0]) || (isalpha (pathname[0]) && (pathname[1] == ':') && IS_DIRSEP (pathname[2])))
+       || (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
-      token = (*search_path != 0 ? search_path : NULL);
+      if (search_paths_or_NULL_for_MKIFS_PATH_envvar != NULL)
+      {
+         token = (*search_paths_or_NULL_for_MKIFS_PATH_envvar != 0 ? search_paths_or_NULL_for_MKIFS_PATH_envvar : NULL);
-      nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
+         nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
-      while (token != NULL)
+         while (token != NULL)
+         {
+            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
+      for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)
+      {
-         sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s", (int) (nextsep - token), token, pathname);
+         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
-         token = (*nextsep != 0 ? nextsep + 1 : NULL);
-         nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
+      }
+   }
    errno = ENOENT; // we exhausted all possibilities
    return (NULL); // file not found, return with ENOENT
+{
    // 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 table_index;
    size_t table_count;
          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
          if (segment_size != 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, ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + data_offset - corrective_offset); // 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)
+            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
+   }
    return (Buffer_OffsetOf (buffer, occurrence)); // can't fail
+}
-static int Buffer_StripELFFile (buffer_t *file, const char *indicative_pathname)
+static int Buffer_StripELFFile (buffer_t *file, const char **saved_sections, const size_t saved_section_count, 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;
-   static const char *saved_sections[] = { "QNX_info", ".gnu_debuglink", "QNX_usage", ".note.gnu.build-id" };
    const elf_program_header_t *phdr;
    const elf_section_header_t *shdr;
    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 array_index;
    size_t table_index;
    size_t table_count;
    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 < sizeof (saved_sections) / sizeof (saved_sections[0]); array_index++)
+   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_sections[array_index], (unsigned long long) sectiondata_start, (unsigned long long) sectiondata_size);
+         //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
+      }
    for (table_index = 1; table_index < elf_section_count; table_index++)
       Buffer_WriteAt (file, new_shdrtable_offset + table_index * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header), &elf_sections[table_index].header, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header)); // write each section header
    Buffer_WriteAt (file, new_shdrtable_offset + table_index * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header), &elf_sections[0].header, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header)); // write the section header names section header last
    // and finally fix the ELF master header
+   new_shdrtable_len = 1 + elf_section_count; // take in account that the first entry in the section headers table is empty
    ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_offset, new_shdrtable_offset);
-   ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_len, 1 + elf_section_count); // take in account that the first entry in the section headers table is empty
+   ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_len, new_shdrtable_len);
    ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_names_idx, elf_section_count); // the section headers strings table is the last section
    // align size with page size (4096 on x86, 16k on ARM), zerofilling the extra space
    ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (file, ROUND_TO_UPPER_MULTIPLE (file->size, page_size)));
                // 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)
+                  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.)
-                  if      (strncmp (token, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->uid     = (int) read_integer (value); }
+                  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 (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); strcpy (entry_parms->prefix, (*value == '/' ? value + 1 : value)); } // skip possible leading slash in prefix
                   else if (strcmp (token, "+followlink") == 0) entry_parms->should_follow_symlinks = true;
                   else if (strcmp (token, "-followlink") == 0) entry_parms->should_follow_symlinks = false;
                   else if (strcmp (token, "+keeplinked") == 0) entry_parms->should_keep_ld_output = true;
                   else if (strcmp (token, "-keeplinked") == 0) entry_parms->should_keep_ld_output = false;
                   else LOG_WARNING ("unimplemented bootstrap executable attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, token);
          // now we know which startup and procnto executables to use
          LOG_DEBUG ("Startup: %s", startup_name);
          LOG_DEBUG ("Kernel: %s", procnto_name);
-         sprintf (candidate_pathname, "%s/%s", entry_parms->prefix, procnto_name); // fix the entry name
+         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);
 #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 (linker_script_pathname_arg, "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);
-         resolved_pathname = resolve_pathname (procnto_name, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH)); // locate the procnto kernel location
+         resolved_pathname = resolve_pathname (procnto_name, entry_parms->search); // locate the procnto kernel location
          ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_name);
          strcpy (procnto_buildhost_pathname, resolved_pathname);
          sprintf (procnto_sym_filename, "%s.sym", procnto_name);
          _spawnv (_P_WAIT, linker_pathname, linker_argv); // spawn the linker and produce a stripped procnto (wait for completion)
          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
+         // now strip this prelinked ELF kernel file
+         Buffer_StripELFFile (&entry_parms->data, saved_ELF_sections, 1, stored_pathname); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info")
+         entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
 #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); // HACK: fix the entry name
+         /* 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
          /* HACK */ image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
          /* HACK */ free (entry_parms->data.bytes); // discard inline contents
          entry_parms->mtime = entry_parms->mtime_for_inline_files; // if so, set it a mtime equal to the mtime to use for inline files
          LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)", entry_parms->extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.size);
+      }
       else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?
+      {
-         resolved_pathname = resolve_pathname (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH)); // locate the file
+         resolved_pathname = resolve_pathname (buildhost_pathname, entry_parms->search); // locate the file
          if (resolved_pathname == NULL)
             DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
          if (!Buffer_ReadFromFile (&entry_parms->data, resolved_pathname))
             DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d can't be read: %s", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
          stat (resolved_pathname, &stat_buf); // can't fail, since we could read it
+                  }
                // do we have it ?
                if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0))
+               {
-                  sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", entry_parms->prefix, canonical_dylib_name);
+                  sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), canonical_dylib_name);
                   if (strcmp (candidate_pathname, stored_pathname) != 0) // claimed dylib name differs from passed name ?
+                  {
                      original_stored_pathname = stored_pathname; // if so, remember to create a symlink here
                      stored_pathname = candidate_pathname;
+                  }
          } // 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, stored_pathname); // strip the ELF file à la mkifs
+            Buffer_StripELFFile (&entry_parms->data, saved_ELF_sections, saved_ELF_section_count, 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
+   }
    const char *pathname_b = (S_ISDIR (entry_b->header.mode) ? entry_b->u.dir.path : (S_ISREG (entry_b->header.mode) ? entry_b->u.file.path : (S_ISLNK (entry_b->header.mode) ? entry_b->u.symlink.path : entry_b->u.device.path)));
    return (strcmp (pathname_a, pathname_b));
+}
-static void update_MKIFS_PATH (const char *processor)
+static void parse_line (FILE *buildfile_fp, char *line_buffer, fsentry_t **fsentries, size_t *fsentry_count, parms_t *default_parms)
+{
+   thread_local static char path_on_buildhost[MAXPATHLEN] = "";
+   thread_local static char path_in_ifs[MAXPATHLEN] = "";
-   // updates the value of MKIFS_PATH according to the passed processor name string, unless an environment variable already defines it
+   thread_local static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
+   bool should_discard_inline_contents;
+   bool is_quoted_context;
+   bool is_escaped_char;
+   struct stat stat_buf;
+   struct tm utc_time;
-   char processor_base[16];
+   void *reallocated_ptr;
+   size_t allocated_size;
-   size_t data_len;
+   size_t string_len;
+   char *specifiedpathname_start;
+   char *attrblock_start;
+   char *write_ptr;
-   char *envvar;
+   char *line_ptr;
+   char *value;
    char *token;
+   char *sep;
+   char *ctx;
+   int read_char;
+   line_ptr = line_buffer;
+   while ((*line_ptr != 0) && isspace (*line_ptr))
+      line_ptr++; // skip leading spaces
+   if ((*line_ptr == 0) || (*line_ptr == '#'))
+      return; // skip empty or comment lines
+   string_len = (int) strlen (line_buffer);
+   if ((string_len > 0) && (line_buffer[string_len - 1] == '\n'))
-   envvar = getenv ("MKIFS_PATH"); // look in the environment first, and construct a default one if not supplied
+      line_buffer[string_len - 1] = 0; // chop off newline for easier debug output
-   if (envvar != NULL)
+   // reset entry values
-      MKIFS_PATH = envvar; // if envvar is present, set MKIFS_PATH to point to it
+   memcpy (&entry_parms, default_parms, sizeof (parms_t));
+   path_in_ifs[0] = 0;
+   path_on_buildhost[0] = 0;
+   should_discard_inline_contents = false;
+   // does this line start with an attribute block ?
-   else // envvar not present
+   if (*line_ptr == '[')
+   {
+      line_ptr++; // skip the leading square bracket
+      attrblock_start = line_ptr; // remember where it starts
+      is_quoted_context = false;
+      while ((*line_ptr != 0) && !((*line_ptr == ']') && (line_ptr[-1] != '\\') && !is_quoted_context))
+      {
+         if (*line_ptr == '"')
+            is_quoted_context ^= true; // remember when we're between quotes
+         else if (!is_quoted_context && (*line_ptr == ' '))
+            *line_ptr = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
+         line_ptr++; // reach the next unescaped closing square bracket
+      }
-      if (MKIFS_PATH != NULL)
+      if (*line_ptr != ']')
+      {
+         LOG ("warning", 0, "syntax error in \"%s\" line %d: unterminated attributes block (skipping)", buildfile_pathname, lineno);
+         return; // invalid attribute block, skip line
+      }
-         free (MKIFS_PATH); // free any MKIFS_PATH that we constructed earlier
+      *line_ptr = 0; // end the attribute block so that it is a parsable C string
+      // now parse the attribute tokens
-      strcpy_s (processor_base, sizeof (processor_base), processor); // construct PROCESSOR_BASE
+      // DOCUMENTATION: https://www.qnx.com/developers/docs/8.0/com.qnx.doc.neutrino.utilities/topic/m/mkifs.html#mkifs__description
-      token = strchr (processor_base, '-');
+      token = strtok_r (attrblock_start, RECORD_SEP, &ctx);
-      if (token != NULL)
+      while (token != NULL)
+      {
+         // evaluate attribute token
+         #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)
+         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, "dperms=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms.dperms  = (int) read_integer (value); }
+         else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms.perms   = (int) read_integer (value); }
+         else if (strncmp (token, "type=",    5) == 0) { REACH_TOKEN_VALUE ();
+            if      (strcmp (value, "dir")  == 0) entry_parms.st_mode = S_IFDIR;
+            else if (strcmp (value, "file") == 0) entry_parms.st_mode = S_IFREG;
+            else if (strcmp (value, "link") == 0) entry_parms.st_mode = S_IFLNK;
+            else if (strcmp (value, "fifo") == 0) entry_parms.st_mode = S_IFIFO;
+            else DIE_WITH_EXITCODE (1, "invalid 'type' attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, value);
+         }
+         else if (strncmp (token, "image=",   6) == 0) { REACH_TOKEN_VALUE ();
+            image_base = (uint32_t) read_integer (value); // read image base address
+            if ((sep = strchr (value, '-')) != NULL) image_end       = (uint32_t) read_integer (sep + 1); // if we have a dash, read optional image end (TODO: check this value and produce an error in the relevant case. Not important.)
+            if ((sep = strchr (value, ',')) != NULL) image_maxsize   = (uint32_t) read_integer (sep + 1); // if we have a comma, read optional image max size
+            if ((sep = strchr (value, '=')) != NULL) image_totalsize = (uint32_t) read_integer (sep + 1); // if we have an equal sign, read optional image padding size
+            if ((sep = strchr (value, '%')) != NULL) image_align     = (uint32_t) read_integer (sep + 1); // if we have a modulo sign, read optional image aligmnent
+            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
+               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
+               value = sep + 1;
+            }
+            //sprintf (image_bootfile, "%s/%s/boot/sys/%s.boot", QNX_TARGET, image_processor, value); // save preboot file name (TODO: we should search in MKIFS_PATH instead of this. Not important.)
+            //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");
+#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)
+               {
+                  LOG_WARNING ("syntax error in \"%s\" line %d: mtime specification not in YYYY-MM-DD-HH:MM:SS format (skipping)", buildfile_pathname, lineno);
-         *token = 0; // split anything from the first dash onwards
+                  continue; // invalid attribute block, skip line
+               }
+               utc_time.tm_mon--; // convert month from [1-12] to [0-11]
+               entry_parms.mtime = (uint32_t) mktime (&utc_time);
+            }
+         }
-      data_len = strlen (processor_base);
+         else if (strcmp (token, "+script")     == 0) {
+            entry_parms.is_compiled_bootscript = true;
+            ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&entry_parms.data, INITIAL_STARTUP_SCRIPT)); // FIXME: HACK until the script compiler is implemented
-      if ((data_len > 2) && ((processor_base[data_len - 2] == 'b') || (processor_base[data_len - 2] == 'l')) && (processor_base[data_len - 1] == 'e'))
+            should_discard_inline_contents = true; // remember we already have data (so as to discard the inline block's contents)
+         }
-         processor_base[data_len - 2] = 0; // if it ends with "le" or "be", strip that too
+         else if (strcmp (token, "-script")     == 0) entry_parms.is_compiled_bootscript = false;
+         else if (strcmp (token, "+followlink") == 0) entry_parms.should_follow_symlinks = true;
+         else if (strcmp (token, "-followlink") == 0) entry_parms.should_follow_symlinks = false;
+         else if (strcmp (token, "+autolink")   == 0) entry_parms.should_autosymlink_dylib = true;
+         else if (strcmp (token, "-autolink")   == 0) entry_parms.should_autosymlink_dylib = false;
+         else if (strcmp (token, "+keeplinked") == 0) entry_parms.should_keep_ld_output = true;
+         else if (strcmp (token, "-keeplinked") == 0) entry_parms.should_keep_ld_output = false;
+         else LOG_WARNING ("unimplemented attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, token);
+         #undef REACH_TOKEN_VALUE
-      MKIFS_PATH = malloc (10 * MAXPATHLEN); // construct a default MKIFS_PATH now
+         token = strtok_r (NULL, RECORD_SEP, &ctx); // proceed to next attribute token
+      }
-      ASSERT_WITH_ERRNO (MKIFS_PATH);
+      line_ptr++; // reach the next character
+      while ((*line_ptr != 0) && isspace (*line_ptr))
-      sprintf_s (MKIFS_PATH, 10 * MAXPATHLEN,
+         line_ptr++; // skip leading spaces
+      // are we at the end of the line ? if so, it means the attribute values that are set should become the default
+      if ((*line_ptr == 0) || (*line_ptr == '#'))
+      {
-                 "." PATH_SEP "%s/%s/sbin" PATH_SEP "%s/%s/usr/sbin" PATH_SEP "%s/%s/boot/sys" PATH_SEP "%s/%s/boot/sys" PATH_SEP "%s/%s/bin" PATH_SEP "%s/%s/usr/bin" PATH_SEP "%s/%s/lib" PATH_SEP "%s/%s/lib/dll" PATH_SEP "%s/%s/usr/lib", // use a platform-specific character as path separator
+         #define APPLY_DEFAULT_ATTR_NUM(attr,descr,fmt) do { if (entry_parms.attr != default_parms->attr) { \
+               LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d", default_parms->attr, entry_parms.attr, buildfile_pathname, lineno); \
-                 QNX_TARGET, processor,
+               default_parms->attr = entry_parms.attr; \
-                 QNX_TARGET, processor,
+            } } while (0)
-                 QNX_TARGET, processor,
+         #define APPLY_DEFAULT_ATTR_STR(attr,descr,fmt) do { if (((default_parms->attr == NULL) && (entry_parms.attr != NULL)) || ((default_parms->attr != NULL) && (entry_parms.attr == NULL)) || ((default_parms->attr != NULL) && (entry_parms.attr != NULL) && (strcmp (entry_parms.attr, default_parms->attr) != 0))) { \
+            LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d", (default_parms->attr != NULL ? default_parms->attr : "none"), entry_parms.attr, buildfile_pathname, lineno); \
-                 QNX_TARGET, processor_base,
+               default_parms->attr = entry_parms.attr; \
-                 QNX_TARGET, processor,
+            } } while (0)
+         //APPLY_DEFAULT_ATTR_STR (new_cwd,                  "current working directory",       "\"%s\"");
+         APPLY_DEFAULT_ATTR_STR (search,                   "search path list",                "\"%s\"");
+         APPLY_DEFAULT_ATTR_STR (prefix,                   "prefix",                          "\"%s\"");
+         APPLY_DEFAULT_ATTR_NUM (dperms,                   "directory permissions",           "0%o");
+         APPLY_DEFAULT_ATTR_NUM (perms,                    "file permissions",                "0%o");
+         APPLY_DEFAULT_ATTR_NUM (uid,                      "owner ID",                        "%d");
+         APPLY_DEFAULT_ATTR_NUM (gid,                      "group ID",                        "%d");
+         APPLY_DEFAULT_ATTR_NUM (st_mode,                  "inode type",                      "0%o");
+         APPLY_DEFAULT_ATTR_NUM (is_compiled_bootscript,   "compiled script state",           "%d");
+         APPLY_DEFAULT_ATTR_NUM (should_follow_symlinks,   "symlink resolution",              "%d");
+         APPLY_DEFAULT_ATTR_NUM (should_autosymlink_dylib, "dylib canonical name symlinking", "%d");
+         APPLY_DEFAULT_ATTR_NUM (should_keep_ld_output,    "linker output preservation",      "%d");
-                 QNX_TARGET, processor,
+         #undef APPLY_DEFAULT_ATTR_STR
-                 QNX_TARGET, processor,
+         #undef APPLY_DEFAULT_ATTR_NUM
+         return; // end of line reached, proceed to the next line
+      }
-                 QNX_TARGET, processor,
+      // end of attributes parsing
+   } // end of "this line starts with an attributes block"
+   // there's data in this line. We expect a filename in the IFS. Read it and unescape escaped characters
+   string_len = sprintf_s (path_in_ifs, sizeof (path_in_ifs), "%s", (entry_parms.prefix != NULL ? entry_parms.prefix : ""));
+   while ((string_len > 0) && (path_in_ifs[string_len - 1] == '/'))
+      string_len--; // chop off any trailing slashes from prefix
-                 QNX_TARGET, processor);
+   write_ptr = &path_in_ifs[string_len];
+   *write_ptr++ = '/'; // add ONE trailing slash
+   specifiedpathname_start = write_ptr; // remember the specified pathname will start here
+   is_quoted_context = (*line_ptr == '"');
+   if (is_quoted_context)
+      line_ptr++; // skip a possible initial quote
+   if (*line_ptr == '/')
+   {
+      LOG_WARNING ("paths in the IFS file should not begin with a leading '/' in \"%s\" line %d", buildfile_pathname, lineno);
+      line_ptr++; // consistency check: paths in the IFS should not begin with a '/'
+   }
+   while ((*line_ptr != 0) && ((!is_quoted_context && (*line_ptr != '=') && !isspace (*line_ptr)) || (is_quoted_context && (*line_ptr == '"'))))
+   {
+      if (*line_ptr == '\\')
+      {
+         line_ptr++;
+         *write_ptr++ = *line_ptr; // unescape characters that are escaped with '\'
+      }
+      else
+         *write_ptr++ = *line_ptr;
+      line_ptr++;
+   }
+   *write_ptr = 0; // terminate the string
+   if (is_quoted_context && (*line_ptr == '"'))
+      line_ptr++; // skip a possible final quote
+   // we reached a space OR an equal sign
+   while ((*line_ptr != 0) && isspace (*line_ptr))
+      line_ptr++; // skip optional spaces after the filename in the IFS
+   // do we have an equal sign ?
+   if (*line_ptr == '=') // we must be creating either a directory or a file, do we have an equal sign ?
+   {
+      line_ptr++; // skip the equal sign
+      while ((*line_ptr != 0) && isspace (*line_ptr))
+         line_ptr++; // skip optional spaces after the equal sign
+      if (*line_ptr == 0)
+      {
+         LOG_WARNING ("syntax error in \"%s\" line %d: missing data specification after equal sign (skipping)", buildfile_pathname, lineno);
+         return; // invalid symlink specification, skip line
+      }
+      // read the host system's path, it may be either a path or a contents definition. Is it a content definition ?
+      if (*line_ptr == '{')
+      {
+         allocated_size = 0;
+         line_ptr++; // skip the leading content definition
+         is_escaped_char = false;
+         for (;;)
+         {
+            read_char = fgetc (buildfile_fp);
+            if (read_char == EOF)
+               DIE_WITH_EXITCODE (1, "syntax error in \"%s\" line %d: unterminated contents block (end of file reached)", buildfile_pathname, lineno); // invalid contents block
+            else if ((read_char == '\\') && !is_escaped_char)
+               is_escaped_char = true; // remember the next char is escaped
+            else if ((read_char == '}') && !is_escaped_char)
+               break; // found an unescaped closing bracked, stop parsing
+            else
+            {
+               is_escaped_char = false; // any other char, meaning the next one will not be escaped
+               if (!should_discard_inline_contents) // only store the contents if we do NOT know the data yet
+               {
+                  if (entry_parms.data.size == allocated_size) // reallocate in 4 kb blocks
+                  {
+                     reallocated_ptr = realloc (entry_parms.data.bytes, allocated_size + 4096);
+                     ASSERT_WITH_ERRNO (reallocated_ptr);
+                     entry_parms.data.bytes = reallocated_ptr;
+                     allocated_size += 4096;
+                  }
+                  entry_parms.data.bytes[entry_parms.data.size++] = read_char;
+               }
+               if (read_char == '\n')
+                  lineno++; // update line counter as we parse the inline content
+            }
+         } // end for
+      }
+      else // not a content definition between { brackets }, must be either a pathname on the build host, or the target of a symlink
+      {
+         is_quoted_context = (*line_ptr == '"');
+         if (is_quoted_context)
+            line_ptr++; // skip a possible initial quote
+         specifiedpathname_start = line_ptr; // remember where the specified pathname starts
+         write_ptr = line_ptr; // now unescape all characters
+         while ((*line_ptr != 0) && ((!is_quoted_context && !isspace (*line_ptr)) || (is_quoted_context && (*line_ptr == '"'))))
+         {
+            if (*line_ptr == '\\')
+            {
+               line_ptr++;
+               *write_ptr++ = *line_ptr; // unescape characters that are escaped with '\'
+            }
+            else
+               *write_ptr++ = *line_ptr;
+            line_ptr++;
+         }
+         *write_ptr = 0; // terminate the string
+         if (is_quoted_context && (*line_ptr == '"'))
+            line_ptr++; // skip a possible final quote
+         if (S_ISLNK (entry_parms.st_mode)) // are we storing a symlink ?
+            ASSERT_WITH_ERRNO (Buffer_InitWithCString (&entry_parms.data, specifiedpathname_start)); // if so, store the symlink target as the dirent's blob data
+         else // it's a build host filesystem path
+            strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is given after the equal sign
+      }
+   }
+   else // no equal sign, meaning the file will have the same name on the build host filesystem
+   {
+      // consistency check: symlinks MUST have an equal sign
+      if (entry_parms.st_mode == S_IFLNK)
+      {
+         LOG_WARNING ("syntax error in \"%s\" line %d: missing equal sign and symlink target (skipping)", buildfile_pathname, lineno);
+         return; // invalid symlink specification, skip line
+      }
+      strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is the one specified
+      sep = strrchr (specifiedpathname_start, '/');
+      if (sep != NULL)
+         memmove (specifiedpathname_start, sep + 1, strlen (sep + 1) + 1); // the path in the IFS will be the BASENAME of the path specified (after the prefix)
+   }
+   // now add this entry to the image filesystem
+   if (S_ISDIR (entry_parms.st_mode))
+      entry_parms.st_mode |= entry_parms.dperms;
+   else if (S_ISLNK (entry_parms.st_mode))
+      entry_parms.st_mode |= 0777; // NOTE: mkifs sets symlink permissions to rwxrwxrwx !?
+   else // file or device node
+      entry_parms.st_mode |= entry_parms.perms;
+   add_fsentry (fsentries, fsentry_count, &entry_parms, path_in_ifs, path_on_buildhost); // and add filesystem entry
+   if (entry_parms.data.bytes != NULL)
+      free (entry_parms.data.bytes); // if blob data was allocated, free it
-   return;
+   return; //  finished parsing that line
+}
 int main (int argc, char **argv)
+{
       .prefix = "/proc/boot",
       .should_follow_symlinks = true, // [+|-followlink]
       .should_autosymlink_dylib = true, // [+|-autolink]
       .is_compiled_bootscript = false, // [+|-script]
       .extra_ino_flags = 0,
-      .search = "",
+      .search = NULL,
       .data = { NULL, 0 }
    };
    static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
    char path_on_buildhost[MAXPATHLEN] = "";
    char path_in_ifs[MAXPATHLEN] = "";
    char *ifs_pathname = NULL;
    void *reallocated_ptr;
-   struct tm utc_time;
-   struct stat stat_buf;
-   size_t imgdir_size;
+   size_t reallocated_size;
    size_t available_space;
-   size_t allocated_size;
    size_t fsentry_index;
    size_t largest_index;
    size_t largest_size;
+   size_t imgdir_size;
    size_t curr_offset;
    ifs_t ifs = { 0 };
    int32_t checksum;
    char *first_pathname = NULL;
    char *second_pathname = NULL;
-   char *specifiedpathname_start;
-   char *directiveblock_start;
-   char *write_ptr;
-   char *line_ptr;
-   char *token;
-   char *value;
    char *sep;
-   char *ctx;
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
    bool should_discard_inline_contents = false;
    bool want_info = false;
    bool want_help = false;
    bool want_dump = false;
    bool want_strip = false;
    bool want_hexdump = false;
    bool is_foreign_endianness;
-   int string_len;
-   int read_char;
    FILE *buildfile_fp;
+   // initialize stuff
+   saved_ELF_sections = (char **) malloc (4 * sizeof (char *));
+   ASSERT_WITH_ERRNO (saved_ELF_sections);
+   saved_ELF_sections[0] = "QNX_info"; // NOTE: MUST BE THE FIRST ONE as we artificially shrink down the array to 1 when using it for boot ELF files
+   saved_ELF_sections[1] = ".gnu_debuglink";
+   saved_ELF_sections[2] = "QNX_usage";
+   saved_ELF_sections[3] = ".note.gnu.build-id"; // undocumented by QNX, but nonetheless preserved
+   saved_ELF_section_count = 4;
    // parse arguments
    for (arg_index = 1; arg_index < argc; arg_index++)
+   {
       if ((strcmp (argv[arg_index], "--bootfile") == 0) && (arg_index + 1 < argc)) // --bootfile path/to/blob.bin
          want_strip = true;
       else if (strcmp (argv[arg_index], "--everything") == 0)
          want_everything = true;
       else if (strncmp (argv[arg_index], "-v", 2) == 0) // -v[....]
          verbose_level += (int) strlen (argv[arg_index] + 1); // increase verbosity by the number of characters in this flag
+      else if ((strcmp (argv[arg_index], "-l") == 0) && (arg_index + 1 < argc))
+         arg_index++; // these args will be parsed once the build file is open
+      else if ((strcmp (argv[arg_index], "-r") == 0) && (arg_index + 1 < argc))
+      {
+         reallocated_size = (SEARCH_PATH != NULL ? strlen (SEARCH_PATH) + 1 : 0) + strlen (argv[arg_index + 1]) + 1;
+         reallocated_ptr = realloc (SEARCH_PATH, reallocated_size); // grow search prefixes array
+         ASSERT_WITH_ERRNO (reallocated_ptr);
+         if (SEARCH_PATH != NULL)
+            strcat_s (reallocated_ptr, reallocated_size, PATH_SEP);
+         strcat_s (reallocated_ptr, reallocated_size, argv[++arg_index]); // stack up another search prefix
+         SEARCH_PATH = reallocated_ptr;
+      }
+      else if ((strcmp (argv[arg_index], "-s") == 0) && (arg_index + 1 < argc))
+      {
+         reallocated_ptr = realloc (saved_ELF_sections, (saved_ELF_section_count + 1) * sizeof (char *)); // grow ELF sections array
+         ASSERT_WITH_ERRNO (reallocated_ptr);
+         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)
          first_pathname = argv[arg_index];
       else if (second_pathname == NULL)
       fprintf (out, "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");
       fprintf (out, "          version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
       if (!want_help)
          fprintf (out, "error: missing parameters\n");
       fprintf (out, "usage:\n");
-      fprintf (out, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-n[n]] [-v[...]] <buildfile> <outfile>\n");
       fprintf (out, "    ifstool --info [--everything] <ifs file>\n");
       fprintf (out, "    ifstool --dump [--outdir <path>] <ifs file>\n");
       fprintf (out, "    ifstool --strip [--outfile <pathname>] <ELF file>\n");
-      fprintf (out, "    ifstool --help\n");
+      fprintf (out, "    ifstool [-?|--help]\n");
+      fprintf (out, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-l inputline] [-n[n]] [-r rootdir] [-v[...]] <buildfile> <outfile>\n");
-      fprintf (out, "NOTE: the compilation feature requires predigested boot, startup and kernel files produced by mkifs.\n");
+      fprintf (out, "NOTE: the compiler mode requires predigested boot, startup and kernel files produced by mkifs.\n");
+      fprintf (out, "options:\n");
+      fprintf (out, "    -?       Display some help information.\n");
+//      fprintf (out, "    -a .ext  Append a suffix to symbol files generated via [+keeplinked].\n");
+      fprintf (out, "    -l line  Process line before interpreting the buildfile. Input lines given\n");
+      fprintf (out, "             to mkifs should be quoted to prevent interpretation by the shell\n");
+      fprintf (out, "             (especially as mkifs input lines often contain spaces). Multiple\n");
+      fprintf (out, "             -l options are processed in the order specified. No default.\n");
+      fprintf (out, "    -n[n]    Force the modification times of all inline files to be 0. If you\n");
+      fprintf (out, "             specify -nn, mkifs sets the modification times of all files to 0.\n");
+      fprintf (out, "             When mkifs adds files to an IFS image, it uses the timestamp info\n");
+      fprintf (out, "             from the file on the host machine. If mkifs is creating an inline\n");
+      fprintf (out, "             file (which doesn't exist on the host machine), it must generate\n");
+      fprintf (out, "             its own timestamp information. By default, it's the time at which\n");
+      fprintf (out, "             the image is generated. This results in different checksum values\n");
+      fprintf (out, "             for two identical builds, because the file's times are different.\n");
+      fprintf (out, "             If you use -n, the checksum value is the same on all identical\n");
+      fprintf (out, "             builds. The -nn option addresses a quirk in NTFS with daylight\n");
+      fprintf (out, "             savings time. This forces the modification time for all files in\n");
+      fprintf (out, "             the IFS image to be set to 0. This ensures that subsequent builds\n");
+      fprintf (out, "             of the same IFS image have the same checksum.");
+//      fprintf (out, "    -o dir   Specify a directory to be used for all permanent build artifacts,\n");
+//      fprintf (out, "             other than the output image itself. The most common example is\n");
+//      fprintf (out, "             the .sym files generated by the [+keeplinked] attribute.\n");
+//      fprintf (out, "    -p file  Apply patching instructions from this file.\n");
+      fprintf (out, "    -r dir   When searching for host files to be included in the image, search\n");
+      fprintf (out, "             the default paths used for storing binaries within the specified\n");
+      fprintf (out, "             directory before searching the default paths within $QNX_TARGET.\n");
+      fprintf (out, "             You can define multiple -r options; each adds a set of paths to\n");
+      fprintf (out, "             search for files. The -r options are evaluated from left to right\n");
+      fprintf (out, "             meaning the paths prefixed with the first (leftmost) rootdir are\n");
+      fprintf (out, "             searched first, then those prefixed with the second rootdir, and\n");
+      fprintf (out, "             so on.\n");
+      fprintf (out, "             Normally, mkifs searches any paths defined in $MKIFS_PATH when\n");
+      fprintf (out, "             it was called and then the default paths within $QNX_TARGET. The\n");
+      fprintf (out, "             default paths are based on the CPU architecture specified by\n");
+      fprintf (out, "             $PROCESSOR and $PROCESSOR_BASE. If you specify -r options, mkifs\n");
+      fprintf (out, "             searches the default paths prefixed with each dir variable before\n");
+      fprintf (out, "             searching those within $QNX_TARGET. These paths are:\n");
+      fprintf (out, "               dir/${PROCESSOR}/sbin\n");
+      fprintf (out, "               dir/${PROCESSOR}/usr/sbin\n");
+      fprintf (out, "               dir/${PROCESSOR}/boot/sys\n");
+      fprintf (out, "               dir/${PROCESSOR_BASE}/boot/sys\n");
+      fprintf (out, "               dir/${PROCESSOR}/bin\n");
+      fprintf (out, "               dir/${PROCESSOR}/usr/bin\n");
+      fprintf (out, "               dir/${PROCESSOR}/lib\n");
+      fprintf (out, "               dir/${PROCESSOR}/lib/dll\n");
+      fprintf (out, "               dir/${PROCESSOR}/usr/lib\n");
+      fprintf (out, "             NOTE: The structure of the directory paths under dir must be\n");
+      fprintf (out, "             identical to that of the default paths under $QNX_TARGET, but the\n");
+      fprintf (out, "             root dir itself may be any path you choose. For example, if you\n");
+      fprintf (out, "             wanted to include /scratch/aarch64le/sbin/devb-sata, you would\n");
+      fprintf (out, "             specify a -r option like this:\n");
+      fprintf (out, "               -r /scratch\n");
+      fprintf (out, "             Note that you don't include $PROCESSOR or $PROCESSOR_BASE in dir.\n");
+      fprintf (out, "    -s name  Don't strip the named section from ELF executables when creating\n");
+      fprintf (out, "             an IFS image. You can use this option more than once to specify\n");
+      fprintf (out, "             additional sections. By default, mkifs doesn't strip:\n");
+      fprintf (out, "               .gnu_debuglink - the name and checksum of the debug info file\n");
+      fprintf (out, "               QNX_info       - build properties\n");
+      fprintf (out, "               QNX_usage      - usage message\n");
+      fprintf (out, "             You can use the keepsection attribute to specify the sections\n");
+      fprintf (out, "             that are not to be stripped from specific files in the image. For\n");
+      fprintf (out, "             files in the bootstrap section (like startup or procnto), the\n");
+      fprintf (out, "             global keepsection list affected by -s does not apply to these\n");
+      fprintf (out, "             files. For them, only the QNX_info section is kept.\n");
+      fprintf (out, "    -v[v..]  Operate verbosely. Specifying additional v options increases the\n");
+      fprintf (out, "             verbosity.\n");
       exit (want_help ? 0 : 1);
+   }
    // do we want info about a particular IFS ? if so, dissecate it
    if (want_info)
    // 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, first_pathname), "error stripping \"%s\": %s", first_pathname, strerror (errno));
+      ASSERT (Buffer_StripELFFile (&file, saved_ELF_sections, saved_ELF_section_count, 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
    QNX_TARGET = getenv ("QNX_TARGET");
    if (QNX_TARGET == NULL)
       DIE_WITH_EXITCODE (1, "the QNX_TARGET environment variable is not set");
    else if (access (QNX_TARGET, 0) != 0)
       DIE_WITH_EXITCODE (1, "the QNX_TARGET environment variable doesn't point to an existing directory");
-   // prepare a default MKIFS_PATH assuming the host processor
-   update_MKIFS_PATH (image_processor);
    // open build file
    fopen_s (&buildfile_fp, buildfile_pathname, "rb");
    if (buildfile_fp == NULL)
       DIE_WITH_EXITCODE (1, "unable to open build file \"%s\" for reading: %s", buildfile_pathname, strerror (errno));
    // stack up filesystem entries
    memcpy (&entry_parms, &default_parms, sizeof (default_parms));
    entry_parms.st_mode = S_IFDIR | default_parms.dperms;
    add_fsentry (&fsentries, &fsentry_count, &entry_parms, "", NULL); // add the root dir first
+   // parse -l arguments before everything else
+   for (arg_index = 1; arg_index < argc; arg_index++)
+      if ((strcmp (argv[arg_index], "-l") == 0) && (arg_index + 1 < argc))
+         parse_line (NULL, argv[++arg_index], &fsentries, &fsentry_count, &default_parms);
    // parse the IFS build file line per line
    while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)
+   {
       if (current_line != NULL)
          free (current_line);
       current_line = strdup (line_buffer);
       ASSERT_WITH_ERRNO (current_line);
       lineno++; // keep track of current line number
+      parse_line (buildfile_fp, line_buffer, &fsentries, &fsentry_count, &default_parms);
+   }
-      line_ptr = line_buffer;
-      while ((*line_ptr != 0) && isspace (*line_ptr))
+   fclose (buildfile_fp); // finished parsing the build file
-         line_ptr++; // skip leading spaces
-      if ((*line_ptr == 0) || (*line_ptr == '#'))
-         continue; // skip empty or comment lines
-      string_len = (int) strlen (line_buffer);
+   // parse the IFS build file line per line
-      if ((string_len > 0) && (line_buffer[string_len - 1] == '\n'))
+   while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)
-         line_buffer[string_len - 1] = 0; // chop off newline for easier debug output
-      // reset entry values
-      memcpy (&entry_parms, &default_parms, sizeof (default_parms));
-      path_in_ifs[0] = 0;
-      path_on_buildhost[0] = 0;
-      should_discard_inline_contents = false;
-      // does this line start with an attribute block ?
-      if (*line_ptr == '[')
-      {
+   {
-         line_ptr++; // skip the leading square bracket
-         directiveblock_start = line_ptr; // remember where it starts
-         is_quoted_context = false;
-         while ((*line_ptr != 0) && !((*line_ptr == ']') && (line_ptr[-1] != '\\') && !is_quoted_context))
-         {
-            if (*line_ptr == '"')
-               is_quoted_context ^= true; // remember when we're between quotes
-            else if (!is_quoted_context && (*line_ptr == ' '))
-               *line_ptr = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting
-            line_ptr++; // reach the next unescaped closing square bracket
-         }
-         if (*line_ptr != ']')
-         {
-            LOG ("warning", 0, "syntax error in \"%s\" line %d: unterminated attributes block (skipping)", buildfile_pathname, lineno);
-            continue; // invalid attribute block, skip line
-         }
-         *line_ptr = 0; // end the attribute block so that it is a parsable C string
-         // now parse the attribute tokens
-         // DOCUMENTATION: https://www.qnx.com/developers/docs/8.0/com.qnx.doc.neutrino.utilities/topic/m/mkifs.html#mkifs__description
-         token = strtok_r (directiveblock_start, RECORD_SEP, &ctx);
-         while (token != NULL)
+      if (current_line != NULL)
-         {
-            // evaluate attribute token
-            #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)
-            if      (strncmp (token, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.uid     = (int) read_integer (value); }
-            else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.gid     = (int) read_integer (value); }
-            else if (strncmp (token, "dperms=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms.dperms  = (int) read_integer (value); }
-            else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms.perms   = (int) read_integer (value); }
-            else if (strncmp (token, "type=",    5) == 0) { REACH_TOKEN_VALUE ();
-               if      (strcmp (value, "dir")  == 0) entry_parms.st_mode = S_IFDIR;
-               else if (strcmp (value, "file") == 0) entry_parms.st_mode = S_IFREG;
-               else if (strcmp (value, "link") == 0) entry_parms.st_mode = S_IFLNK;
-               else if (strcmp (value, "fifo") == 0) entry_parms.st_mode = S_IFIFO;
-               else DIE_WITH_EXITCODE (1, "invalid 'type' attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, value);
-            }
-            else if (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); strcpy_s (entry_parms.prefix, sizeof (entry_parms.prefix), (*value == '/' ? value + 1 : value)); } // skip possible leading slash in prefix
-            else if (strncmp (token, "image=",   6) == 0) { REACH_TOKEN_VALUE ();
-               image_base = (uint32_t) read_integer (value); // read image base address
-               if ((sep = strchr (value, '-')) != NULL) image_end       = (uint32_t) read_integer (sep + 1); // if we have a dash, read optional image end (TODO: check this value and produce an error in the relevant case. Not important.)
-               if ((sep = strchr (value, ',')) != NULL) image_maxsize   = (uint32_t) read_integer (sep + 1); // if we have a comma, read optional image max size
-               if ((sep = strchr (value, '=')) != NULL) image_totalsize = (uint32_t) read_integer (sep + 1); // if we have an equal sign, read optional image padding size
-               if ((sep = strchr (value, '%')) != NULL) image_align     = (uint32_t) read_integer (sep + 1); // if we have a modulo sign, read optional image aligmnent
-               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
-                  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
-                  update_MKIFS_PATH (image_processor);
-                  value = sep + 1;
-               }
-               //sprintf (image_bootfile, "%s/%s/boot/sys/%s.boot", QNX_TARGET, image_processor, value); // save preboot file name (TODO: we should search in MKIFS_PATH instead of this. Not important.)
-               //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");
-#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)
-                  {
-                     LOG_WARNING ("syntax error in \"%s\" line %d: mtime specification not in YYYY-MM-DD-HH:MM:SS format (skipping)", buildfile_pathname, lineno);
-                     continue; // invalid attribute block, skip line
-                  }
-                  utc_time.tm_mon--; // convert month from [1-12] to [0-11]
-                  entry_parms.mtime = (uint32_t) mktime (&utc_time);
-               }
-            }
-            else if (strcmp (token, "+script")     == 0) {
-               entry_parms.is_compiled_bootscript = true;
-               ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&entry_parms.data, INITIAL_STARTUP_SCRIPT)); // FIXME: HACK until the script compiler is implemented
-               should_discard_inline_contents = true; // remember we already have data (so as to discard the inline block's contents)
-            }
-            else if (strcmp (token, "-script")     == 0) entry_parms.is_compiled_bootscript = false;
-            else if (strcmp (token, "+followlink") == 0) entry_parms.should_follow_symlinks = true;
-            else if (strcmp (token, "-followlink") == 0) entry_parms.should_follow_symlinks = false;
-            else if (strcmp (token, "+autolink")   == 0) entry_parms.should_autosymlink_dylib = true;
-            else if (strcmp (token, "-autolink")   == 0) entry_parms.should_autosymlink_dylib = false;
-            else if (strcmp (token, "+keeplinked") == 0) entry_parms.should_keep_ld_output = true;
-            else if (strcmp (token, "-keeplinked") == 0) entry_parms.should_keep_ld_output = false;
-            else LOG_WARNING ("unimplemented 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
-         }
-         line_ptr++; // reach the next character
-         while ((*line_ptr != 0) && isspace (*line_ptr))
-            line_ptr++; // skip leading spaces
-         // are we at the end of the line ? if so, it means the attribute values that are set should become the default
-         if ((*line_ptr == 0) || (*line_ptr == '#'))
-         {
-            #define APPLY_DEFAULT_ATTR_NUM(attr,descr,fmt) do { if (entry_parms.attr != default_parms.attr) { \
-                  LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d", default_parms.attr, entry_parms.attr, buildfile_pathname, lineno); \
-                  default_parms.attr = entry_parms.attr; \
-               } } while (0)
-            #define APPLY_DEFAULT_ATTR_STR(attr,descr,fmt) do { if (strcmp (entry_parms.attr, default_parms.attr) != 0) { \
-                  LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %d", default_parms.attr, entry_parms.attr, buildfile_pathname, lineno); \
-                  strcpy_s (default_parms.attr, sizeof (default_parms.attr), entry_parms.attr); \
-               } } while (0)
-            APPLY_DEFAULT_ATTR_NUM (dperms,                   "directory permissions",           "0%o");
-            APPLY_DEFAULT_ATTR_NUM (perms,                    "file permissions",                "0%o");
-            APPLY_DEFAULT_ATTR_NUM (uid,                      "owner ID",                        "%d");
-            APPLY_DEFAULT_ATTR_NUM (gid,                      "group ID",                        "%d");
-            APPLY_DEFAULT_ATTR_NUM (st_mode,                  "inode type",                      "0%o");
-            APPLY_DEFAULT_ATTR_STR (prefix,                   "prefix",                          "\"%s\"");
-            APPLY_DEFAULT_ATTR_NUM (is_compiled_bootscript,   "compiled script state",           "%d");
-            APPLY_DEFAULT_ATTR_NUM (should_follow_symlinks,   "symlink resolution",              "%d");
-            APPLY_DEFAULT_ATTR_NUM (should_autosymlink_dylib, "dylib canonical name symlinking", "%d");
-            APPLY_DEFAULT_ATTR_NUM (should_keep_ld_output,    "linker output preservation",      "%d");
-            #undef APPLY_DEFAULT_ATTR_STR
-            #undef APPLY_DEFAULT_ATTR_NUM
-            continue; // end of line reached, proceed to the next line
-         }
-         // end of attributes parsing
-      } // end of "this line starts with an attributes block"
-      // there's data in this line. We expect a filename in the IFS. Read it and unescape escaped characters
-      string_len = sprintf_s (path_in_ifs, sizeof (path_in_ifs), "%s", entry_parms.prefix);
-      while ((string_len > 0) && (path_in_ifs[string_len - 1] == '/'))
-         string_len--; // chop off any trailing slashes from prefix
-      write_ptr = &path_in_ifs[string_len];
-      *write_ptr++ = '/'; // add ONE trailing slash
-      specifiedpathname_start = write_ptr; // remember the specified pathname will start here
-      is_quoted_context = (*line_ptr == '"');
-      if (is_quoted_context)
-         line_ptr++; // skip a possible initial quote
-      if (*line_ptr == '/')
-      {
-         LOG_WARNING ("paths in the IFS file should not begin with a leading '/' in \"%s\" line %d", buildfile_pathname, lineno);
-         line_ptr++; // consistency check: paths in the IFS should not begin with a '/'
-      }
-      while ((*line_ptr != 0) && ((!is_quoted_context && (*line_ptr != '=') && !isspace (*line_ptr)) || (is_quoted_context && (*line_ptr == '"'))))
-      {
-         if (*line_ptr == '\\')
-         {
-            line_ptr++;
+         free (current_line);
-            *write_ptr++ = *line_ptr; // unescape characters that are escaped with '\'
-         }
-         else
-            *write_ptr++ = *line_ptr;
+      current_line = strdup (line_buffer);
-         line_ptr++;
-      }
-      *write_ptr = 0; // terminate the string
-      if (is_quoted_context && (*line_ptr == '"'))
-         line_ptr++; // skip a possible final quote
-      // we reached a space OR an equal sign
-      while ((*line_ptr != 0) && isspace (*line_ptr))
-         line_ptr++; // skip optional spaces after the filename in the IFS
-      // do we have an equal sign ?
-      if (*line_ptr == '=') // we must be creating either a directory or a file, do we have an equal sign ?
-      {
-         line_ptr++; // skip the equal sign
-         while ((*line_ptr != 0) && isspace (*line_ptr))
-            line_ptr++; // skip optional spaces after the equal sign
-         if (*line_ptr == 0)
-         {
-            LOG_WARNING ("syntax error in \"%s\" line %d: missing data specification after equal sign (skipping)", buildfile_pathname, lineno);
-            continue; // invalid symlink specification, skip line
-         }
-         // read the host system's path, it may be either a path or a contents definition. Is it a content definition ?
-         if (*line_ptr == '{')
-         {
-            allocated_size = 0;
-            line_ptr++; // skip the leading content definition
-            is_escaped_char = false;
-            for (;;)
-            {
-               read_char = fgetc (buildfile_fp);
-               if (read_char == EOF)
-                  DIE_WITH_EXITCODE (1, "syntax error in \"%s\" line %d: unterminated contents block (end of file reached)", buildfile_pathname, lineno); // invalid contents block
-               else if ((read_char == '\\') && !is_escaped_char)
-                  is_escaped_char = true; // remember the next char is escaped
-               else if ((read_char == '}') && !is_escaped_char)
-                  break; // found an unescaped closing bracked, stop parsing
-               else
-               {
-                  is_escaped_char = false; // any other char, meaning the next one will not be escaped
-                  if (!should_discard_inline_contents) // only store the contents if we do NOT know the data yet
-                  {
-                     if (entry_parms.data.size == allocated_size) // reallocate in 4 kb blocks
-                     {
-                        reallocated_ptr = realloc (entry_parms.data.bytes, allocated_size + 4096);
-                        ASSERT_WITH_ERRNO (reallocated_ptr);
+      ASSERT_WITH_ERRNO (current_line);
-                        entry_parms.data.bytes = reallocated_ptr;
-                        allocated_size += 4096;
-                     }
-                     entry_parms.data.bytes[entry_parms.data.size++] = read_char;
-                  }
-                  if (read_char == '\n')
-                     lineno++; // update line counter as we parse the inline content
-               }
-            } // end for
-         }
-         else // not a content definition between { brackets }, must be either a pathname on the build host, or the target of a symlink
-         {
-            is_quoted_context = (*line_ptr == '"');
-            if (is_quoted_context)
-               line_ptr++; // skip a possible initial quote
-            specifiedpathname_start = line_ptr; // remember where the specified pathname starts
-            write_ptr = line_ptr; // now unescape all characters
-            while ((*line_ptr != 0) && ((!is_quoted_context && !isspace (*line_ptr)) || (is_quoted_context && (*line_ptr == '"'))))
-            {
-               if (*line_ptr == '\\')
-               {
-                  line_ptr++;
-                  *write_ptr++ = *line_ptr; // unescape characters that are escaped with '\'
-               }
-               else
-                  *write_ptr++ = *line_ptr;
-               line_ptr++;
-            }
-            *write_ptr = 0; // terminate the string
-            if (is_quoted_context && (*line_ptr == '"'))
-               line_ptr++; // skip a possible final quote
+      lineno++; // keep track of current line number
-            if (S_ISLNK (entry_parms.st_mode)) // are we storing a symlink ?
-               ASSERT_WITH_ERRNO (Buffer_InitWithCString (&entry_parms.data, specifiedpathname_start)); // if so, store the symlink target as the dirent's blob data
-            else // it's a build host filesystem path
-               strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is given after the equal sign
-         }
-      }
-      else // no equal sign, meaning the file will have the same name on the build host filesystem
-      {
-         // consistency check: symlinks MUST have an equal sign
-         if (entry_parms.st_mode == S_IFLNK)
-         {
-            LOG_WARNING ("syntax error in \"%s\" line %d: missing equal sign and symlink target (skipping)", buildfile_pathname, lineno);
-            continue; // invalid symlink specification, skip line
-         }
-         strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is the one specified
-         sep = strrchr (specifiedpathname_start, '/');
-         if (sep != NULL)
-            memmove (specifiedpathname_start, sep + 1, strlen (sep + 1) + 1); // the path in the IFS will be the BASENAME of the path specified (after the prefix)
-      }
-      // now add this entry to the image filesystem
-      if (S_ISDIR (entry_parms.st_mode))
-         entry_parms.st_mode |= entry_parms.dperms;
-      else if (S_ISLNK (entry_parms.st_mode))
-         entry_parms.st_mode |= 0777; // NOTE: mkifs sets symlink permissions to rwxrwxrwx !?
-      else // file or device node
-         entry_parms.st_mode |= entry_parms.perms;
-      add_fsentry (&fsentries, &fsentry_count, &entry_parms, path_in_ifs, path_on_buildhost); // and add filesystem entry
-      if (entry_parms.data.bytes != NULL)
-         free (entry_parms.data.bytes); // if blob data was allocated, free it
+   }
    fclose (buildfile_fp); // finished parsing the build file
    //////////////////////////////////

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/ifstool.c – Rev 16 → 17