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

 const char *__asan_default_options () { return ("detect_leaks=0"); }
 // placeholder value
 #define WILL_BE_FILLED_LATER 0xbaadf00d // urgh
+// boot type values
+#define BOOTTYPE_NONE 0
+#define BOOTTYPE_BIOS 1
+#define BOOTTYPE_UEFI 2
 // miscellaneous macros
 #define ROUND_TO_UPPER_MULTIPLE(val,multiple) ((((val) + (size_t) (multiple) - 1) / (multiple)) * (multiple)) // note that val is being evaluated once, so it can be the result of a function call
 #ifdef _WIN32
 static char **saved_ELF_sections = NULL; // mallocated array of const strings, populated by the -s command-line argument
 static size_t saved_ELF_section_count = 0; // number of elements in the saved_ELF_sections array
 static char *sym_suffix = ""; // .sym files extra suffix, settable with the -a command-line argument
 // bootable IFS support
+static int boot_type = BOOTTYPE_NONE;
-static char *bootfile_pathname = NULL;           // FIXME: HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS
+static char *bootfile_pathname = NULL;           // FIXME: HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS in BIOS mode
-static size_t bootfile_size = 0;                 // FIXME: HACK: size of the bootcode binary blob file to put at the start of a bootable IFS
+static size_t bootfile_size = 0;                 // FIXME: HACK: size of the bootcode binary blob file to put at the start of a bootable IFS in BIOS mode
 static char *startupfile_pathname = NULL;        // FIXME: HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS
 static size_t startupfile_ep_from_imagebase = 0; // FIXME: HACK: startup code entrypoint offset from image base for a bootable IFS
 static size_t kernelfile_offset = 0;             // kernel file offset in the IFS (first offset rounded at pagesize after the dirents table)
 // 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 long long read_integer (const char *str, const int base_or_zero_for_auto); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)
 static char *resolve_envvars (const char *str); // resolves environment variables in str and replaces them with their value, or an empty string if undefined. Returns a mallocated string (caller frees)
 static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar); // locates pathname among the known search paths and returns a pointer to the resolved pathname (static string)
 static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file
 static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs_data, const size_t write_offset, const fsentry_t *fsentry); // writes the given filesystem entry (without its contents) to the IFS buffer
 static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, const fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer
    return (is_foreign_endianness ? __builtin_bswap32 (-image_cksum) : -image_cksum);
