Subversion Repositories QNX 8.QNX8 IFS tool

#include <direct.h>

#include <sys/utime.h>

#define mkdir(p,m) _mkdir ((p))

#define chmod(p,m) _chmod ((p), (m))

#define utimbuf __utimbuf32

#define utime(p,t) _utime32 ((p), (t))

#include <utime.h>

static int create_intermediate_dirs (const char *file_pathname); // creates all intermediate directories to file_pathname so that fopen(file_pathname, "w") doesn't fail

static int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error

   char *outdir = ".";

   bool want_dump = false;

      else if ((strcmp (argv[arg_index], "--outdir") == 0) && (arg_index + 1 < argc)) // --outdir path

         outdir = argv[++arg_index];

      else if (strcmp (argv[arg_index], "--dump") == 0)

         want_dump = true;

      fprintf (fp, "    ifstool --dump [--outdir <path>] <ifs file>\n");

   // else do we want to dump its contents ? if so, do so

   else if (want_dump)

      exit (dump_ifs_contents (buildfile_pathname, outdir)); // NOTE: the first argument after --info is actually the IFS file, not a build file, but the arguments are collected in this order

   return (0);

}

static int create_intermediate_dirs (const char *file_pathname)

{

   // creates all intermediate directories from root (or cwd) up to file_path

   char *temp_pathname;

   char *separator;

   size_t string_index;

   size_t length;

   temp_pathname = strdup (file_pathname); // have a working copy of file_pathname

   if (temp_pathname == NULL)

      return (-1); // on strdup() failure, return an error value (errno is set)

   length = strlen (temp_pathname);

   for (string_index = length - 1; string_index != SIZE_MAX; string_index--) // i.e. loop until it overflows

      if ((temp_pathname[string_index] == '/') || (temp_pathname[string_index] == '\\'))

         break; // look for the last directory separator and stop as soon as we find it

   if (string_index != SIZE_MAX)

   {

      for (; string_index < length; string_index++)

         temp_pathname[string_index] = 0; // if we found one, break there so as to have just the path and clear the rest of the string

      separator = strtok (&temp_pathname[1], "/\\"); // for each separator in the remaining string past the first one...

      while (separator != NULL)

      {

         (void) mkdir (temp_pathname, 0755); // create directories recursively

         temp_pathname[strlen (temp_pathname)] = '/'; // put the separator back

         separator = strtok (NULL, "/\\"); // and look for the next one

      }

   }

   free (temp_pathname); // release our working copy of file_pathname

   return (0);

}

static int dump_ifs_contents (const char *ifs_pathname, const char *outdir)

