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

    uint32_t mtime_for_inline_files; // same as above but only for files that don't exist on the build host (i.e. files with an explicit content blob)
    char *prefix; // [prefix=path] install path (e.g. "proc/boot")
    bool should_follow_symlinks; // follow symlinks
    bool should_autosymlink_dylib; // dynamic libraries should be written under their official SONAME and a named symlink be created pointing at them
    bool should_keep_ld_output; // whether to keep .sym files produced by ld calls, togglable by the [+keeplinked] attribute
+   bool should_ignore_duplicates; // [+|-dupignore] whether to ignore duplicates
+   bool should_allow_nonexistent_files; // [+|-optional] whether to continue processing on unexistent files
    bool is_compiled_bootscript; // entry has [+script] attribute
    int extra_ino_flags; // bitmap of extra inode flags (IFS_INO_xxx)
    char *search; // [search=path[:path]] binary search path (the default one will be constructed at startup)
    buffer_t data; // the resolved file's own data bytes
       { false, "/lib/dll"  }, // prefix with $PROCESSOR/
       { false, "/usr/lib"  }  // prefix with $PROCESSOR/
    };
    static thread_local char *resolved_pathname = NULL;
+   void *reallocated_ptr;
+   char *resolved_search_path;
+   char *replacement;
+   size_t old_searchpath_len;
+   size_t new_searchpath_len;
+   size_t replacement_len;
+   size_t middlebit_len;
+   size_t endbit_len;
    size_t defaultpath_index;
    struct stat stat_buf;
+   int erase_index;
+   char erased_char;
+   char *varname;
-   const char *nextsep;
+   char *nextsep;
+   char *endbit;
-   const char *token;
+   char *token;
    // initial allocation (per thread)
    if (resolved_pathname == NULL)
+   {
       resolved_pathname = malloc (MAXPATHLEN);
          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
-         token = (*search_paths_or_NULL_for_MKIFS_PATH_envvar != 0 ? search_paths_or_NULL_for_MKIFS_PATH_envvar : NULL);
+         resolved_search_path = strdup (search_paths_or_NULL_for_MKIFS_PATH_envvar);
+         ASSERT_WITH_ERRNO (resolved_search_path);
+         while ((((token = strstr (resolved_search_path, "${")) != NULL) && ((endbit = strchr (token, '}')) != NULL)) // look for variables in the "${VARNAME}" format *AND* in "$VARNAME" format
+                || (((token = strstr (resolved_search_path, "$")) != NULL) && ((middlebit_len = strspn (token, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")) != strlen (token))))
+         {
+            if (token[1] == '{') // "${VARNAME}" format
+            {
+               endbit++; // locate where the end bit begins
+               varname = token + 2; // skip the leading two characters: "${"
+               erase_index = -1; // we shall split the string at the character that's *just before* where the end bit starts
+            }
+            else // "$VARNAME" format
+            {
+               endbit = &token[middlebit_len]; // locate where the end bit begins
+               varname = token + 1; // skip the leading '$'
+               erase_index = 0; // we shall split the string at the character that's *right where* the end bit starts
+            }
+            old_searchpath_len = strlen (resolved_search_path); // measure current string length
+            endbit_len = strlen (endbit); // measure the length of the end bit (skip the closing curly brace)
+            erased_char = endbit[erase_index]; // remember which is the character we're going to erase
+            endbit[erase_index] = 0; // split the string at the end of the variable name
+            replacement = getenv (varname); // peek at the environment for its value
+            if (replacement == NULL)
+               replacement = ""; // if this variable isn't defined, fallback to an empty string, just like what a UNIX shell does
+            endbit[erase_index] = erased_char; // put the erased character back
+            replacement_len = strlen (replacement); // measure replacement length
+            new_searchpath_len = (size_t) token - (size_t) resolved_search_path + replacement_len + endbit_len; // measure updated search path len
+            if (new_searchpath_len > old_searchpath_len)
+            {
+               reallocated_ptr = realloc (resolved_search_path, new_searchpath_len + 1); // grow it if necessary
+               ASSERT_WITH_ERRNO (reallocated_ptr);
+               token = &((char *) reallocated_ptr)[token - resolved_search_path]; // fix the pointers that may have moved
+               endbit = &((char *) reallocated_ptr)[endbit - resolved_search_path]; // fix the pointers that may have moved
+               resolved_search_path = reallocated_ptr;
+            }
+            memmove (token + replacement_len, endbit, endbit_len + 1); // move the end bit to its final location (including its nul terminator)
+            memcpy (token, replacement, replacement_len); // and patch the replacement in between
+         }
+         // now split this search path string into multiple tokens and process them one after the other
+         token = (*resolved_search_path != 0 ? resolved_search_path : NULL);
          nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
          while (token != NULL)
+         {
+            // look under this search path at each of the known subpaths
             for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)
+            {
                sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s/%s/%s", (int) (nextsep - token), token, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname);
                if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))
                   return (resolved_pathname); // if a file can indeed be found at this location, stop searching
             token = (*nextsep != 0 ? nextsep + 1 : NULL);
             nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);
+         }
+      }
-      // file not found in search paths: look under QNX_TARGET
+      // file not found in search paths: look under QNX_TARGET at each of the known subpaths
       for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)
+      {
          sprintf_s (resolved_pathname, MAXPATHLEN, "%s/%s/%s/%s", QNX_TARGET, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname);
          if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))
             return (resolved_pathname); // if a file can indeed be found at this location, stop searching
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
    static thread_local char *candidate_pathname = NULL;
    static int inode_count = 0; // will be preincremented each time this function is called