+}
-static long long read_integer (const char *str)
+static long long read_integer (const char *str, const int base_or_zero_for_auto)
+{
    // reads a number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)
    char *endptr = NULL;
-   long long ret = strtoll (str, &endptr, 0); // use strtoll() to handle hexadecimal (0x...), octal (0...) and decimal (...) bases
+   long long ret = strtoll (str, &endptr, base_or_zero_for_auto); // use strtoll() to handle hexadecimal (0x...), octal (0...) and decimal (...) bases
    if (endptr != NULL)
+   {
       if      ((*endptr == 'k') || (*endptr == 'K')) ret *= (size_t) 1024;
       else if ((*endptr == 'm') || (*endptr == 'M')) ret *= (size_t) 1024 * 1024;
       else if ((*endptr == 'g') || (*endptr == 'G')) ret *= (size_t) 1024 * 1024 * 1024;
       endbit_len = strlen (endbit); // measure the length of the end bit (skip the closing curly brace)
       erased_char = endbit[erase_index]; // remember which is the character we're going to erase
       endbit[erase_index] = 0; // split the string at the end of the variable name
       if (strcmp (varname, "PFS") == 0)
          replacement = PATH_SEP; // special case: if it's the PFS variable, select ":" or ";" based on the host platform
+      else if (strcmp (varname, "PROCESSOR") == 0)
+         replacement = image_processor; // special case: if it's PROCESSOR, replace it with the processor name (e.g. "aarch64le")
+      else if (strcmp (varname, "PROCESSOR_BASE") == 0)
+         replacement = image_processor_base; // special case: if it's PROCESSOR_BASE, replace it with the processor base name (e.g. "aarch64")
       else
          replacement = getenv (varname); // peek at the environment for its value
       if (replacement == NULL)
          replacement = ""; // if this variable isn't defined, fallback to an empty string, just like what a UNIX shell does
       endbit[erase_index] = erased_char; // put the erased character back
    // is the file we're storing a preprocessed ELF file ?
    if (fsentry->header.ino & IFS_INO_PROCESSED_ELF)
+   {
-      elf = (elf_header_t *) fsentry->u.file.UNSAVED_databuf; // quick access to ELF header
+      elf = (elf_header_t *) fsentry->UNSAVED_databuf; // quick access to ELF header
       table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
       for (table_index = 0; table_index < table_count; table_index++)
+      {
-         phdr = (elf_program_header_t *) &fsentry->u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+         phdr = (elf_program_header_t *) &fsentry->UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
          //segment_type = ELF_GET_NUMERIC (elf, phdr, segment_type); // get segment type
          //if (!((segment_type >= 2) && (segment_type <= 7) || ((segment_type >= 0x6474e550) && (segment_type <= 0x6474e552)) || (segment_type == 0x70000001)))
          //   continue; // NOTE: only certain segments types must be corrected
             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
+   ASSERT_WITH_ERRNO (Buffer_Append (ifs_data, fsentry->UNSAVED_databuf, fsentry->u.file.size)); // write file data blob
    return (ifs_data->size - data_offset); // return the number of bytes written
+}
 static inline size_t Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (buffer_t *buffer, const char *str)
    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;
+   const char *filename_bit;
    buffer_t current_line;
    buffer_t compiled_script;
    buffer_t compiled_scriptline;
    buffer_t *shstrtab = NULL;
    const char *canonical_dylib_name;
    const char *dynamic_strings; // strings table of the ".dynamic" section
    const char *last_dirsep;
    size_t array_index;
    size_t line_index;
    size_t fsentry_index;
+   size_t pathbit_len;
    size_t wait_time;
    char *resolved_pathname;
    char *linebit_start;
    char *write_ptr;
    char *read_ptr;
                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.)
-                  else 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, 10); }
-                  else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->gid     = (int) read_integer (value); }
+                  else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->gid     = (int) read_integer (value, 10); }
-                  else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms->perms   = (int) read_integer (value); }
+                  else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms->perms   = (int) read_integer (value, 8); }
                   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 %zd of inline document '%s': '%s'", buildfile_pathname, 1 + line_index, stored_pathname, token);
          STRINGARRAY_INIT (&linker_argv);
          STRINGARRAY_PUSH (&linker_argv, strrchr (linker_pathname, '/') + 1); // "${TARGET_TRIPLE}-ld"
          STRINGARRAY_PUSH (&linker_argv, linker_sysroot_arg); // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"
          STRINGARRAY_PUSH (&linker_argv, linker_script_pathname_arg); // "-T${QNX_TARGET}/${TARGET_CPU}/lib/nto.link"
          STRINGARRAY_PUSH (&linker_argv, "--section-start");
-         STRINGARRAY_PUSH (&linker_argv, ".text=0xffff800000001000");
+         STRINGARRAY_PUSH (&linker_argv, (boot_type == BOOTTYPE_UEFI ? ".text=0xffff800000002000" : ".text=0xffff800000001000")); // FIXME: wild assumption!
          STRINGARRAY_PUSH (&linker_argv, "--no-relax");
          STRINGARRAY_PUSH (&linker_argv, procnto_buildhost_pathname); // "${QNX_TARGET}/${TARGET_CPU}/boot/sys/procnto-smp-instr"
          STRINGARRAY_PUSH (&linker_argv, "-o");
          STRINGARRAY_PUSH (&linker_argv, procnto_sym_filename); // "procnto-smp-instr.sym"
 #ifdef __GNUC__
                   ASSERT_WITH_ERRNO (Buffer_WriteInt8At (&compiled_scriptline, 8, (current_scriptcmd_params.sched_policy != -1 ? current_scriptcmd_params.sched_policy : 0))); // scheduling policy
                   ASSERT_WITH_ERRNO (Buffer_WriteInt8At (&compiled_scriptline, 9, (current_scriptcmd_params.priority != -1 ? current_scriptcmd_params.priority : 0))); // scheduling priority
                   ASSERT_WITH_ERRNO (Buffer_WriteInt8At (&compiled_scriptline, 10, (uint8_t) line_argv.count)); // argc
                   ASSERT_WITH_ERRNO (Buffer_WriteInt8At (&compiled_scriptline, 11, (uint8_t) global_envp.count)); // envc
                   ASSERT_WITH_ERRNO (Buffer_Append (&compiled_scriptline, line_argv.args[0], strlen (line_argv.args[0]) + 1)); // executable
