---

rawdump.cpp

Go to the documentation of this file.

/*
PeRdr - PE file disassembler
Copyright (C) 1999-2002 Frediano Ziglio
-----

This program 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 of the License, or
(at your option) any later version.

This program 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 program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-----

INFORMATION
  www: https://freddy77.tripod.com/perdr/
  e-mail: freddy77@angelfire.com
*/
#include "global.h"
#ifdef HAVE_HDRSTOP
#pragma hdrstop
#endif

#include <cctype>
#include "signfile.hpp"
#include "rawdump.h"
#include "codeglob.h"

using namespace std;

// !!! funzione copiata da codeprn.cpp !!!
// file generico di dump ??
static void WriteBinary(uint32_t address,const uint8_t* ibuffer,int _len)
{
  _PRG_ASSERT(ibuffer != NULL);
  _PRG_ASSERT(_len>0);
  // remove warning
  unsigned len = (unsigned)_len;
  const unsigned nCarInRow = 16;
  char buffer[3*nCarInRow+nCarInRow+10];
  for(unsigned n=0;;++n)
  {
    unsigned part = n%nCarInRow;
    if (part==0)
    {
      if (n>=nCarInRow)
      {
        buffer[nCarInRow*3+nCarInRow+1] = '\0';
        printf("%08X %s\n",static_cast<uint32_t>(address+n-nCarInRow),buffer);
        if (n>=len)
          return;
      }
      // inizializza buffer
      memset(buffer,' ',sizeof(buffer));
    }
    if (n<len)
    {
      uint8_t car = *ibuffer++;

      // scrive il carattere in esadecimale e carattere relativo
      sprintf(buffer+part*3,"%02X",car);
      buffer[part*3+2] = part==(nCarInRow/2-1)?'-':' ';
      // !!! settare come opzione carattere ?
      buffer[nCarInRow*3+1+part] = isprint(car)?car:'.';
    }
  }
}

void RawDump(CSignFile& file,uint32_t imageBase,const RVAFileTranslator& rva)
{
  // get file size
  file.Seek(0,SEEK_END);
  uint32_t fileSize = (uint32_t)file.Tell();

  uint32_t startFile = 0;
  uint32_t endFile;

  printf("\nRaw dump\n");

  for(unsigned n=0; ; )
  {
    const PeSection* section = rva.GetSection(n);
    uint32_t writeStart = startFile;
    int currSection = -1;
    if (!section)
    {
      // no more sections, write last part of file
      endFile = fileSize;
    }
    else
    {
      if (startFile == section->RawAddress )
      {
        // write this section
        endFile = section->RawAddress + section->RawSize;
        writeStart = imageBase + section->RvaAddress;
        currSection = n;
        ++n;
      }
      else if (startFile > section->RawAddress )
      {
        // skip section (probably not file section)
        ++n;
        continue;
      }
      else
      {
        // write part before section
        endFile = section->RawAddress;
      }
    }

    // normalize
    if (endFile > fileSize)
      endFile = fileSize;

    // write dump of [startFile, endFile)
    // exclude empty sections
    if (startFile != endFile)
    {
      if (currSection == -1)
        printf("\nFile section\n");
      else
        printf("\nSection %d\n",currSection);
      uint8_t buffer[256];
      file.Seek(startFile);
      while ( startFile < endFile)
      {
        unsigned left = (endFile - startFile) > 256 ? 256 : (endFile - startFile);
        file.RawRead(buffer,left*sizeof(uint8_t));
        WriteBinary(writeStart,buffer,left);
        startFile += left;
        writeStart += left;
      }
    }

    startFile = endFile;

    if (endFile == fileSize)
      break;
  }
}

---