{

   static char outfile_pathname[MAXPATHLEN] = "";

   startup_header_t *startup_header = NULL;

   size_t startupheader_offset = 0;

   image_header_t *image_header = NULL;

   size_t imageheader_offset = 0;

   size_t imagetrailer_offset = 0;

   fsentry_t **fsentries = NULL; // mallocated

   size_t fsentry_count = 0;

   fsentry_t *current_fsentry = NULL;

   size_t startupfile_blobsize = 0;

   struct utimbuf file_times = { 0, 0 };

   void *reallocated_ptr;

   size_t bootfile_blobsize = 0;

   size_t current_offset;

   size_t fsentry_index;

   size_t nearest_distance;

   size_t nearest_index;

   size_t byte_index;

   buffer_t file;

   FILE *fp;

   // open and read IFS file

   if (read_filecontents (ifs_pathname, ".", &file) == NULL)

   {

      fprintf (stderr, "error: can't open \"%s\" for reading: %s\n", ifs_pathname, strerror (errno));

      return (1);

   }

   // create the output directory

   create_intermediate_dirs (outdir);

   (void) mkdir (outdir, 0755);

   // parse file from start to end

   current_offset = 0;

   for (;;)

   {

      // does a startup header start here ?

      if ((current_offset + sizeof (startup_header_t) < file.len) && (memcmp (&file.bytes[current_offset], "\xeb\x7e\xff\x00", 4) == 0))

      {

         startupheader_offset = current_offset;

         startup_header = (startup_header_t *) &file.bytes[startupheader_offset];

         // layout:

         // [STARTUP HEADER]

         // (startup file blob)

         // [STARTUP TRAILER v1 or v2]

         // validate that the file can contain up to the startup trailer

         if (current_offset + startup_header->startup_size > file.len)

         {

            printf ("WARNING: this IFS file is corrupted (startup trailer extends past end of file)\n");

            goto endofdata;

         }

         // locate the right startup trailer at the right offset

         if (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2)

            startupfile_blobsize = startup_header->startup_size - sizeof (startup_header_t) - sizeof (startup_trailer_v2_t);

         else // old V1 trailer

            startupfile_blobsize = startup_header->startup_size - sizeof (startup_header_t) - sizeof (startup_trailer_v1_t);

         current_offset += sizeof (startup_header_t); // jump over the startup header and reach the startup blob

         // write startup blob

         sprintf (outfile_pathname, "%s/STARTUP.BLOB", outdir);

         fp = fopen (outfile_pathname, "wb");

         WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));

         fwrite (&file.bytes[current_offset], 1, startupfile_blobsize, fp);

         fclose (fp);

         current_offset += startupfile_blobsize; // jump over the startup blob and reach the startup trailer

         current_offset += (startup_header->flags1 & STARTUP_HDR_FLAGS1_TRAILER_V2 ? sizeof (startup_trailer_v2_t) : sizeof (startup_trailer_v1_t)); // jump over the startup trailer and reach the next segment

      }

      // else does an image header start here ?

      else if ((current_offset + sizeof (image_header_t) < file.len) && (memcmp (&file.bytes[current_offset], "imagefs", 7) == 0))

      {

         imageheader_offset = current_offset;

         image_header = (image_header_t *) &file.bytes[imageheader_offset];

         // layout:

         // [IMAGE HEADER]

         // [image directory entries]

         // [smallest file blobs up to KERNEL]

         // [padding]

         // [KERNEL]

         // [rest of file blobs]

         // [IMAGE FOOTER]

         // validate that the file can contain up to the image trailer

         if (current_offset + image_header->image_size > file.len)

         {

            printf ("WARNING: this IFS file is corrupted (image trailer extends past end of file)\n");

            goto endofdata;

         }

         // locate the image trailer at the right offset

         if (image_header->flags & IMAGE_FLAGS_TRAILER_V2)

            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v2_t);

         else // old V1 trailer

            imagetrailer_offset = current_offset + image_header->image_size - sizeof (image_trailer_v1_t);

         current_offset += sizeof (image_header_t); // jump over the image header

         current_offset += image_header->dir_offset - sizeof (image_header_t); // jump over possible padding

         // dump all directory entries until the last one included

         fsentries = NULL;

         fsentry_count = 0;

         while (current_offset < imageheader_offset + image_header->hdr_dir_size)

         {

            current_fsentry = (fsentry_t *) &file.bytes[current_offset];

            if (imageheader_offset + image_header->hdr_dir_size - current_offset < sizeof (current_fsentry->header))

               break; // end padding reached

            // stack up the filesystem entry pointers in an array while we read them

            reallocated_ptr = realloc (fsentries, (fsentry_count + 1) * sizeof (fsentry_t *));

            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");

            fsentries = reallocated_ptr;

            fsentries[fsentry_count] = current_fsentry;

            fsentry_count++;

            if ((current_fsentry->header.size == 0) || (current_offset + current_fsentry->header.size >= file.len))

            {

               printf ("WARNING: this IFS file is corrupted (the size of this directory entry is invalid)\n");

               goto endofdata;

            }

            current_offset += current_fsentry->header.size;

         }

         current_offset += imageheader_offset + image_header->hdr_dir_size - current_offset; // jump over possible padding

         // at this point we are past the directory entries; what is stored now, up to and until the image trailer, is the files' data

         if (fsentry_count > 0)

         {

            while (current_offset < imagetrailer_offset) // and parse data up to the trailer

            {

               nearest_distance = SIZE_MAX;

               nearest_index = SIZE_MAX;

               for (fsentry_index = 0; fsentry_index < fsentry_count; fsentry_index++)

                  if (S_ISREG (fsentries[fsentry_index]->header.mode) // if this directory entry a file (i.e. it has a data blob)...

                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset >= current_offset) // ... AND its data blob is still ahead of our current pointer ...

                      && (imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset < nearest_distance)) // ... AND it's the closest to us we've found so far

                  {

                     nearest_distance = imageheader_offset + (size_t) fsentries[fsentry_index]->u.file.offset - current_offset; // then remember it

                     nearest_index = fsentry_index;

                  }

               if (nearest_index == SIZE_MAX)

                  break; // found no file ahead, which means we've parsed the whole file data area, so stop the loop so as to proceed to the image trailer

               fsentry_index = nearest_index;

               current_fsentry = fsentries[fsentry_index]; // quick access to closest fsentry

               current_offset += imageheader_offset + (size_t) current_fsentry->u.file.offset - current_offset; // jump over possible padding

               if (current_offset + current_fsentry->u.file.size >= file.len)

               {

                  printf ("WARNING: this IFS file is corrupted (the size of this file data extends past the IFS size)\n");

                  goto endofdata;

               }

               // write filesystem data entry

               if (S_ISDIR (current_fsentry->header.mode))

               {

                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.dir.path); // convert from pointer to char array

                  create_intermediate_dirs (outfile_pathname);

                  (void) mkdir (outfile_pathname, current_fsentry->header.mode & 0777);

               }

               else if (S_ISLNK (current_fsentry->header.mode))

               {

                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.symlink.path); // convert from pointer to char array

                  create_intermediate_dirs (outfile_pathname);