+                  if (current_scriptcmd_params.argv0 != NULL)
-                  ASSERT_WITH_ERRNO (Buffer_Append (&compiled_scriptline, (current_scriptcmd_params.argv0 != NULL ? current_scriptcmd_params.argv0 : line_argv.args[0]), strlen (current_scriptcmd_params.argv0 != NULL ? current_scriptcmd_params.argv0 : line_argv.args[0]) + 1)); // argv[0]
+                     ASSERT_WITH_ERRNO (Buffer_Append (&compiled_scriptline, current_scriptcmd_params.argv0, strlen (current_scriptcmd_params.argv0) + 1)); // argv[0] -- explicit value from attribute
+                  else
+                  {
+                     filename_bit = strrchr (line_argv.args[0], '/'); // argv[0] has an implicit value: look where the filename starts
+                     filename_bit = (filename_bit != NULL ? filename_bit + 1 : line_argv.args[0]);
+                     ASSERT_WITH_ERRNO (Buffer_Append (&compiled_scriptline, filename_bit, strlen (filename_bit) + 1)); // argv[0] -- store just the filename
+                  }
                   for (array_index = 1; array_index < line_argv.count; array_index++)
                      ASSERT_WITH_ERRNO (Buffer_Append (&compiled_scriptline, line_argv.args[array_index], strlen (line_argv.args[array_index]) + 1)); // argv[n]
                   for (array_index = 0; array_index < global_envp.count; array_index++)
                      ASSERT_WITH_ERRNO (Buffer_Append (&compiled_scriptline, global_envp.args[array_index], strlen (global_envp.args[array_index]) + 1)); // envp[n]
+               }
          if (!Buffer_ReadFromFile (&entry_parms->data, resolved_pathname))
             DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d can't be read from \"%s\": %s", buildhost_pathname, buildfile_pathname, lineno, resolved_pathname, strerror (errno));
          stat (resolved_pathname, &stat_buf); // can't fail, since we could read it
          if (entry_parms->mtime == UINT32_MAX)
             entry_parms->mtime = (uint32_t) stat_buf.st_mtime;
+         if ((entry_parms->data.size > 52) && (memcmp (entry_parms->data.bytes, ELF_MAGIC_STR, 4) == 0))
+            entry_parms->st_mode |= 0111; // add +x permissions to ELF entries (undocumented mkifs behaviour)
          LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->data.size);
+      }
       else
          DIE_WITH_EXITCODE (1, "unexpected code path: can't store a file without neither explicit contents nor a host pathname. This is a bug in the program. Please contact the author.");
+                  {
                      canonical_dylib_name = dynamic_strings + ELF_GET_NUMERIC (ELFHDR, dynamic_entry, value);
                      break;
+                  }
+               // do we have the canonical dylib name AND does it differ from the name under which we'll be storing this dylib ?
-               // do we have it ?
+               filename_bit = strrchr (stored_pathname, '/');
-               if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0))
+               if (filename_bit != NULL)
+               {
+                  filename_bit++;
+                  pathbit_len = filename_bit - stored_pathname;
+               }
+               else
+               {
+                  filename_bit = stored_pathname;
+                  pathbit_len = 0;
+               }
-                  sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), canonical_dylib_name);
+               if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0) && (strcmp (canonical_dylib_name, filename_bit) != 0))
+               {
-                  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
+                  if (pathbit_len > 0)
+                  {
-                     original_stored_pathname = stored_pathname; // if so, remember to create a symlink here
+                     strncpy_s (candidate_pathname, MAXPATHLEN, stored_pathname, pathbit_len);
-                     stored_pathname = candidate_pathname;
+                     strcpy_s (&candidate_pathname[pathbit_len], MAXPATHLEN - pathbit_len, canonical_dylib_name);
+                  }
+                  else
+                     strcpy_s (candidate_pathname, MAXPATHLEN, canonical_dylib_name);
+                  stored_pathname = candidate_pathname;
+               }
+            }
          } // end if the file we're storing is a dylib
          // now strip this ELF file if necessary
+   }
    // is there already an entry for this item ?
    if (fsentry_index < *fsentry_count)
+   {
-      // if we should NOT ignore duplicates, bomb out, else just reuse that entry
+      // if we should NOT ignore duplicates, bomb out (except for the root entry which is implicitly defined), else just return
+      if (strcmp (stored_pathname, "/") == 0)
+         return; // the root entry is implicitly defined: do not warn about it
-      if (!entry_parms->should_ignore_duplicates)
+      else if (entry_parms->should_ignore_duplicates)
+         LOG_WARNING ("duplicate detected: entry \"%s\" specified in \"%s\" line %d already exists in build file (already defined line %d)", stored_pathname, buildfile_pathname, lineno, (*fsentries)[fsentry_index].UNSAVED_lineno);
+      else
-         DIE_WITH_EXITCODE (1, "duplicate detected: entry \"%s\" specified in \"%s\" line %d already exists in IFS file", stored_pathname, buildfile_pathname, lineno);
+         DIE_WITH_EXITCODE (1, "duplicate detected: entry \"%s\" specified in \"%s\" line %d already exists in build file (already defined line %d)", stored_pathname, buildfile_pathname, lineno, (*fsentries)[fsentry_index].UNSAVED_lineno);
+   }
    else // this is a new entry: grow filesystem entries array to hold one more slot
