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

 int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer
 // prototypes of local functions
 static long long read_integer (const char *str); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)
+static char *resolve_envvars (const char *str); // resolves environment variables in str and replaces them with their value, or an empty string if undefined. Returns a mallocated string (caller frees)
 static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar); // locates pathname among the known search paths and returns a pointer to the resolved pathname (static string)
 static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file
 static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs_data, const size_t write_offset, const fsentry_t *fsentry); // writes the given filesystem entry (without its contents) to the IFS buffer
 static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, const fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer
 static int Buffer_StripELFFile (buffer_t *file, const char **saved_sections, const size_t saved_section_count, const bool should_align_segsize_with_ramsize, const char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded
       else if ((*endptr == 'm') || (*endptr == 'M')) ret *= (size_t) 1024 * 1024;
       else if ((*endptr == 'g') || (*endptr == 'G')) ret *= (size_t) 1024 * 1024 * 1024;
       else if ((*endptr == 't') || (*endptr == 'T')) ret *= (size_t) 1024 * 1024 * 1024 * 1024; // future-proof enough, I suppose?
+   }
    return (ret);
+}
+static char *resolve_envvars (const char *str)
+{
+   // resolves environment variables in str and replaces them with their value, or an empty string if undefined
+   // returns a mallocated string (caller frees), or dies with errno
+   signed int erase_index;
+   void *reallocated_ptr;
+   size_t replacement_len;
+   size_t middlebit_len;
+   size_t old_str_len;
+   size_t new_str_len;
+   size_t endbit_len;
+   char erased_char;
+   char *resolved_str;
+   char *replacement;
+   char *varname;
+   char *endbit;
+   char *token;
+   resolved_str = strdup (str); // have a working copy of the input string
+   ASSERT_WITH_ERRNO (resolved_str);
+   while ((((token = strstr (resolved_str, "${")) != NULL) && ((endbit = strchr (token, '}')) != NULL)) // look for variables in the "${VARNAME}" format *AND* in "$VARNAME" format
+          || (((token = strstr (resolved_str, "$")) != NULL) && ((middlebit_len = strspn (token, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")) != strlen (token))))
+   {
+      if (token[1] == '{') // "${VARNAME}" format
+      {
+         endbit++; // locate where the end bit begins
+         varname = token + 2; // skip the leading two characters: "${"
+         erase_index = -1; // we shall split the string at the character that's *just before* where the end bit starts
+      }
+      else // "$VARNAME" format
+      {
+         endbit = &token[middlebit_len]; // locate where the end bit begins
+         varname = token + 1; // skip the leading '$'
+         erase_index = 0; // we shall split the string at the character that's *right where* the end bit starts
+      }
+      old_str_len = strlen (resolved_str); // measure current string length
+      endbit_len = strlen (endbit); // measure the length of the end bit (skip the closing curly brace)
+      erased_char = endbit[erase_index]; // remember which is the character we're going to erase
+      endbit[erase_index] = 0; // split the string at the end of the variable name
+      if (strcmp (varname, "PFS") == 0)
+         replacement = PATH_SEP; // special case: if it's the PFS variable, select ":" or ";" based on the host platform
+      else
+         replacement = getenv (varname); // peek at the environment for its value
+      if (replacement == NULL)
+         replacement = ""; // if this variable isn't defined, fallback to an empty string, just like what a UNIX shell does
+      endbit[erase_index] = erased_char; // put the erased character back
+      replacement_len = strlen (replacement); // measure replacement length
+      new_str_len = (size_t) token - (size_t) resolved_str + replacement_len + endbit_len; // measure updated string len
+      if (new_str_len > old_str_len)
+      {
+         reallocated_ptr = realloc (resolved_str, new_str_len + 1); // grow it if necessary
+         ASSERT_WITH_ERRNO (reallocated_ptr);
+         token = &((char *) reallocated_ptr)[token - resolved_str]; // fix the pointers that may have moved
+         endbit = &((char *) reallocated_ptr)[endbit - resolved_str]; // fix the pointers that may have moved
+         resolved_str = reallocated_ptr;
+      }
+      memmove (token + replacement_len, endbit, endbit_len + 1); // move the end bit to its final location (including its nul terminator)
+      memcpy (token, replacement, replacement_len); // and patch the replacement in between
+   }
+   return (resolved_str); // finished, return the mallocated resolved string (caller frees)
+}
 static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar)
+{
       { false, "/lib/dll"  }, // prefix with $PROCESSOR/
       { false, "/usr/lib"  }  // prefix with $PROCESSOR/
    };
    static thread_local char *resolved_pathname = NULL;
-   void *reallocated_ptr;
+   char *pathname_without_envvars;
    char *resolved_search_path;
-   char *replacement;
-   size_t old_searchpath_len;
-   size_t new_searchpath_len;
-   size_t replacement_len;
-   size_t middlebit_len;
-   size_t endbit_len;
    size_t defaultpath_index;
    struct stat stat_buf;
-   int erase_index;
-   char erased_char;
-   char *varname;
    char *nextsep;
-   char *endbit;
    char *token;
-   // initial allocation (per thread)
-   if (resolved_pathname == NULL)
-   {
-      resolved_pathname = malloc (MAXPATHLEN);
+   // resolve possible environment variables in pathname
-      ASSERT_WITH_ERRNO (resolved_pathname);
+   pathname_without_envvars = resolve_envvars (pathname);
-   }
-   // is it an absolute pathname (POSIX and Windows variants) ?
+   // is it an absolute pathname (POSIX and Windows variants) OR a relative pathname ?
    if (IS_DIRSEP (pathname[0])
 #ifdef _WIN32
        || (isalpha (pathname[0]) && (pathname[1] == ':') && IS_DIRSEP (pathname[2]))
+       || (strchr (pathname, '\\') != NULL)
 #endif // _WIN32
+       || (strchr (pathname, '/') != NULL)
+       )
-      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)
+      return (pathname_without_envvars); // 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
+   else // what we've been given is just a basename, so search it among the search paths we have
+   {
       // QNX docs:
-      // When searching for host files to be included in the image, search
+      // 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.
-      // 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
+      // You can define multiple -r options; each adds a set of paths to search for files.
-      // search for files. The -r options are evaluated from left to right
-      // meaning the paths prefixed with the first (leftmost) rootdir are
+      // 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.
-      // searched first, then those prefixed with the second rootdir, and
-      // so on.
-      // Normally, mkifs searches any paths defined in $MKIFS_PATH when
+      // Normally, mkifs searches any paths defined in $MKIFS_PATH when it was called and then the default paths within $QNX_TARGET.
-      // it was called and then the default paths within $QNX_TARGET. The
-      // default paths are based on the CPU architecture specified by
+      // The default paths are based on the CPU architecture specified by $PROCESSOR and $PROCESSOR_BASE.
-      // $PROCESSOR and $PROCESSOR_BASE. If you specify -r options, mkifs
-      // searches the default paths prefixed with each dir variable before
+      // If you specify -r options, mkifs searches the default paths prefixed with each dir variable before searching those within $QNX_TARGET.
-      // searching those within $QNX_TARGET. These paths are:
+      // 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
+      // 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.
-      // root dir itself may be any path you choose. For example, if you
-      // wanted to include /scratch/aarch64le/sbin/devb-sata, you would
+      // For example, if you wanted to include /scratch/aarch64le/sbin/devb-sata, you would specify a -r option like this:
-      // specify a -r option like this:
       //   -r /scratch
       // Note that you don't include $PROCESSOR or $PROCESSOR_BASE in dir.
       //  - search all paths in explicit path/[default paths] (if explicit path supplied)
       //  - search all paths in (-r flags if have some|MKIFS_PATH)/[default paths] (if no explicit path supplied)
       //  - search all paths in $QNX_TARGET/[default paths]
+      // initial allocation (per thread)
+      if (resolved_pathname == NULL)
+      {
+         resolved_pathname = malloc (MAXPATHLEN);
+         ASSERT_WITH_ERRNO (resolved_pathname);
+      }
       // if no file-specific explicit search path was supplied, use the path list supplied by the -r command-line arguments, else fallback to MKIFS_PATH if we don't have any
       if (search_paths_or_NULL_for_MKIFS_PATH_envvar == NULL)
          search_paths_or_NULL_for_MKIFS_PATH_envvar = (SEARCH_PATH != NULL ? SEARCH_PATH : getenv ("MKIFS_PATH"));
       // construct a potential final path using each element of the search path
       if (search_paths_or_NULL_for_MKIFS_PATH_envvar != NULL)
+      {
          // the first step is to resolve all environment variables in the search path
-         resolved_search_path = strdup (search_paths_or_NULL_for_MKIFS_PATH_envvar);
+         resolved_search_path = resolve_envvars (search_paths_or_NULL_for_MKIFS_PATH_envvar);
-         ASSERT_WITH_ERRNO (resolved_search_path);
-         while ((((token = strstr (resolved_search_path, "${")) != NULL) && ((endbit = strchr (token, '}')) != NULL)) // look for variables in the "${VARNAME}" format *AND* in "$VARNAME" format
-                || (((token = strstr (resolved_search_path, "$")) != NULL) && ((middlebit_len = strspn (token, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")) != strlen (token))))
-         {
-            if (token[1] == '{') // "${VARNAME}" format
-            {
-               endbit++; // locate where the end bit begins
-               varname = token + 2; // skip the leading two characters: "${"
-               erase_index = -1; // we shall split the string at the character that's *just before* where the end bit starts
-            }
-            else // "$VARNAME" format
-            {
-               endbit = &token[middlebit_len]; // locate where the end bit begins
-               varname = token + 1; // skip the leading '$'
-               erase_index = 0; // we shall split the string at the character that's *right where* the end bit starts
-            }
-            old_searchpath_len = strlen (resolved_search_path); // measure current string length
-            endbit_len = strlen (endbit); // measure the length of the end bit (skip the closing curly brace)
-            erased_char = endbit[erase_index]; // remember which is the character we're going to erase
-            endbit[erase_index] = 0; // split the string at the end of the variable name
-            replacement = getenv (varname); // peek at the environment for its value
-            if (replacement == NULL)
-               replacement = ""; // if this variable isn't defined, fallback to an empty string, just like what a UNIX shell does
-            endbit[erase_index] = erased_char; // put the erased character back
-            replacement_len = strlen (replacement); // measure replacement length
-            new_searchpath_len = (size_t) token - (size_t) resolved_search_path + replacement_len + endbit_len; // measure updated search path len
-            if (new_searchpath_len > old_searchpath_len)
-            {
-               reallocated_ptr = realloc (resolved_search_path, new_searchpath_len + 1); // grow it if necessary
-               ASSERT_WITH_ERRNO (reallocated_ptr);
-               token = &((char *) reallocated_ptr)[token - resolved_search_path]; // fix the pointers that may have moved
-               endbit = &((char *) reallocated_ptr)[endbit - resolved_search_path]; // fix the pointers that may have moved
-               resolved_search_path = reallocated_ptr;
-            }
-            memmove (token + replacement_len, endbit, endbit_len + 1); // move the end bit to its final location (including its nul terminator)
-            memcpy (token, replacement, replacement_len); // and patch the replacement in between
-         }
          // now split this search path string into multiple tokens and process them one after the other
          token = (*resolved_search_path != 0 ? resolved_search_path : NULL);
          nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
          while (token != NULL)
+         {
             // look under this search path at each of the known subpaths
             for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)
+            {
-               sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s/%s/%s", (int) (nextsep - token), token, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname);
+               sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s/%s/%s", (int) (nextsep - token), token, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname_without_envvars);
                if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))
+               {
+                  free (pathname_without_envvars);
                   return (resolved_pathname); // if a file can indeed be found at this location, stop searching
+               }
+            }
             token = (*nextsep != 0 ? nextsep + 1 : NULL);
             nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
+         }
+      }
       // file not found in search paths: look under QNX_TARGET at each of the known subpaths
       for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)
+      {
-         sprintf_s (resolved_pathname, MAXPATHLEN, "%s/%s/%s/%s", QNX_TARGET, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname);
+         sprintf_s (resolved_pathname, MAXPATHLEN, "%s/%s/%s/%s", QNX_TARGET, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname_without_envvars);
          if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))
+         {
+            free (pathname_without_envvars);
             return (resolved_pathname); // if a file can indeed be found at this location, stop searching
+         }
+      }
+   }
+   free (pathname_without_envvars);
    errno = ENOENT; // we exhausted all possibilities
    return (NULL); // file not found, return with ENOENT
+}
    static thread_local stringarray_t aps_partnames = { NULL, 0 };
    static int inode_count = 0; // will be preincremented each time this function is called
    typedef struct scriptcmd_s
+   {
-      const char *argv0;
+      char *argv0;
       int cpu_number;
       bool is_external;
       int priority;
       int sched_policy;
       int aps_partindex;
       ASSERT_WITH_ERRNO (candidate_pathname);
+   }
    if (S_ISDIR (entry_parms->st_mode)) // are we storing a directory ?
+   {
-      if (buildhost_pathname != NULL) // was a source file pathname supplied ?
+      if ((buildhost_pathname != NULL) && (buildhost_pathname[0] != 0)) // was a source file pathname supplied ?
+      {
          memcpy (&default_parms, entry_parms, sizeof (parms_t)); // apply current entry parameters when including a directory recursively
          add_directory_contents_recursively (fsentries, fsentry_count, buildhost_pathname, strlen (buildhost_pathname), &default_parms); // if so, add this diretory contents recursively
+      }
       LOG_INFO ("directory: ino 0x%x uid %d gid %d mode 0%o path \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname);
                      LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %zd of inline document '%s'", default_scriptcmd_params.attr, current_scriptcmd_params.attr, buildfile_pathname, 1 + line_index, stored_pathname); \
                      default_scriptcmd_params.attr = current_scriptcmd_params.attr; \
                   } } while (0)
                #define APPLY_DEFAULT_ATTR_STR(attr,descr,fmt) do { if (((default_scriptcmd_params.attr == NULL) && (current_scriptcmd_params.attr != NULL)) || ((default_scriptcmd_params.attr != NULL) && (current_scriptcmd_params.attr == NULL)) || ((default_scriptcmd_params.attr != NULL) && (current_scriptcmd_params.attr != NULL) && (strcmp (current_scriptcmd_params.attr, default_scriptcmd_params.attr) != 0))) { \
                   LOG_INFO ("changing default " descr " from " fmt " to " fmt " by attribute at \"%s\" line %zd of inline document '%s'", (default_scriptcmd_params.attr != NULL ? default_scriptcmd_params.attr : "none"), current_scriptcmd_params.attr, buildfile_pathname, 1 + line_index, stored_pathname); \
+                     if (default_scriptcmd_params.attr != NULL) free (default_scriptcmd_params.attr); \
+                     default_scriptcmd_params.attr = strdup (current_scriptcmd_params.attr); \
+                     ASSERT_WITH_ERRNO (default_scriptcmd_params.attr != NULL); \
                      default_scriptcmd_params.attr = current_scriptcmd_params.attr; \
                   } } while (0)
                APPLY_DEFAULT_ATTR_STR (argv0,                          "executable name",                 "\"%s\"");
                APPLY_DEFAULT_ATTR_NUM (cpu_number,                     "CPU mask",                        "0%o");
                APPLY_DEFAULT_ATTR_NUM (is_external,                    "external command flag",           "0%o");
                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 (((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); \
+               if (default_parms->attr != NULL) free (default_parms->attr); \
-               default_parms->attr = entry_parms.attr; \
+               default_parms->attr = strdup (entry_parms.attr); \
+               ASSERT_WITH_ERRNO (default_parms->attr != NULL); \
             } } 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");
    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 == '"'))))
+   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 '\'
          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 == '"'))))
+         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 '\'
    parms_t default_parms = { // default parameters for a filesystem entry
       .dperms = 0755,
       .perms = 0644,
       .mtime = UINT32_MAX,
       .mtime_for_inline_files = UINT32_MAX,
-      .prefix = "/proc/boot",
+      .prefix = NULL, // will be initialized to a *mallocated* string: "/proc/boot"
       .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)
    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;
+   default_parms.prefix = strdup ("/proc/boot");
+   ASSERT_WITH_ERRNO (default_parms.prefix);
    // 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

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool/ifstool.c – Rev 22 → 24