+   const char *stored_pathname_without_leading_slash;
    const char *original_stored_pathname = NULL;
    buffer_t *shstrtab = NULL;
    const char *canonical_dylib_name;
    const char *dynamic_strings; // strings table of the ".dynamic" section
    const char *last_dirsep;
    char *global_envstring = NULL;
    size_t global_envstring_len = 0;
+   size_t fsentry_index;
    char *startup_name = NULL;
    char *procnto_name = NULL;
    char *resolved_pathname;
    void *reallocated_ptr;
    void *old_data;
+   {
       if (strcmp (stored_pathname, "/proc/boot/boot") == 0) // is it the kernel ?
+      {
          // HACK: for now just consider the kernel as a binary blob
          // FIXME: reimplement properly
-#ifdef PROCNTO_WIP // FIXME: segment corruption somewhere!
+#ifdef PROCNTO_WIP
          char *linebit_start;
          char *content_line;
          char *write_ptr;
          char *token;
          char *value;
+      }
       else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?
+      {
          resolved_pathname = resolve_pathname (buildhost_pathname, entry_parms->search); // locate the file
          if (resolved_pathname == NULL)
+         {
+            if (entry_parms->should_allow_nonexistent_files)
+            {
+               LOG_WARNING ("filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: ignoring", buildhost_pathname, buildfile_pathname, lineno);
+               return (*fsentry_count); // if we're allowed to continue when a file to add doesn't exist, do so, else die with an error message
+            }
             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
          if (entry_parms->mtime == UINT32_MAX)
             entry_parms->mtime = (uint32_t) stat_buf.st_mtime;
       if (strchr (entry_parms->data.bytes, ':') == NULL)
          DIE_WITH_EXITCODE (1, "device entry \"%s\" malformed (no 'dev:rdev' pair)", stored_pathname);
       LOG_INFO ("fifo: ino 0x%x uid %d gid %d mode 0%o path \"%s\" dev:rdev %s)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);
+   }
+   // have a pointer to where the stored pathname actually starts, without the leading slash
+   stored_pathname_without_leading_slash = stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname;
+   // see if this item already has an entry in the current list of filesystem entries
+   for (fsentry_index = 0; fsentry_index < *fsentry_count; fsentry_index++)
+   {
+      fsentry = &(*fsentries)[fsentry_index]; // quick access to fs entry slot
+      if (   (S_ISDIR  (fsentry->header.mode) && (strcmp (fsentry->u.dir.path,     stored_pathname_without_leading_slash) == 0))
+            || (S_ISREG  (fsentry->header.mode) && (strcmp (fsentry->u.file.path,    stored_pathname_without_leading_slash) == 0))
+            || (S_ISLNK  (fsentry->header.mode) && (strcmp (fsentry->u.symlink.path, stored_pathname_without_leading_slash) == 0))
+            || (S_ISFIFO (fsentry->header.mode) && (strcmp (fsentry->u.symlink.path, stored_pathname_without_leading_slash) == 0)))
+         break; // stop searching as soon as we find a duplicate
+   }
+   // 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 (!entry_parms->should_ignore_duplicates)
+         DIE_WITH_EXITCODE (1, "duplicate detected: entry \"%s\" specified in \"%s\" line %d already exists in IFS file", stored_pathname, buildfile_pathname, lineno);
+   }
-   // grow filesystem entries array to hold one more slot
+   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
+      reallocated_ptr = realloc (*fsentries, (*fsentry_count + 1) * sizeof (fsentry_t)); // attempt to reallocate
-   ASSERT_WITH_ERRNO (reallocated_ptr);
+      ASSERT_WITH_ERRNO (reallocated_ptr); // verify
-   *fsentries = reallocated_ptr; // save reallocated pointer
+      *fsentries = reallocated_ptr; // save reallocated pointer
-   fsentry = &(*fsentries)[*fsentry_count]; // quick access to fs entry slot
+      fsentry = &(*fsentries)[*fsentry_count]; // quick access to fs entry slot
+      (*fsentry_count)++; // remember there's one entry more in the array
+   }
+   // save (or update) this entry's parameters
    fsentry->header.extattr_offset = 0;
    fsentry->header.ino = entry_parms->extra_ino_flags | (++inode_count);
    fsentry->header.mode = entry_parms->st_mode;
    fsentry->header.gid = entry_parms->gid;
    fsentry->header.uid = entry_parms->uid;
    fsentry->header.mtime = (entry_parms->mtime == UINT32_MAX ? (uint32_t) time (NULL) : entry_parms->mtime);
    if (S_ISDIR (entry_parms->st_mode))
+   {
-      fsentry->u.dir.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
+      fsentry->u.dir.path = strdup (stored_pathname_without_leading_slash);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + strlen (fsentry->u.dir.path) + 1, image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = true; // no data to save
+   }
    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[0] == '/' ? &stored_pathname[1] : stored_pathname);