+   {
       reallocated_ptr = realloc (*fsentries, (*fsentry_count + 1) * sizeof (fsentry_t)); // attempt to reallocate
       ASSERT_WITH_ERRNO (reallocated_ptr); // verify
    else if (S_ISREG (entry_parms->st_mode))
+   {
       fsentry->u.file.offset = WILL_BE_FILLED_LATER; // will be filled later in main() when the file's data blob will be written to the output file
       fsentry->u.file.size = (uint32_t) entry_parms->data.size;
       fsentry->u.file.path = strdup (stored_pathname_without_leading_slash);
-      fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->data.size);
-      ASSERT_WITH_ERRNO (fsentry->u.file.UNSAVED_databuf);
-      memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data.bytes, entry_parms->data.size);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.file.path) + 1, image_align); // now we can set the size
+      fsentry->UNSAVED_databuf = malloc (entry_parms->data.size);
+      ASSERT_WITH_ERRNO (fsentry->UNSAVED_databuf);
+      memcpy (fsentry->UNSAVED_databuf, entry_parms->data.bytes, entry_parms->data.size);
       fsentry->UNSAVED_was_data_written = false; // there *IS* data to save
+   }
    else if (S_ISLNK (entry_parms->st_mode))
+   {
       fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname_without_leading_slash) + 1);
       fsentry->u.device.path = strdup (stored_pathname_without_leading_slash);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.device.path), image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = true; // no data to save
+   }
+   fsentry->UNSAVED_lineno = lineno; // save the line number at which this entry was defined, for error reporting
    // should we also add a symlink to this entry ? (in case we stored a dylib file under its canonical name)
    if (original_stored_pathname != NULL)
+   {
+      old_data = entry_parms->data.bytes; // backup previous data pointer
       entry_parms->is_compiled_bootscript = false;
       entry_parms->should_autosymlink_dylib = false;
       entry_parms->should_follow_symlinks = false;
       entry_parms->st_mode = S_IFLNK | 0777; // NOTE: mkifs stores symlink permissions as rwxrwxrwx !
       entry_parms->extra_ino_flags = (fsentry->header.ino & (IFS_INO_PROCESSED_ELF | IFS_INO_RUNONCE_ELF | IFS_INO_BOOTSTRAP_EXE)); // preserve target's inode flags
-      last_dirsep = strrchr (stored_pathname, '/');
-      old_data = entry_parms->data.bytes; // backup previous data pointer
-      entry_parms->data.bytes = (uint8_t *) (last_dirsep == NULL ? stored_pathname : last_dirsep + 1); // store symlink target in dirent data
+      entry_parms->data.bytes = (uint8_t *) ((last_dirsep = strrchr (stored_pathname, '/')) == NULL ? stored_pathname : last_dirsep + 1); // store symlink target in dirent data
       entry_parms->data.size = strlen (entry_parms->data.bytes);
       add_fsentry (fsentries, fsentry_count, entry_parms, original_stored_pathname, NULL);
       entry_parms->data.bytes = old_data; // restore previous data pointer so that it can be freed normally
+   }
+#if 0 // DISABLED: not the right place to do that (causes duplicates)
+   // WEIRD HACK: if we stored a dylib under the form "xxxxx.so.yyyy", then add a symlink as "xxxxx.so". This is to replicate a weird (undocumented?) behaviour of mkifs.
+   if ((canonical_dylib_name != NULL) && ((token = strstr (stored_pathname, ".so.")) != NULL))
+   {
+      old_data = entry_parms->data.bytes; // backup previous data pointer
+      entry_parms->is_compiled_bootscript = false;
+      entry_parms->should_autosymlink_dylib = false;
+      entry_parms->should_follow_symlinks = false;
+      entry_parms->st_mode = S_IFLNK | 0777; // NOTE: mkifs stores symlink permissions as rwxrwxrwx !
+      entry_parms->extra_ino_flags = (fsentry->header.ino & (IFS_INO_PROCESSED_ELF | IFS_INO_RUNONCE_ELF | IFS_INO_BOOTSTRAP_EXE)); // preserve target's inode flags
+      entry_parms->data.bytes = (uint8_t *) ((last_dirsep = strrchr (stored_pathname, '/')) == NULL ? stored_pathname : last_dirsep + 1); // store symlink target in dirent data
+      entry_parms->data.size = strlen (entry_parms->data.bytes);
+      token[3] = 0;
+      add_fsentry (fsentries, fsentry_count, entry_parms, stored_pathname, NULL);
+      token[3] = '.';
+      entry_parms->data.bytes = old_data; // restore previous data pointer so that it can be freed normally
+   }
+#endif
    return; // finished, return to our caller
