libs/EDocBFD/bfd_utils.cpp

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 Brendon Costa

   This code is free software; you can redistribute it and/or modify 
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This code is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this code; see the file COPYING.  If not, write to
   the Free Software Foundation, 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.

*******************************************************************************/
#include "config.h"
#include "EDocBFD/bfd_utils.h"

#include "EDocBFD/Section.h"
#include "EDocBFD/BFDArchive.h"

#include "EDoc/utils.h"
#include "EDocBFD/exceptions.h"
#include "EDoc/persistence_data.h"

#ifdef HAVE_STRING_H
   #include <string.h>
#endif

#ifdef HAVE_FCNTL_H
   #include <fcntl.h>
#endif

#ifdef HAVE_UNISTD_H
   #include <unistd.h>
#endif

#ifdef HAVE_ERRNO_H
   #include <errno.h>
#endif

#ifdef HAVE_SYS_STAT_H
   #include <sys/stat.h>
#endif

namespace EDocBFD
{
   //===========================================================================
   /** \brief
    */
   bool bfd_initialised = false;

   //===========================================================================
   void ProcessReadBFD(std::list<EDoc::ManagedFile>& input_files, 
      struct bfd* abfd, const EDoc::ManagedFile& filename)
   {
      // Only accept archives and object file formats. Not core dump files.
      if (!bfd_check_format(abfd, bfd_object) && 
          !bfd_check_format(abfd, bfd_archive))
      {
         EDOC_THROW_EXCEPTION(BFDException, "Unknown binary format.", "");
      }

      EDOC_Debug(std::cerr << "BFD Format of file: " << filename.GetFileNameRep()
         << " is: " << bfd_format_string(abfd->format));

      // If the BFD is an archive then process each of its internal files.
      if (bfd_check_format(abfd, bfd_archive))
      {
         for (struct bfd* ibfd = bfd_openr_next_archived_file(abfd, NULL); 
            ibfd; ibfd = bfd_openr_next_archived_file(abfd, ibfd))
         {
            // @@@Brendon Not sure if the filename of ibfd is the name of the 
            // archived file?
            // Construct a temporary managed file object to store the name of 
            // the bfd archive item.
            //std::list<std::string> id = filename.GetIdentifier();
            //id.push_back(ibfd->filename);
            //ret.push_back(ManagedFile(id, filename, NULL));
            ProcessReadBFD(input_files, ibfd, filename);
         }
         
         // @@@Brendon Not sure if this return should be here.
         // Returns as we assume that a BFD archive does not itself contain any
         // .edoc sections.
         return;
      }
      
      // Otherwise here we expect the bfd to be an object. Process its sections.
      EDOC_Debug("Received object format BFD.");
      try
      {
         if (!abfd->sections)
         {
            EDOC_Debug("Contains no sections.");
            return;
         }

         // Dont use: bfd_map_over_sections as it does not work with exceptions.
         asection* p;
         bool has_edoc_data = false;

         for (p = abfd->sections; p != NULL; p = p->next)
         {
            if (strcmp(p->name, EDOC_SECTION_NAME))
            {
               continue;
            }

            std::list<EDoc::ManagedFile> files(HandleEDocSection(abfd, p, filename));
            if (files.size())
            {
               has_edoc_data = true;
               EDOC_Fine("Appending: " << files.size() 
                  << " edoc files to input files list.");
               EDoc::Append(input_files, files);
            }
         }
      }
      catch(...)
      {
         EDOC_Fine("An error occured looking for input files.");
         EDoc::Erase(input_files);
         throw;
      }

   }
   //===========================================================================
   void InitialiseBFD()
   {
      if (bfd_initialised)
      {
         bfd_init();
         bfd_initialised = true;
      }
   }
   //===========================================================================
   struct bfd* OpenBFDFile(std::string filename)
   {
      // Ensure that bfd has been initialised.
      InitialiseBFD();

      // Then we assume it is a binary file with embedded edoc data.
      struct bfd* abfd = bfd_openr(filename.c_str(), "default");
      if (abfd == NULL)
      {
         bfd_error_type error_code = bfd_get_error();
         EDOC_THROW_EXCEPTION(BFDException, bfd_errmsg(error_code), "");
      }

      try
      {
         // Only accept archives and object file formats. Not core dump files.
         if (!bfd_check_format(abfd, bfd_object) && 
             !bfd_check_format(abfd, bfd_archive))
         {
            EDOC_THROW_EXCEPTION(BFDException, 
               "Unknown binary format.", "");
         }

         EDOC_Debug("BFD Format of file: " << filename
            << " is: " << bfd_format_string(abfd->format));
      }
      catch(...)
      {
         bfd_close(abfd);
         throw;
      }