+      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_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[0] == '/' ? &stored_pathname[1] : stored_pathname) + 1);
+      fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname_without_leading_slash) + 1);
       fsentry->u.symlink.sym_size = (uint16_t) entry_parms->data.size;
-      fsentry->u.symlink.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
+      fsentry->u.symlink.path = strdup (stored_pathname_without_leading_slash);
       fsentry->u.symlink.contents = strdup (entry_parms->data.bytes);
       ASSERT_WITH_ERRNO (fsentry->u.symlink.contents);
       fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint16_t) + sizeof (uint16_t) + (size_t) fsentry->u.symlink.sym_offset + fsentry->u.symlink.sym_size + 1, image_align); // now we can set the size
       fsentry->UNSAVED_was_data_written = true; // no data to save
+   }
    else // necessarily a device node
+   {
       fsentry->u.device.dev  = strtol (entry_parms->data.bytes, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
       fsentry->u.device.rdev = strtol (strchr (entry_parms->data.bytes, ':') + 1, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers
-      fsentry->u.device.path = strdup (stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname);
+      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_count)++;
    // 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)
+   {
       entry_parms->is_compiled_bootscript = false;
          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 if (strcmp (token, "+dupignore")  == 0) entry_parms.should_ignore_duplicates = true;
+         else if (strcmp (token, "-dupignore")  == 0) entry_parms.should_ignore_duplicates = false;
+         else if (strcmp (token, "+optional")   == 0) entry_parms.should_allow_nonexistent_files = true;
+         else if (strcmp (token, "-optional")   == 0) entry_parms.should_allow_nonexistent_files = 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
+      }
             } } 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); \
                default_parms->attr = entry_parms.attr; \
             } } while (0)
-         //APPLY_DEFAULT_ATTR_STR (new_cwd,                  "current working directory",       "\"%s\"");
+         //APPLY_DEFAULT_ATTR_STR (new_cwd,                        "current working directory",       "\"%s\"");
-         APPLY_DEFAULT_ATTR_STR (search,                   "search path list",                "\"%s\"");
+         APPLY_DEFAULT_ATTR_STR (search,                         "search path list",                "\"%s\"");
-         APPLY_DEFAULT_ATTR_STR (prefix,                   "prefix",                          "\"%s\"");
+         APPLY_DEFAULT_ATTR_STR (prefix,                         "prefix",                          "\"%s\"");
-         APPLY_DEFAULT_ATTR_NUM (dperms,                   "directory permissions",           "0%o");
+         APPLY_DEFAULT_ATTR_NUM (dperms,                         "directory permissions",           "0%o");
-         APPLY_DEFAULT_ATTR_NUM (perms,                    "file permissions",                "0%o");
+         APPLY_DEFAULT_ATTR_NUM (perms,                          "file permissions",                "0%o");
-         APPLY_DEFAULT_ATTR_NUM (uid,                      "owner ID",                        "%d");
+         APPLY_DEFAULT_ATTR_NUM (uid,                            "owner ID",                        "%d");
-         APPLY_DEFAULT_ATTR_NUM (gid,                      "group ID",                        "%d");
+         APPLY_DEFAULT_ATTR_NUM (gid,                            "group ID",                        "%d");
-         APPLY_DEFAULT_ATTR_NUM (st_mode,                  "inode type",                      "0%o");
+         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 (is_compiled_bootscript,         "compiled script state",           "%d");
-         APPLY_DEFAULT_ATTR_NUM (should_follow_symlinks,   "symlink resolution",              "%d");
+         APPLY_DEFAULT_ATTR_NUM (should_follow_symlinks,         "symlink resolution flag",         "%d");
-         APPLY_DEFAULT_ATTR_NUM (should_autosymlink_dylib, "dylib canonical name symlinking", "%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");
+         APPLY_DEFAULT_ATTR_NUM (should_keep_ld_output,          "linker output preservation flag", "%d");
+         APPLY_DEFAULT_ATTR_NUM (should_ignore_duplicates,       "ignore duplicates flag",          "%d");
+         APPLY_DEFAULT_ATTR_NUM (should_allow_nonexistent_files, "ignore nonexistent files flag",   "%d");
          #undef APPLY_DEFAULT_ATTR_STR
          #undef APPLY_DEFAULT_ATTR_NUM
          return; // end of line reached, proceed to the next line
+      }
       // end of attributes parsing

Subversion Repositories QNX 8.QNX8 IFS tool

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