+}
+}
 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 specified_pathname[MAXPATHLEN] = ""; // exactly as specified in the build file
    thread_local static char path_on_buildhost[MAXPATHLEN] = "";
    thread_local static char path_in_ifs[MAXPATHLEN] = "";
    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;
    struct stat stat_buf;
    struct tm utc_time;
    void *reallocated_ptr;
    size_t allocated_size;
    size_t string_len;
-   char *specifiedpathname_start;
    char *attrblock_start;
+   char *pathname_start;
    char *write_ptr;
    char *line_ptr;
    char *value;
    char *token;
    char *sep;
    if ((*line_ptr == 0) || (*line_ptr == '#'))
       return; // don't process empty lines and comments
    string_len = (int) strlen (line_buffer);
-   if ((string_len > 0) && (line_buffer[string_len - 1] == '\n'))
+   while ((string_len > 0) && ((line_buffer[string_len - 1] == '\r') || (line_buffer[string_len - 1] == '\n')))
-      line_buffer[string_len - 1] = 0; // chop off newline for easier debug output
+      line_buffer[--string_len] = 0; // chop off carriage returns and newlines for easier debug output
    // reset entry values
    memcpy (&entry_parms, default_parms, sizeof (parms_t));
    path_in_ifs[0] = 0;
    path_on_buildhost[0] = 0;
+   specified_pathname[0] = 0;
    should_discard_inline_contents = false;
    // does this line start with an attribute block ?
    if (*line_ptr == '[')
+   {
+      {
          // 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, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.uid     = (int) read_integer (value, 10); }
-         else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.gid     = (int) read_integer (value); }
+         else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms.gid     = (int) read_integer (value, 10); }
-         else if (strncmp (token, "dperms=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms.dperms  = (int) read_integer (value); }
+         else if (strncmp (token, "dperms=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms.dperms  = (int) read_integer (value, 8); }
-         else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms.perms   = (int) read_integer (value); }
+         else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms.perms   = (int) read_integer (value, 8); }
          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
+            image_base = (uint32_t) read_integer (value, 0); // 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_end       = (uint32_t) read_integer (sep + 1, 0); // 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_maxsize   = (uint32_t) read_integer (sep + 1, 0); // 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_totalsize = (uint32_t) read_integer (sep + 1, 0); // 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
+            if ((sep = strchr (value, '%')) != NULL) image_align     = (uint32_t) read_integer (sep + 1, 0); // 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)) // FIXME: HACK until I figure out how to re-create them
-               DIE_WITH_EXITCODE (1, "creating bootable images require the --bootfile and --startupfile 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;
                if (strcmp (value, "x86_64") == 0)
+               {
+               }
                else
                   DIE_WITH_EXITCODE (1, "unrecognized processor type in 'virtual' attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, value);
                value = sep + 1;
+            }
+            boot_type = (strstr (value, "uefi") != NULL ? BOOTTYPE_UEFI : BOOTTYPE_BIOS); // FIXME: this should be a boot FILE, not a hardcoded tag
+            if (boot_type == BOOTTYPE_UEFI)
+            {
+               if (startupfile_pathname == NULL) // FIXME: HACK until I figure out how to re-create it
+                  DIE_WITH_EXITCODE (1, "creating bootable UEFI images requires the --startupfile command-line option in \"%s\" line %d", buildfile_pathname, lineno);
+               bootfile_size = ROUND_TO_UPPER_MULTIPLE (sizeof (uefi64_header_t), 512); // round to upper filesystem block (PE header constraint)
+               LOG_INFO ("processor \"%s\" bootfile <generated, UEFI>\n", image_processor);
+            }
+            else
+            {
+               if ((bootfile_pathname == NULL) || (startupfile_pathname == NULL)) // FIXME: HACK until I figure out how to re-create them
+                  DIE_WITH_EXITCODE (1, "creating bootable BIOS images requires the --bootfile and --startupfile command-line options in \"%s\" line %d", buildfile_pathname, lineno);
-            if (stat (bootfile_pathname, &stat_buf) != 0)
+               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));
+                  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
+               bootfile_size = stat_buf.st_size; // save preboot file size
-            LOG_INFO ("processor \"%s\" bootfile \"%s\"\n", image_processor, bootfile_pathname);
+               LOG_INFO ("processor \"%s\" bootfile \"%s\"\n", image_processor, bootfile_pathname);
+            }
             entry_parms.is_bootstrap_file = true;
+         }
          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));
