mirror/ELFIO
1
0
Fork 0
mirror of https://github.com/serge1/ELFIO.git synced 2025-03-15 16:21:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Names and tabs refactoring

Browse Source
This commit is contained in:
Serge Lamikhov-Center 2019-04-19 14:46:22 +03:00
parent 013cc2f9db
commit 858b7a3b70
3 changed files with 61 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
elfio/elfio.hpp
View File

@ -61,10 +61,10 @@ get_##FNAME() const \
} \
void \
set_##FNAME( TYPE val ) \
{ \
if (header) { \
{ \
if (header) { \
header->set_##FNAME( val ); \
} \
} \
} \
namespace ELFIO {
@ -490,13 +490,13 @@ class elfio
}
//------------------------------------------------------------------------------
bool save_header( std::ostream& f )
bool save_header( std::ostream& stream )
{
return header->save( f );
return header->save( stream );
}
//------------------------------------------------------------------------------
bool save_sections( std::ostream& f )
bool save_sections( std::ostream& stream )
{
for ( unsigned int i = 0; i < sections_.size(); ++i ) {
section *sec = sections_.at(i);
@ -505,13 +505,13 @@ class elfio
(std::streamoff)header->get_sections_offset() +
header->get_section_entry_size() * sec->get_index();
sec->save(f,headerPosition,sec->get_offset());
sec->save(stream,headerPosition,sec->get_offset());
}
return true;
}
//------------------------------------------------------------------------------
bool save_segments( std::ostream& f )
bool save_segments( std::ostream& stream )
{
for ( unsigned int i = 0; i < segments_.size(); ++i ) {
segment *seg = segments_.at(i);
@ -519,7 +519,7 @@ class elfio
std::streampos headerPosition = header->get_segments_offset() +
header->get_segment_entry_size()*seg->get_index();
seg->save( f, headerPosition, seg->get_offset() );
seg->save( stream, headerPosition, seg->get_offset() );
}
return true;
}

59
elfio/elfio_section.hpp
View File

@ -49,12 +49,12 @@ class section
size_t stream_size;
size_t get_stream_size() const
{
return stream_size;
return stream_size;
}
void set_stream_size(size_t value)
{
stream_size = value;
stream_size = value;
}
virtual const char* get_data() const = 0;
@ -67,9 +67,9 @@ class section
ELFIO_SET_ACCESS_DECL( Elf64_Off, offset );
ELFIO_SET_ACCESS_DECL( Elf_Half, index );
virtual void load( std::istream& f,
virtual void load( std::istream& stream,
std::streampos header_offset ) = 0;
virtual void save( std::ostream& f,
virtual void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset ) = 0;
virtual bool is_address_initialized() const = 0;
@ -235,33 +235,34 @@ class section_impl : public section
{
std::fill_n( reinterpret_cast<char*>( &header ), sizeof( header ), '\0' );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &header ), sizeof( header ) );
Elf_Xword size = get_size();
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
}
if ( 0 != size ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; //ensure data is ended with 0 to avoid oob read
data_size = size;
}
}
if ( 0 == data && SHT_NULL != get_type() && SHT_NOBITS != get_type() && size < get_stream_size()) {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
}
if ( 0 != size ) {
stream.seekg( (*convertor)( header.sh_offset ) );
stream.read( data, size );
data[size] = 0; //ensure data is ended with 0 to avoid oob read
data_size = size;
}
}
}
//------------------------------------------------------------------------------
void
save( std::ostream& f,
save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset )
{
@ -270,10 +271,10 @@ class section_impl : public section
header.sh_offset = (*convertor)( header.sh_offset );
}
save_header( f, header_offset );
save_header( stream, header_offset );
if ( get_type() != SHT_NOBITS && get_type() != SHT_NULL &&
get_size() != 0 && data != 0 ) {
save_data( f, data_offset );
save_data( stream, data_offset );
}
}
@ -281,20 +282,20 @@ class section_impl : public section
private:
//------------------------------------------------------------------------------
void
save_header( std::ostream& f,
save_header( std::ostream& stream,
std::streampos header_offset ) const
{
f.seekp( header_offset );
f.write( reinterpret_cast<const char*>( &header ), sizeof( header ) );
stream.seekp( header_offset );
stream.write( reinterpret_cast<const char*>( &header ), sizeof( header ) );
}
//------------------------------------------------------------------------------
void
save_data( std::ostream& f,
save_data( std::ostream& stream,
std::streampos data_offset ) const
{
f.seekp( data_offset );
f.write( get_data(), get_size() );
stream.seekp( data_offset );
stream.write( get_data(), get_size() );
}
//------------------------------------------------------------------------------

41
elfio/elfio_segment.hpp
View File

@ -57,7 +57,7 @@ class segment
virtual const std::vector<Elf_Half>& get_sections() const = 0;
virtual void load( std::istream& stream, std::streampos header_offset ) = 0;
virtual void save( std::ostream& f, std::streampos header_offset,
virtual void save( std::ostream& stream, std::streampos header_offset,
std::streampos data_offset ) = 0;
};
@ -192,8 +192,8 @@ class segment_impl : public segment
std::streampos header_offset )
{
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg ( 0, stream.end );
set_stream_size ( stream.tellg() );
stream.seekg( header_offset );
stream.read( reinterpret_cast<char*>( &ph ), sizeof( ph ) );
@ -202,31 +202,34 @@ class segment_impl : public segment
if ( PT_NULL != get_type() && 0 != get_file_size() ) {
stream.seekg( (*convertor)( ph.p_offset ) );
Elf_Xword size = get_file_size();
if ( size > get_stream_size() ) {
data = 0;
} else {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
}
if ( 0 != data ) {
stream.read( data, size );
data[size] = 0;
}
}
if ( size > get_stream_size() ) {
data = 0;
}
else {
try {
data = new char[size + 1];
} catch (const std::bad_alloc&) {
data = 0;
}
if ( 0 != data ) {
stream.read( data, size );
data[size] = 0;
}
}
}
}
//------------------------------------------------------------------------------
void save( std::ostream& f,
void save( std::ostream& stream,
std::streampos header_offset,
std::streampos data_offset )
{
ph.p_offset = data_offset;
ph.p_offset = (*convertor)(ph.p_offset);
f.seekp( header_offset );
f.write( reinterpret_cast<const char*>( &ph ), sizeof( ph ) );
stream.seekp( header_offset );
stream.write( reinterpret_cast<const char*>( &ph ), sizeof( ph ) );
}
//------------------------------------------------------------------------------