      return abfd;
   }
   //===========================================================================
   std::list<EDoc::ManagedFile> HandleEDocSection(bfd* abfd, asection* asect,
      const EDoc::ManagedFile& arch)
   {
      std::list<EDoc::ManagedFile> ret;
      Section section(abfd, asect);

      try
      {
         while (!section.IsEof())
         {
            std::string data;

            // Need to read the 1st 4 bytes for the block size.
            data = section.ReadEx(4);
            uint32_t block_size = 0;
            block_size = ( ((uint32_t)((uint8_t)data[0]) << 24) |
                           ((uint32_t)((uint8_t)data[1]) << 16) |
                           ((uint32_t)((uint8_t)data[2]) << 8)  |
                           ((uint32_t)((uint8_t)data[3]) << 0));
            EDOC_Finest("Got block size: " << block_size);

            // read the filename size.
            data = section.ReadEx(4);
            uint32_t filename_size = 0;
            filename_size = ( ((uint32_t)((uint8_t)data[0]) << 24) |
                              ((uint32_t)((uint8_t)data[1]) << 16) |
                              ((uint32_t)((uint8_t)data[2]) << 8)  |
                              ((uint32_t)((uint8_t)data[3]) << 0));

            EDOC_Finest("Got filename size: " << filename_size);
            std::string filename = section.ReadEx(filename_size);
            EDOC_Debug("Extracted: " << filename 
               << " of size: " << (block_size - filename_size));

            // Read the data in chunks and write it to a temp file.
            std::string outfile = EDoc::CreateTempFilename();
            int fd = open(outfile.c_str(), O_WRONLY, O_TRUNC);
            if (fd == -1)
            {
               EDOC_THROW_EXCEPTION(BFDException, "", "");
            }

            std::list<std::string> id = arch.GetIdentifier();
            id.push_back(filename);
            ret.push_back(EDoc::ManagedFile(id, outfile, 
               new ExtractedBFDFile(outfile)));

            // -4 because of the file size value is included into the 
            // block size.
            uint32_t file_size = block_size - filename_size - 8;

            char temp[1024];
            size_t blocks_to_read = file_size / 1024;
            for (size_t i = 0; i < blocks_to_read; i++)
            {
               ssize_t result = section.ReadEx(temp, 1024);
               if (write(fd, temp, result) != result)
               {
                  EDOC_THROW_EXCEPTION(BFDException, "", "");
               }
            }

            if (file_size % 1024)
            {
               ssize_t result = section.ReadEx(temp, file_size % 1024);
               if (write(fd, temp, result) != result)
               {
                  EDOC_THROW_EXCEPTION(BFDException, "", "");
               }
            }

            close(fd);
            EDOC_Finest("Completed writing contents of extrated file to "
               "temp file.");
         }
      }
      catch(...)
      {
         EDOC_Debug("An error occured re-throwing.");
         EDoc::Erase(ret);
         throw;
      }

      return ret;
   }
   //===========================================================================
   void EmbedFileInBinary(const std::string& file_to_embed, 
      const std::string embedded_name,
      const std::string& binary_file, 
      std::string section)
   {
      std::string tmpfile = EDoc::CreateTempFilename();
      int fd = open(tmpfile.c_str(), O_WRONLY, O_TRUNC);
      if (fd == -1)
      {
         EDOC_THROW_EXCEPTION(BFDException, "", "");
      }

      try
      {
         // Write the block size
         // Write the filename size
         // Write the filename
         // Copy the data


         struct stat buffer;
         int result = stat(file_to_embed.c_str(), &buffer);
         if ((result == -1) || !(buffer.st_mode & S_IFREG))
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         size_t block_size = embedded_name.size() + 8 + buffer.st_size;
         unsigned char c = 0;

         c = (block_size & 0xFF000000) >> 24;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (block_size & 0x00FF0000) >> 16;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (block_size & 0x0000FF00) >> 8;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (block_size & 0x000000FF) >> 0;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (embedded_name.size() & 0xFF000000) >> 24;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (embedded_name.size() & 0x00FF0000) >> 16;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (embedded_name.size() & 0x0000FF00) >> 8;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         c = (embedded_name.size() & 0x000000FF) >> 0;
         result = write(fd, &c, 1);
         if (result != 1)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         result = write(fd, embedded_name.c_str(), embedded_name.size());
         if (result != (ssize_t)embedded_name.size())
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         // Open the file to be embedded to read from.
         int fd2 = open(file_to_embed.c_str(), O_RDONLY, 0);
         if (fd2 == -1)
         {
            EDOC_THROW_EXCEPTION(BFDException, "", "");
         }

         // Write the contents of the file.
         char temp[1024];
         size_t blocks_to_write = buffer.st_size / 1024;

         for (size_t i = 0; i < blocks_to_write; i++)
         {
            ssize_t result = read(fd2, temp, 1024);
            if (result == 0)
            {
               EDOC_THROW_EXCEPTION(BFDException, "", "");
            }
            if (write(fd, temp, result) != result)
            {
               EDOC_THROW_EXCEPTION(BFDException, "", "");
            }
         }

         if (buffer.st_size % 1024)
         {
            ssize_t result = read(fd2, temp, buffer.st_size % 1024);
            if (result == 0)
            {
               EDOC_THROW_EXCEPTION(BFDException, "", "");
            }
            if (write(fd, temp, result) != result)
            {
               EDOC_THROW_EXCEPTION(BFDException, "", "");
            }
         }

         close(fd2);
         close(fd);


         std::ostringstream stream;
         stream << "objcopy --remove-section=" << section << " --add-section "
            << section << "=" << tmpfile
            << " " << binary_file;
         if (EDoc::RunProgram(stream.str()) != 0)
         {
            EDOC_THROW_EXCEPTION(EDoc::BugException, "", "");
         }

         // Delete the temporary file.
         unlink(tmpfile.c_str());
      }
      catch(...)
      {
         unlink(tmpfile.c_str());
         throw;
      }
   }
   //===========================================================================
   
}

---