+      }
       // 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
-   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 == '/')
+   write_ptr = specified_pathname;
-   {
-      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++;
    // 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 ?
+   if (*line_ptr == '=')
+   {
       line_ptr++; // skip the equal sign
       while ((*line_ptr != 0) && isspace (*line_ptr))
          line_ptr++; // skip optional spaces after the equal sign
+      {
          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 ?
+      // 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
          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 == '\r')
+               continue; // just ignore carriage returns (Microsoft end of line format)
             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
       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
+         pathname_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 == '\\')
+            {
          *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
+            ASSERT_WITH_ERRNO (Buffer_InitWithCString (&entry_parms.data, pathname_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
+            strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), pathname_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
+      {
          LOG_WARNING ("syntax error in \"%s\" line %d: missing equal sign and symlink target (skipping)", buildfile_pathname, lineno);
          return; // invalid symlink specification, skip line
+      }
+      // UNLESS we know we are storing (=creating empty) a directory, the path on the build host is the one specified
+      if (S_ISDIR (entry_parms.st_mode))
+         path_on_buildhost[0] = 0; // we're storing a new empty directory: path on build host is nil
+      else
-      strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specifiedpathname_start); // the path on the build host is the one specified
+         strcpy_s (path_on_buildhost, sizeof (path_on_buildhost), specified_pathname); // the path on the build host is the one specified
+      if ((specified_pathname[0] != '/') && ((token = strrchr (specified_pathname, '/')) != NULL))
+         memmove (specified_pathname, token + 1, strlen (token + 1) + 1); // unless it's absolute, the path in the IFS is the BASENAME of the path specified
+   }
+   // was the specified path in the build file absolute or relative ?
-      sep = strrchr (specifiedpathname_start, '/');
+   if (specified_pathname[0] == '/')
+      strcpy_s (path_in_ifs, sizeof (path_in_ifs), specified_pathname); // path is absolute, use it verbatim
-      if (sep != NULL)
+   else // path is relative
+   {
+      string_len = sprintf_s (path_in_ifs, sizeof (path_in_ifs), "%s", (entry_parms.prefix != NULL ? entry_parms.prefix : "")); // use path prefix
+      while ((string_len > 0) && (path_in_ifs[string_len - 1] == '/'))
+         string_len--; // chop off any trailing slashes from prefix
+      path_in_ifs[string_len++] = '/'; // add ONE trailing slash
-         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)
+      strcpy_s (&path_in_ifs[string_len], sizeof (path_in_ifs) - string_len, specified_pathname); // construct an absolute path with the IFS prefix
+   }
    // now add this entry to the image filesystem
    if (S_ISDIR (entry_parms.st_mode))
-      entry_parms.st_mode |= entry_parms.dperms;
+      entry_parms.st_mode |= entry_parms.dperms; // directory
    else if (S_ISLNK (entry_parms.st_mode))
-      entry_parms.st_mode |= 0777; // NOTE: mkifs sets symlink permissions to rwxrwxrwx !?
+      entry_parms.st_mode |= 0777; // symlink (NOTE: mkifs sets symlink permissions to rwxrwxrwx !?)
-   else // file or device node
+   else if (S_ISREG (entry_parms.st_mode))
-      entry_parms.st_mode |= entry_parms.perms;
+      entry_parms.st_mode |= entry_parms.perms; // file
+   else
+      entry_parms.st_mode |= entry_parms.perms; // device node
    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
       .should_follow_symlinks = true, // [+|-followlink]
       .should_autosymlink_dylib = true, // [+|-autolink]
    };
    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)
+   uefi64_header_t *uefi_header = NULL;
    char path_on_buildhost[MAXPATHLEN] = "";
    char path_in_ifs[MAXPATHLEN] = "";
    const char *ifs_pathname = NULL;
    const char *rootdir_pathname = NULL;
    const fsentry_t *fsentry;
    void *reallocated_ptr;
    buffer_t compressed_imagefs;
+   buffer_t opaqueblob_file;
    uint8_t *compressor_out;
    uint8_t *compressor_in;
    size_t compressor_outlen;
    size_t compressor_inlen;
    size_t reallocated_size;
          sep = strchr (argv[++arg_index], '@');
          if ((sep == NULL) || (sep[1] == 0))
             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);