#ifdef _WIN32

                  fp = fopen (outfile_pathname, "wb"); // on Windows create symlinks as plain files

                  WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));

                  fwrite ((char *) &current_fsentry->u.symlink.path + current_fsentry->u.symlink.sym_offset, 1, current_fsentry->u.symlink.sym_size, fp); // convert from pointer to char array

                  fclose (fp);

#else // !_WIN32, thus POSIX

                  symlink (current_fsentry->u.symlink.contents, outfile_pathname); // on UNIX systems, just create the symlink for real

#endif // _WIN32

               }

               else if (S_ISREG (current_fsentry->header.mode))

               {

                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.file.path); // convert from pointer to char array

                  create_intermediate_dirs (outfile_pathname);

                  fp = fopen (outfile_pathname, "wb"); // on Windows create symlinks as plain files

                  WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));

                  fwrite (&file.bytes[current_offset], 1, current_fsentry->u.file.size, fp);

                  fclose (fp);

               }

               else // must be a device node. Since we might not be the super-user and/or on Win32, create plain file with "X:Y" as data

               {

                  sprintf (outfile_pathname, "%s/%s", outdir, (char *) &current_fsentry->u.device.path); // convert from pointer to char array

                  create_intermediate_dirs (outfile_pathname);

                  fp = fopen (outfile_pathname, "wb"); // on Windows create symlinks as plain files

                  WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));

                  fprintf (fp, "%u:%u", current_fsentry->u.device.dev, current_fsentry->u.device.rdev);

                  fclose (fp);

               }

               // set created file mtime

               file_times.actime = current_fsentry->header.mtime;

               file_times.modtime = current_fsentry->header.mtime;

               utime (outfile_pathname, &file_times);

               // set created file mode

               (void) chmod (outfile_pathname, current_fsentry->header.mode & 0777);

               current_offset += current_fsentry->u.file.size; // now jump over this file's data

            }

         }

         // ad this point we're past the last file data, there may be padding before the image trailer

         current_offset += imagetrailer_offset - current_offset; // jump over possible padding and reach the image trailer

         current_offset += (image_header->flags & IMAGE_FLAGS_TRAILER_V2 ? sizeof (image_trailer_v2_t) : sizeof (image_trailer_v1_t)); // now jump over the image trailer and reach the next segment (typically end of file)

      }

      // else it has to be a boot blob, of which we don't know the size, except that it has to fit in 0xffff bytes and be immediately followed by a startup header

      else

      {

         // so scan for the first startup header magic and version (which makes us 6 bytes to scan for, i.e. "\xeb\x7e\xff\x00" for the magic and "\x01\x00" (LSB) for the version 1)

         for (byte_index = current_offset; byte_index < file.len - 6; byte_index++)

            if (memcmp (&file.bytes[byte_index], "\xeb\x7e\xff\x00" "\x01\x00", 4 + 2) == 0)

               break; // stop as soon as we find it

         if (byte_index >= file.len - 6)

            break; // if not found, stop scanning

         bootfile_blobsize = byte_index - current_offset;

         // write boot blob

         sprintf (outfile_pathname, "%s/BOOT.BLOB", outdir);

         fp = fopen (outfile_pathname, "wb");

         WELLMANNERED_ASSERT (fp, "failed to open '%s': %s", outfile_pathname, strerror (errno));

         fwrite (&file.bytes[current_offset], 1, bootfile_blobsize, fp);

         fclose (fp);

         current_offset = byte_index; // now reach the next segment

      }

   }

endofdata: