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

 #include <ctype.h>
 #include <time.h>
 // platform-specific includes
 #ifdef _MSC_VER
-#include <io.h>
-#include <direct.h>
 #include <sys/utime.h>
 #else // !_MSC_VER
 #include <sys/param.h>
+#include <sys/sysmacros.h>
 #include <unistd.h>
+#include <dirent.h>
 #include <utime.h>
 #endif // _MSC_VER
 // own includes
 #include "buffer.h"
    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
 } parms_t;
 static int lineno = 0; // current line number in IFS build file
 static char *QNX_TARGET = NULL; // value of the $QNX_TARGET environment variable
 static char *SEARCH_PATH = NULL; // mallocated string of search paths, populated by the -r command-line argument
 static char **saved_ELF_sections = NULL; // mallocated array of const strings, populated by the -s command-line argument
 static size_t saved_ELF_section_count = 0; // number of elements in the saved_ELF_sections array
+static char *sym_suffix = ""; // .sym files extra suffix, settable with the -a command-line argument
 // bootable IFS support
 static char *bootfile_pathname = NULL;           // HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS
 static size_t bootfile_size = 0;                 // HACK: size of the bootcode binary blob file to put at the start of a bootable IFS
 static char *startupfile_pathname = NULL;        // HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS
 static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar); // locates pathname among the known search paths and returns a pointer to the resolved pathname (static string)
 static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file
 static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs_data, const size_t write_offset, const fsentry_t *fsentry); // writes the given filesystem entry (without its contents) to the IFS buffer
 static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer
 static int Buffer_StripELFFile (buffer_t *file, const char **saved_sections, const size_t saved_section_count, const char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded
+static void add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // stack up a new filesystem entry in the the fsentries array
-static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // stack up a new filesystem entry
+static void add_directory_contents_recursively (fsentry_t **fsentries, size_t *fsentry_count, const char *dir_pathname, const size_t start_pathname_len, parms_t *default_parms); // adds the contents of the directory pointed to by dir_pathname to the fsentries array, recursively
 static int fsentry_compare_pathnames_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by pathnames
 static void parse_line (FILE *buildfile_fp, char *line_buffer, fsentry_t **fsentries, size_t *fsentry_count, parms_t *default_parms); // parses a line in the build file and make the relevant changes to the fsentries array
 // imported function prototypes
    #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file
    return (1); // success
+}
-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 void 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;
    char *resolved_pathname;
    void *reallocated_ptr;
    void *old_data;
    struct stat stat_buf;
    fsentry_t *fsentry;
+   int retval;
    // initial allocation (per thread)
    if (candidate_pathname == NULL)
+   {
       candidate_pathname = malloc (MAXPATHLEN);
          resolved_pathname = resolve_pathname (procnto_name, entry_parms->search); // locate the procnto kernel location
          ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_name);
          strcpy (procnto_buildhost_pathname, resolved_pathname);
-         sprintf (procnto_sym_filename, "%s.sym", procnto_name);
+         sprintf_s (procnto_sym_filename, sizeof (procnto_sym_filename), "%s.sym%s", procnto_name, sym_suffix);
          const char *linker_argv[] = // construct the linker invokation argv
+         {
             strrchr (linker_pathname, '/') + 1, // "${TARGET_TRIPLE}-ld"
             linker_sysroot_arg, // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"
             DIE_WITH_EXITCODE (1, "the host cross-linker failed to produce a readable stripped \"%s\" kernel: %s", procnto_sym_filename, strerror (errno));
          if (!entry_parms->should_keep_ld_output)
             unlink (procnto_sym_filename); // remove the linker output file if we want to
          // now strip this prelinked ELF kernel file
-         Buffer_StripELFFile (&entry_parms->data, saved_ELF_sections, 1, stored_pathname); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info")
+         Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, 1, stored_pathname); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info")
          entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
 #else // !PROCNTO_WIP
          /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
          /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */
          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
+               return; // 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;
          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.");
       // is the file we're storing an ELF file ?
       #define ELFHDR ((elf_header_t *) entry_parms->data.bytes) // this convenient definition will make sure the ELF header points at the right location, even after entry_parms.data->byte is reallocated
       if ((entry_parms->data.size > 52) // file is big enough to contain an ELF header
           && (memcmp (ELF_GET_STRING (ELFHDR, ELFHDR, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic
          } // end if the file we're storing is a dylib
          // now strip this ELF file if necessary
          if (!(entry_parms->extra_ino_flags & IFS_INO_PROCESSED_ELF))
+         {
-            Buffer_StripELFFile (&entry_parms->data, saved_ELF_sections, saved_ELF_section_count, stored_pathname); // strip the ELF file à la mkifs
+            Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, saved_ELF_section_count, stored_pathname); // strip the ELF file à la mkifs
             entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
          } // end if the file is not yet a processed ELF
       } // end if the file we're storing is an ELF file
       #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file
+   }
    else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?
+   {
+      // do we already know the data for this data blob ?
+      if (entry_parms->data.bytes != NULL)
+      {
+         entry_parms->mtime = entry_parms->mtime_for_inline_files; // if so, set it a mtime equal to the mtime to use for inline files
-      LOG_INFO ("symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);
+         LOG_INFO ("symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);
+      }
+      else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?
+      {
+         entry_parms->data.bytes = malloc (MAXPATHLEN); // allocate enough space for symlink data
+         ASSERT_WITH_ERRNO (entry_parms->data.bytes);
+         retval = readlink (buildhost_pathname, entry_parms->data.bytes, MAXPATHLEN); // read symlink contents
+         ASSERT_WITH_ERRNO (retval > 0);
+         entry_parms->data.size = retval; // save symlink target length
+      }
+      else
+         DIE_WITH_EXITCODE (1, "unexpected code path: can't store a symlink without neither explicit contents nor a host pathname. This is a bug in the program. Please contact the author.");
+   }
    else // we must be storing a FIFO
+   {
-      if (strchr (entry_parms->data.bytes, ':') == NULL)
+      if ((entry_parms->data.bytes == NULL) || (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
    // 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_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_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)))
+          || (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)
       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
+   }
+   return; // finished, return to our caller
+}
+static void add_directory_contents_recursively (fsentry_t **fsentries, size_t *fsentry_count, const char *dir_pathname, const size_t start_pathname_len, parms_t *default_parms)
+{
+   // adds the contents of the directory pointed to by dir_pathname to the fsentries array, recursively
+   // start_pathname_len is initialized to the length of dir_pathname by the top caller, and passed down unchanged,
+   // so that each sublevel of the recursion knows the depth of the relative path in which it is.
+   thread_local static char item_pathname[MAXPATHLEN] = "";
+   thread_local static parms_t entry_parms = { 0 };
+   thread_local static struct stat stat_buf = { 0 };
+   thread_local static char major_minor[64];
+   DIR *dirp;
-   return (*fsentry_count);
+   struct dirent *dp;
+   // open the directory
+   dirp = opendir (dir_pathname);
+   if (dirp == NULL)
+      DIE_WITH_EXITCODE (1, "unable to open directory \"%s\" for recursive inclusion", dir_pathname);
+   // enumerate its contents
+   while ((dp = readdir (dirp)) != NULL)
+   {
+      if ((strcmp (dp->d_name, ".") == 0) || (strcmp (dp->d_name, "..") == 0))
+         continue; // skip self and parent
+      memcpy (&entry_parms, default_parms, sizeof (parms_t));
+      sprintf_s (item_pathname, sizeof (item_pathname), "%s/%s", dir_pathname, dp->d_name); // construct item's pathname
+      ASSERT_WITH_ERRNO (stat (item_pathname, &stat_buf) == 0); // peek info about this entry (or die trying)
+      if (S_ISDIR (stat_buf.st_mode))
+      {
+         entry_parms.st_mode |= entry_parms.dperms; // apply DIRECTORY default permissions
+         add_fsentry (fsentries, fsentry_count, &entry_parms, &item_pathname[start_pathname_len], NULL); // add a filesystem entry of type "directory"
+         add_directory_contents_recursively (fsentries, fsentry_count, item_pathname, start_pathname_len, default_parms); // dwell into this directory and add its children recursively
+      }
+      else if (S_ISLNK (stat_buf.st_mode))
+      {
+         entry_parms.st_mode |= 0777; // NOTE: mkifs sets symlink permissions to rwxrwxrwx !?
+         add_fsentry (fsentries, fsentry_count, &entry_parms, &item_pathname[start_pathname_len], item_pathname); // add a filesystem entry of type "link"
+      }
+      else if (S_ISREG (stat_buf.st_mode))
+      {
+         entry_parms.st_mode |= entry_parms.perms; // apply FILE default permissions
+         add_fsentry (fsentries, fsentry_count, &entry_parms, &item_pathname[start_pathname_len], item_pathname); // add a filesystem entry of type "regular file"
+      }
+      else if (S_ISFIFO (stat_buf.st_mode))
+      {
+         entry_parms.st_mode |= entry_parms.perms; // apply FILE default permissions
+         sprintf_s (major_minor, sizeof (major_minor), "%u:%u", (unsigned int) major (stat_buf.st_rdev), (unsigned int) minor (stat_buf.st_rdev));
+         entry_parms.data.bytes = major_minor;
+         add_fsentry (fsentries, fsentry_count, &entry_parms, &item_pathname[start_pathname_len], NULL); // add a filesystem entry of type "FIFO"
+      }
+      else
+         LOG_WARNING ("ignoring unsupported directory entry: \"%s\" (type 0%o)", item_pathname, stat_buf.st_mode & S_IFMT);
+   }
+   closedir (dirp); // finished parsing this level, close the directory handle
+   return; // and return to our caller
+}
 static int fsentry_compare_pathnames_cb (const void *a, const void *b)
+{
    line_ptr = line_buffer;
    while ((*line_ptr != 0) && isspace (*line_ptr))
       line_ptr++; // skip leading spaces
    if ((*line_ptr == 0) || (*line_ptr == '#'))
-      return; // skip empty or comment lines
+      return; // don't process empty lines and comments
    string_len = (int) strlen (line_buffer);
    if ((string_len > 0) && (line_buffer[string_len - 1] == '\n'))
       line_buffer[string_len - 1] = 0; // chop off newline for easier debug output
          else if (strcmp (token, "+script")     == 0) {
             entry_parms.is_compiled_bootscript = true;
             ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&entry_parms.data, INITIAL_STARTUP_SCRIPT)); // FIXME: HACK until the script compiler is implemented
             should_discard_inline_contents = true; // remember we already have data (so as to discard the inline block's contents)
+         }
-         else if (strcmp (token, "-script")     == 0) entry_parms.is_compiled_bootscript = false;
+         else if (strcmp (token, "-script")     == 0) entry_parms.is_compiled_bootscript         = false;
-         else if (strcmp (token, "+followlink") == 0) entry_parms.should_follow_symlinks = true;
+         else if (strcmp (token, "+followlink") == 0) entry_parms.should_follow_symlinks         = true;
-         else if (strcmp (token, "-followlink") == 0) entry_parms.should_follow_symlinks = 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       = true;
-         else if (strcmp (token, "-autolink")   == 0) entry_parms.should_autosymlink_dylib = false;
+         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          = true;
-         else if (strcmp (token, "-keeplinked") == 0) entry_parms.should_keep_ld_output = false;
+         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       = true;
-         else if (strcmp (token, "-dupignore")  == 0) entry_parms.should_ignore_duplicates = false;
+         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
       buffer_t data;
       ifs_offsets_t offsets;
       size_t final_size; // final size: not known (because not set) until everything has been written
    } ifs_t;
-   static startup_header_t startup_header = { 0 }; // output IFS's startup header
+   startup_header_t startup_header = { 0 }; // output IFS's startup header
-   static startup_trailer_v2_t startup_trailer = { 0 }; // output IFS's startup trailer (version 2, with SHA-512 checksum and int32 checksum)
+   startup_trailer_v2_t startup_trailer = { 0 }; // output IFS's startup trailer (version 2, with SHA-512 checksum and int32 checksum)
-   static image_header_t image_header = { 0 }; // output IFS's imagefs header
+   image_header_t image_header = { 0 }; // output IFS's imagefs header
-   static image_trailer_v2_t image_trailer = { 0 }; // output IFS's imagefs trailer (version 2, with SHA-512 checksum and int32 checksum)
+   image_trailer_v2_t image_trailer = { 0 }; // output IFS's imagefs trailer (version 2, with SHA-512 checksum and int32 checksum)
-   static fsentry_t *fsentries = NULL; // output IFS's filesystem entries
+   fsentry_t *fsentries = NULL; // output IFS's filesystem entries
-   static size_t fsentry_count = 0; // number of entries in the IFS filesystem
+   size_t fsentry_count = 0; // number of entries in the IFS filesystem
-   static parms_t default_parms = { // default parameters for a filesystem entry
+   parms_t default_parms = { // default parameters for a filesystem entry
       .dperms = 0755,
       .perms = 0644,
       .uid = 0,
       .gid = 0,
       .st_mode = S_IFREG,
       .is_compiled_bootscript = false, // [+|-script]
       .extra_ino_flags = 0,
       .search = NULL,
       .data = { NULL, 0 }
    };
-   static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
+   parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
    char path_on_buildhost[MAXPATHLEN] = "";
    char path_in_ifs[MAXPATHLEN] = "";
-   char *ifs_pathname = NULL;
+   const char *ifs_pathname = NULL;
+   const char *rootdir_pathname = NULL;
+   const fsentry_t *fsentry;
    void *reallocated_ptr;
    size_t reallocated_size;
    size_t available_space;
    size_t fsentry_index;
    size_t largest_index;
    size_t curr_offset;
    ifs_t ifs = { 0 };
    int32_t checksum;
    char *first_pathname = NULL;
    char *second_pathname = NULL;
+   char *third_pathname = NULL;
    char *sep;
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
    bool should_discard_inline_contents = false;
             DIE_WITH_EXITCODE (1, "the --kernelfile arguments expects <pathname>@<fileoffset>");
          *sep = 0;
          kernelfile_pathname = argv[arg_index];
          kernelfile_offset = (size_t) read_integer (sep + 1);
+      }
+      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)
+      {
          default_parms.mtime = 0; // *all* files should have a mtime set to zero
          want_help = true;
       else if (first_pathname == NULL)
          first_pathname = argv[arg_index];
       else if (second_pathname == NULL)
          second_pathname = argv[arg_index];
+      else if (third_pathname == NULL)
+         third_pathname = argv[arg_index];
       else
          DIE_WITH_EXITCODE (1, "unrecognized option: '%s'", argv[arg_index]);
+   }
-   // do we not have enough information to run ?
+   // do we want to display help ? (TODO: everything that's commented out is pending implementation)
-   if (want_help || (first_pathname == NULL) || (!want_info && !want_dump && !want_hexdump && !want_strip && (second_pathname == NULL)))
+   if (want_help)
+   {
       FILE *out = (want_help ? stdout : stderr); // select the right output channel
       fprintf (out, "ifstool - QNX in-kernel filesystem creation utility by Pierre-Marie Baty <pm@pmbaty.com>\n");
       fprintf (out, "          version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
       if (!want_help)
       fprintf (out, "usage:\n");
       fprintf (out, "    ifstool --info [--everything] <ifs file>\n");
       fprintf (out, "    ifstool --dump [--outdir <path>] <ifs file>\n");
       fprintf (out, "    ifstool --strip [--outfile <pathname>] <ELF file>\n");
       fprintf (out, "    ifstool [-?|--help]\n");
+      // mkifs [-?] [-l inputline] [-n[n]] [-o directory] [-p patchfile] [-r rootdir] [-s section] [-v] [buildfile] [directory] [outputfile]
-      fprintf (out, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-l inputline] [-n[n]] [-r rootdir] [-v[...]] <buildfile> <outfile>\n");
+      fprintf (out, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-a suffix] [-l inputline] [-n[n]] [-r rootdir] [-s section] [-v[...]] <buildfile> [directory] [outfile]\n");
       fprintf (out, "NOTE: the compiler mode requires predigested boot, startup and kernel files produced by mkifs.\n");
       fprintf (out, "options:\n");
       fprintf (out, "    -?       Display some help information.\n");
-//      fprintf (out, "    -a .ext  Append a suffix to symbol files generated via [+keeplinked].\n");
+      fprintf (out, "    -a .ext  Append a suffix to symbol files generated via [+keeplinked].\n");
       fprintf (out, "    -l line  Process line before interpreting the buildfile. Input lines given\n");
       fprintf (out, "             to mkifs should be quoted to prevent interpretation by the shell\n");
       fprintf (out, "             (especially as mkifs input lines often contain spaces). Multiple\n");
       fprintf (out, "             -l options are processed in the order specified. No default.\n");
       fprintf (out, "    -n[n]    Force the modification times of all inline files to be 0. If you\n");
       fprintf (out, "    -v[v..]  Operate verbosely. Specifying additional v options increases the\n");
       fprintf (out, "             verbosity.\n");
       exit (want_help ? 0 : 1);
+   }
-   // do we want info about a particular IFS ? if so, dissecate it
+   // else do we want info about a particular IFS ? if so, dissecate it
-   if (want_info)
+   else if (want_info)
       exit (dump_ifs_info (first_pathname, want_everything));
    // else do we want to dump its contents ? if so, do so
    else if (want_dump)
       exit (dump_ifs_contents (first_pathname, (second_pathname != NULL ? second_pathname : ".")));
    // else do we want to strip an ELF file ? if so, do so
    else if (want_strip)
+   {
       buffer_t file;
       ASSERT (Buffer_ReadFromFile (&file, first_pathname), "can't open \"%s\" for reading: %s", first_pathname, strerror (errno));
-      ASSERT (Buffer_StripELFFile (&file, saved_ELF_sections, saved_ELF_section_count, first_pathname), "error stripping \"%s\": %s", first_pathname, strerror (errno));
+      ASSERT (Buffer_StripELFFile (&file, (const char **) saved_ELF_sections, saved_ELF_section_count, first_pathname), "error stripping \"%s\": %s", first_pathname, strerror (errno));
       ASSERT_WITH_ERRNO (Buffer_WriteToFile (&file, (second_pathname != NULL ? second_pathname : "<stdout>")));
       exit (0);
+   }
    // we want to CREATE an IFS file
    buildfile_pathname = first_pathname; // assign the pathnames properly
+   ifs_pathname = (third_pathname != NULL ? third_pathname : second_pathname); // this is some curious handling of cmdline args, but that's the way mkxfs does it
-   ifs_pathname = second_pathname;
+   rootdir_pathname = (third_pathname != NULL ? second_pathname : NULL);
    // make sure we have ${QNX_TARGET} pointing somewhere
    QNX_TARGET = getenv ("QNX_TARGET");
    if (QNX_TARGET == NULL)
       DIE_WITH_EXITCODE (1, "the QNX_TARGET environment variable is not set");
    else if (access (QNX_TARGET, 0) != 0)
       DIE_WITH_EXITCODE (1, "the QNX_TARGET environment variable doesn't point to an existing directory");
    // open build file
+   if ((buildfile_pathname != NULL) && (strcmp (buildfile_pathname, "-") != 0))
+   {
-   fopen_s (&buildfile_fp, buildfile_pathname, "rb");
+      fopen_s (&buildfile_fp, buildfile_pathname, "rb"); // open it
-   if (buildfile_fp == NULL)
+      if (buildfile_fp == NULL)
-      DIE_WITH_EXITCODE (1, "unable to open build file \"%s\" for reading: %s", buildfile_pathname, strerror (errno));
+         DIE_WITH_EXITCODE (1, "unable to open build file \"%s\" for reading: %s", buildfile_pathname, strerror (errno));
+   }
+   else // no build file specified: use stdin
+   {
+      buildfile_pathname = "<stdin>";
+      buildfile_fp = stdin;
+   }
    // stack up filesystem entries
    memcpy (&entry_parms, &default_parms, sizeof (default_parms));
    entry_parms.st_mode = S_IFDIR | default_parms.dperms;
    add_fsentry (&fsentries, &fsentry_count, &entry_parms, "", NULL); // add the root dir first
       parse_line (buildfile_fp, line_buffer, &fsentries, &fsentry_count, &default_parms);
+   }
    fclose (buildfile_fp); // finished parsing the build file
-   // parse the IFS build file line per line
-   while (fgets (line_buffer, sizeof (line_buffer), buildfile_fp) != NULL)
+   // if a root dir was specified, open it as a directory and recursively add all of its contents to the filesystem
-   {
-      if (current_line != NULL)
+   if (rootdir_pathname != NULL)
-         free (current_line);
-      current_line = strdup (line_buffer);
-      ASSERT_WITH_ERRNO (current_line);
-      lineno++; // keep track of current line number
-   }
-   fclose (buildfile_fp); // finished parsing the build file
+      add_directory_contents_recursively (&fsentries, &fsentry_count, rootdir_pathname, strlen (rootdir_pathname), &default_parms);
    //////////////////////////////////
    // start constructing the IFS file
    Buffer_Initialize (&ifs.data);
    ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, image_totalsize));
    ifs.final_size = ifs.data.size; // and this is the final size of the IFS
    // see if we are past the image max size, in which case it's an error
    if (ifs.final_size > image_maxsize)
-      DIE_WITH_EXITCODE (1, "image file \"%s\" size %zd exceeds max size (%zd)", ifs_pathname, ifs.final_size, (size_t) image_maxsize);
+      DIE_WITH_EXITCODE (1, "image file size %zd exceeds max size (%zd)", ifs.final_size, (size_t) image_maxsize);
    // do we have a startup file ? if so, this is a bootable image
    if (startupfile_pathname != NULL)
+   {
       // patch the startup header with its final values
       checksum = update_checksum (&ifs.data.bytes[ifs.offsets.imageheader], ifs.offsets.imagetrailer - ifs.offsets.imageheader, is_foreign_endianness); // compute old checksum
       memcpy (&ifs.data.bytes[ifs.offsets.imagetrailer], &checksum, 4); // and write it in place
+   }
    // now rewrite IFS with the correct checksums
-   ASSERT_WITH_ERRNO (Buffer_WriteToFile (&ifs.data, ifs_pathname));
+   ASSERT_WITH_ERRNO (Buffer_WriteToFile (&ifs.data, (ifs_pathname != NULL ? ifs_pathname : "<stdout>")));
    // finished, cleanup
    for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)
+   {
+      fsentry = &fsentries[fsentry_index]; // quick access to filesystem entry
+      if (S_ISDIR (fsentry->header.mode))
+         free (fsentry->u.dir.path);
+      else if (S_ISLNK (fsentry->header.mode))
+      {
+         free (fsentry->u.symlink.path);
+         free (fsentry->u.symlink.contents);
+      }
+      else if (S_ISREG (fsentry->header.mode))
+      {
+         free (fsentry->u.file.path);
+         free (fsentry->u.file.UNSAVED_databuf);
+      }
+      else if (S_ISFIFO (fsentry->header.mode))
+         free (fsentry->u.device.path);
+   }
    // and exit with a success code
    LOG_INFO ("Success");
    exit (0);

Subversion Repositories QNX 8.QNX8 IFS tool

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