+         startupfile_ep_from_imagebase = (size_t) read_integer (sep + 1, 0);
+      }
-      else if ((strcmp (argv[arg_index], "--kerneloffs") == 0) && (arg_index + 1 < argc)) // --kerneloffs 0x32000 (undocumented)
-         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)
    // do we have a startup file ? if so, this is a bootable image
    if (startupfile_pathname != NULL)
+   {
       // write boot prefix
+      if (boot_type == BOOTTYPE_UEFI) // UEFI boot
+      {
+         ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, sizeof (uefi64_header_t))); // start by writing an empty UEFI header
+         uefi_header = (uefi64_header_t *) ifs.data.bytes; // have a convenience pointer
+         memcpy (&uefi_header->dos_header.signature, "MZ", 2); // store the MZ magic
+         uefi_header->dos_header.bytes_in_last_page = 144; // fixed value
+         uefi_header->dos_header.number_of_pages = 3; // fixed value
+         uefi_header->dos_header.header_size_in_paragraphs = sizeof (uefi_header->dos_header) / 16;
+         uefi_header->dos_header.requested_paragraphs = 0xffff;
+         uefi_header->dos_header.initial_stack_pointer_value = 0x00b8; // fixed value
+         uefi_header->dos_header.absolute_offset_to_relocation_table = sizeof (uefi_header->dos_header);
+         uefi_header->dos_header.absolute_offset_to_pe_header = sizeof (uefi_header->dos_header) + sizeof (uefi_header->dos_stub_bytes);
+         memcpy (uefi_header->dos_stub_bytes, "\x0E\x1F\xBA\x0E\x00\xB4\x09\xCD\x21\xB8\x01\x4C\xCD\x21" "This program cannot be run in DOS mode.\r\r\n" "\x24\x00\x00\x00\x00\x00\x00\x00", 64); // store DOS stub program
+         memcpy (&uefi_header->pe_header.signature, "PE\0\0", 4); // store the PE magic
+         uefi_header->pe_header.machine_type = (strcmp (image_processor, "x86_64") == 0 ? 0x8664 : (strcmp (image_processor, "aarch64le") == 0 ? 0xaa64 : 0xffff)); // store machine type
+         uefi_header->pe_header.number_of_sections = 1; // store number of sections
+         uefi_header->pe_header.epoch_timestamp = (uint32_t) time (NULL); // store timestamp (NOTE: mkifs doesn't obey its -nn arguments here, so neither shall we)
+         uefi_header->pe_header.size_of_optional_header = sizeof (uefi_header->optional_header64); // 240 bytes
+         uefi_header->pe_header.characteristics_bitmap = 0x0223; // store characteristics bitmap (executable, uses large addresses, relocs stripped, debug info stripped)
+         memcpy (uefi_header->optional_header64.signature, "\x0b\x02", 2); // store the 64-bit optional header magic
+         uefi_header->optional_header64.code_size = WILL_BE_FILLED_LATER; // total size of IFS minus 512 bytes for the UEFI boot header, i.e. size of startup blob plus size of image
+         uefi_header->optional_header64.entrypoint_address = (uint32_t) startupfile_ep_from_imagebase;
+         uefi_header->optional_header64.image_base = image_base;
+         uefi_header->optional_header64.section_alignment = (uint32_t) image_pagesize;
+         uefi_header->optional_header64.file_alignment = 512; // i.e. one filesystem block
+         uefi_header->optional_header64.image_size = WILL_BE_FILLED_LATER; // total IFS file size
+         uefi_header->optional_header64.size_of_headers = (uint32_t) bootfile_size;
+         uefi_header->optional_header64.subsystem_type = 10; // IMAGE_SUBSYSTEM_EFI_APPLICATION
+         uefi_header->optional_header64.stack_reserve_size = image_pagesize;
+         uefi_header->optional_header64.stack_commit_size = image_pagesize;
+         uefi_header->optional_header64.number_of_data_directories = 16; // mkifs reserves 16 data directories, filled with zeroes (FIXME: why?)
+         memcpy (uefi_header->unique_section.section_name, "image\0\0\0", 8); // store the unique section name
+         uefi_header->unique_section.virtual_size = WILL_BE_FILLED_LATER; // same as pe_image_optional_header64.code_size
+         uefi_header->unique_section.virtual_address = ROUND_TO_UPPER_MULTIPLE (uefi_header->optional_header64.size_of_headers, uefi_header->optional_header64.file_alignment);
+         uefi_header->unique_section.rawdata_size = WILL_BE_FILLED_LATER; // same as pe_image_optional_header64.code_size
+         uefi_header->unique_section.rawdata_offset = uefi_header->unique_section.virtual_address;
+         uefi_header->unique_section.characteristics_bitmap = 0x60; // image contains code + image contains initialized data
+         ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, uefi_header->optional_header64.size_of_headers)); // pad as necessary
+      }
+      else // BIOS boot
+      {
-      // ######################################################################################################################################################################################################################################
+         // ######################################################################################################################################################################################################################################
-      // # FIXME: figure out how to re-create it
+         // # FIXME: figure out how mkifs produces the boot prefix out of the BIOS "boot file" here
-      // ######################################################################################################################################################################################################################################
+         // ######################################################################################################################################################################################################################################
-      buffer_t file;
-      if (!Buffer_ReadFromFile (&file, bootfile_pathname))
+         if (!Buffer_ReadFromFile (&opaqueblob_file, bootfile_pathname))
-         DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", bootfile_pathname, strerror (errno));
+            DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", bootfile_pathname, strerror (errno));
-      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &file)); // write boot blob
+         ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &opaqueblob_file)); // write boot blob
-      Buffer_Forget (&file);
+         Buffer_Forget (&opaqueblob_file);
-      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
+         ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
+      }
       ifs.offsets.startupheader = ifs.data.size; // save startup header offset for future use
       memset (&startup_header, 0, sizeof (startup_header)); // prepare startup header
       memcpy (startup_header.signature, "\xeb\x7e\xff\x00", 4); // startup header signature, i.e. 0xff7eeb
       startup_header.version       = 1;
       // then: parse resulting ELF file, take all program segments and concatenate them --> this is the blob (FIXME: wrong?)
       // ######################################################################################################################################################################################################################################
 #if 0 // nonworking
       // <deleted>
 #else // working
-      if (!Buffer_ReadFromFile (&file, startupfile_pathname))
+      if (!Buffer_ReadFromFile (&opaqueblob_file, startupfile_pathname))
          DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", startupfile_pathname, strerror (errno));
-      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &file)); // write startup blob
+      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &opaqueblob_file)); // write startup blob
-      Buffer_Forget (&file);
+      Buffer_Forget (&opaqueblob_file);
 #endif // working
       ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
       ifs.offsets.startuptrailer = ifs.data.size; // save startup trailer offset for future use
       ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &startup_trailer, sizeof (startup_trailer))); // write startup trailer
    // then write all the other files by increasing inode number: ELF files first
    for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
+   {
       if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written // filter out anything that's not a file, and anything that's been already written
-          || (fsentries[fsentry_index].u.file.size < 4) || (memcmp (fsentries[fsentry_index].u.file.UNSAVED_databuf, ELF_MAGIC_STR, 4) != 0)) // filter out anything that's not an ELF file
+          || (fsentries[fsentry_index].u.file.size < 4) || (memcmp (fsentries[fsentry_index].UNSAVED_databuf, ELF_MAGIC_STR, 4) != 0)) // filter out anything that's not an ELF file
          continue; // skip all entries that don't have a separate data block and those who were written already
       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
+   }
+   }
    // do we have a startup file ? if so, this is a bootable image
    if (startupfile_pathname != NULL)
+   {
+      if (boot_type == BOOTTYPE_UEFI) // UEFI boot: fix the final offsets and sizes in the EFI executable's PE header
+      {
+         uefi_header = (uefi64_header_t *) ifs.data.bytes; // have a convenience pointer
+         uefi_header->optional_header64.code_size = (uint32_t) (ifs.data.size - ifs.offsets.startupheader); // total size of IFS minus 512 bytes for the UEFI boot header, i.e. size of startup blob plus size of image
+         uefi_header->optional_header64.image_size = (uint32_t) ifs.data.size; // total IFS file size
+         uefi_header->unique_section.virtual_size = uefi_header->optional_header64.code_size; // same as pe_image_optional_header64.code_size
+         uefi_header->unique_section.rawdata_size = uefi_header->optional_header64.code_size; // same as pe_image_optional_header64.code_size
+      }
       // compute SHA-512 checksum and V1 checksum of startup block
       if (   ( (startup_header.flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
           || (!(startup_header.flags1 & STARTUP_HDR_FLAGS1_BIGENDIAN) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__   )))
          is_foreign_endianness = true; // if the header is big endian and we're on a little endian machine, or the other way around, it's a foreign endianness
       else
          free (fsentry->u.symlink.contents);
+      }
       else if (S_ISREG (fsentry->header.mode))
+      {
          free (fsentry->u.file.path);
-         free (fsentry->u.file.UNSAVED_databuf);
+         free (fsentry->UNSAVED_databuf);
+      }
       else if (S_ISFIFO (fsentry->header.mode))
          free (fsentry->u.device.path);
+   }

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/ifstool.c – Rev 33 → 34