LIBGOBLIN_API_BINFO
const char *LibGoblin_GetRPath_fromBinInfo( int i_bid, char *pstr_rpath );
LIBGOBLIN_API_BINFO
- int LibGoblin_AllocBinInfo( int i_pgid );
+ int LibGoblin_AllocBinInfo( int i_pgid, const char *pstr_filename, const char *pstr_path );
LIBGOBLIN_API_BINFO
int LibGoblin_FreeBinInfo( int i_binfoid );
/*----------------------------------------------------------------------
+Is Exist the Library File in dir (pstr_path & "/" & pstr_solibname)
+
+Return:
+ 0x00: OK (exist LibraryFile)
+ -0x01: Path + .so FileName string size over.
+
+int LibBrownie_SearchLib_IsExistLibrary(
+ char *pstr_path, // Library Dir. string
+ char *pstr_solibname // Library(.so) FileName
+)
----------------------------------------------------------------------*/
int
LibBrownie_SearchLib_IsExistLibrary(
struct stat t_filestat;
char str_solibpath[DRD64_MAX_PATH];
+ // Check Library Path & FileName Size ---
sz_len = strnlen( pstr_path, DRD64_MAX_PATH );
sz_len += strnlen( pstr_solibname, DRD64_MAX_PATH );
/***********************************************************************
+int LibBrownie_GetLibraryPath(
+ char *pstr_solibpath, [OUT] .so existed Library FullPath
+ char *pstr_solibname, [IN] .so Library Filename
+ char *pstr_rpath, [IN] rpath string from .dynamic seciton
+ char *pstr_ldsohints [IN] LD_LIBRARYPATH env string.
+)
+
+ * LocalLibrary ( if pstr_rpath != NULL )
+ pstr_solibpath = pstr_rpath & "/" & pstr_solibname
+
***********************************************************************/
LIBBROWNIE_SEARCHLIB_API
int
return -0x02;
}
+ // LocalLibrary ( rpath in .dynamic section)
if( NULL != pstr_rpath ) {
if( '\0' != *pstr_rpath ) {
i_result = LibBrownie_SearchLib_IsExistLibrary( pstr_rpath, pstr_solibname );
}
}
+ // System Library ( in /usr/lib | /usr/local/lib | ... )
+ // Get from LD_LIBRARYPATH dir.
sz_len = strlen( pstr_ldsohints );
pstr_hintslist = (char *)alloca( sz_len + 1 );
if( NULL == pstr_hintslist ) {
OBJS = drd64_libgoblin_system.o \
drd64_libgoblin_proginfo.o \
drd64_libgoblin_binfo.o \
- drd64_libgoblin_libraryinfo.o \
+ drd64_libgoblin_binaryfile.o \
drd64_libgoblin_checkbin.o \
drd64_libgoblin_analyze.o \
drd64_libgoblin_readbin.o \
drd64_libgoblin_type.h \
drd64_libgoblin_proginfo.h \
drd64_libgoblin_binfo.h \
- drd64_libgoblin_libraryinfo.h \
+ drd64_libgoblin_binaryfile.h \
drd64_libgoblin_checkbin.h \
drd64_libgoblin_analyze.h \
drd64_libgoblin_readbin.h \
TEST_OBJS = test_libgoblin.o \
test_libgoblin_system.o \
test_libgoblin_proginfo.o \
- test_libgoblin_libraryinfo.o \
+ test_libgoblin_binaryfile.o \
test_libgoblin_loadprog.o \
test_libgoblin_binfo.o \
test_libgoblin_readbin.o \
drd64_libgoblin_binfo.o: drd64_libgoblin_binfo.c $(HEADER)
$(CC) -c -o drd64_libgoblin_binfo.o $(FLAGS_DEBUG) \
drd64_libgoblin_binfo.c
-drd64_libgoblin_libraryinfo.o: drd64_libgoblin_libraryinfo.c $(HEADER)
- $(CC) -c -o drd64_libgoblin_libraryinfo.o $(FLAGS_DEBUG) \
- drd64_libgoblin_libraryinfo.c
+drd64_libgoblin_binaryfile.o: drd64_libgoblin_binaryfile.c $(HEADER)
+ $(CC) -c -o drd64_libgoblin_binaryfile.o $(FLAGS_DEBUG) \
+ drd64_libgoblin_binaryfile.c
drd64_libgoblin_checkbin.o: drd64_libgoblin_checkbin.c $(HEADER)
$(CC) -c -o drd64_libgoblin_checkbin.o $(FLAGS_DEBUG) \
drd64_libgoblin_checkbin.c
$(CC) -c -o test_libgoblin_proginfo.o \
$(FLAGS_DEBUG) $(FLAGS_COMPILE) $(TEST_FLAGS_COMPILE) \
test_libgoblin_proginfo.c
-test_libgoblin_libraryinfo.o: test_libgoblin_libraryinfo.c $(HEADER) $(TEST_HEADER)
- $(CC) -c -o test_libgoblin_libraryinfo.o \
+test_libgoblin_binaryfile.o: test_libgoblin_binaryfile.c $(HEADER) $(TEST_HEADER)
+ $(CC) -c -o test_libgoblin_binaryfile.o \
$(FLAGS_DEBUG) $(FLAGS_COMPILE) $(TEST_FLAGS_COMPILE) \
- test_libgoblin_libraryinfo.c
+ test_libgoblin_binaryfile.c
test_libgoblin_loadprog.o: test_libgoblin_loadprog.c $(HEADER) $(TEST_HEADER)
$(CC) -c -o test_libgoblin_loadprog.o \
$(FLAGS_DEBUG) $(FLAGS_COMPILE) $(TEST_FLAGS_COMPILE) \
#include"drd64_libgoblin_type.h"
#include"drd64_libgoblin_proginfo.h"
#include"drd64_libgoblin_binfo.h"
-#include"drd64_libgoblin_libraryinfo.h"
+#include"drd64_libgoblin_binaryfile.h"
#include"drd64_libgoblin_checkbin.h"
#include"drd64_libgoblin_analyze.h"
#include"drd64_libgoblin_readbin.h"
// p_addr->dw_next is update when finalizing ELF/DWARF reading phase.
p_addr->b_elf_flags = p_sym64->st_info;
p_addr->w_secid = LibGoblin_Section_GetSectionID_fromSectionNumber_inElf(
- p_binfo, p_secinfo->i_fid, p_sym64->st_shndx );
+ p_binfo, p_sym64->st_shndx );
if( STT_SECTION == (p_addr->b_elf_flags & 0x0f) )
{ p_addr->pstr_name = LibGoblin_Section_GetSectionName( p_binfo, p_addr->w_secid ); }
else
// p_addr->dw_next is update when finalizing ELF/DWARF reading phase.
p_addr->b_elf_flags = p_sym32->st_info;
p_addr->w_secid = LibGoblin_Section_GetSectionID_fromSectionNumber_inElf(
- p_binfo, p_secinfo->i_fid, p_sym32->st_shndx );
+ p_binfo, p_sym32->st_shndx );
if( STT_SECTION == (p_addr->b_elf_flags & 0x0f) )
{ p_addr->pstr_name = LibGoblin_Section_GetSectionName( p_binfo, p_addr->w_secid ); }
else
LIBGOBLIN_ANALYZE_EXTERN
int
LibGoblin_AnalyzeBinary(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
int i_result = 0x00;
LibGoblin_BinaryFile *p_bfile;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[ i_analyzefid ]);
+ p_bfile = p_binfo->p_binfile;
+ assert( NULL != p_bfile );
/* Check binaryfile is ELF file */
if( 0x00 == (DRD64_LIBFILETYPE_SUB_ELF & p_bfile->t_ftype.w_subtype) ) {
return 0x01;
}
- if((LIBGOBLIN_BINFO_FILE_CORE == i_analyzefid) &&
- (DRD64_LIBFILETYPE_SUB_ELF_CORE != p_bfile->t_ftype.w_subtype)) {
- return 0x02;
- }
-
/* Analyze ELF & Debug-Info. ---*/
//i_result = LibGoblin_AnalyzeElf( p_binfo, i_analyzefid );
- i_result = LibGoblin_Elf_ReadELF_Phase1( p_binfo, i_analyzefid );
+ i_result = LibGoblin_Elf_ReadELF_Phase1( p_binfo );
if( 0x00 != i_result ) {
return 0x03;
}
- i_result = LibGoblin_Elf_ReadELF_Phase2( p_binfo, i_analyzefid );
+ i_result = LibGoblin_Elf_ReadELF_Phase2( p_binfo );
return i_result;
}
LIBGOBLIN_ANALYZE_EXTERN
int LibGoblin_AnalyzeBinary(
- LibGoblin_BinaryInfo *p_bin, int i_analyzefid );
+ LibGoblin_BinaryInfo *p_bin );
--- /dev/null
+/*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
+
+ D r . D e a m o n 6 4
+ for INTEL64(R), AMD64(R)
+
+ Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+
+DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
+
+/* File Info -----------------------------------------------------------
+File: drd64_.c
+Function:
+Comment:
+----------------------------------------------------------------------*/
+
+#define DRD64_SRC_LIBGOBLIN_BINARYFILE
+#include"drd64_libgoblin.h"
+
+/*----------------------------------------------------------------------
+----------------------------------------------------------------------*/
+LIBGOBLIN_BINARYFILE_EXTERN
+LibGoblin_BinaryFile *
+ BinaryFile_GetBinaryFile(
+ int i_bfid )
+{
+ if(( gi_max_binary_file <= i_bfid ) || ( 0 > i_bfid ))
+ { return NULL; }
+
+ if( -0x01 == BINFILE( i_bfid )->i_id )
+ { return NULL; }
+
+ return BINFILE( i_bfid );
+}
+
+
+/*----------------------------------------------------------------------
+OK
+----------------------------------------------------------------------*/
+void
+ BinaryFile_ClearBinaryFile(
+ LibGoblin_BinaryFile *p_binfile )
+{
+ assert( NULL != p_binfile );
+
+ memset( p_binfile, 0x00, sizeof( LibGoblin_BinaryFile ) );
+
+ p_binfile->i_id = -0x01;
+
+ return;
+}
+
+
+/*----------------------------------------------------------------------
+OK
+----------------------------------------------------------------------*/
+LIBGOBLIN_BINARYFILE_EXTERN
+LibGoblin_BinaryFile *
+ BinaryFile_AllocBinaryFile(
+ void )
+{
+ int i_cnt;
+ int i_id_now = -0x01;
+ LibGoblin_BinaryFile *p_binfile = NULL;
+ LibGoblin_BinaryFile *p_bfilebase;
+
+ if( gi_now_binary_file < gi_max_binary_file ) {
+ // Search Non-Used & Alloced BinaryFile struct.
+ for( i_cnt = 0; i_cnt < gi_max_binary_file; i_cnt++ ) {
+ if( -0x01 == BINFILE( i_cnt )->i_id ) {
+ p_binfile = BINFILE( i_cnt );
+ i_id_now = i_cnt;
+ goto goto_BinaryFile_AllocBinaryFile_dataset;
+ }
+ }
+
+ // Bug -- Not Exist Non-used BinaryFile struct.
+ goto goto_BinaryFile_AllocBinaryFile_post;
+ }
+
+ if( gi_now_binary_file == gi_alloc_binary_file ) {
+ p_bfilebase = (LibGoblin_BinaryFile *)realloc( gp_binary_file,
+ sizeof( LibGoblin_BinaryFile ) *
+ ( gi_alloc_binary_file + LIBGOBLIN_BINARYFILE_UNITS ) );
+ if( NULL == p_bfilebase ) {
+ goto goto_BinaryFile_AllocBinaryFile_post;
+ }
+
+ gp_binary_file = p_bfilebase;
+ gi_alloc_binary_file += LIBGOBLIN_BINARYFILE_UNITS;
+ }
+
+ i_id_now = gi_now_binary_file;
+
+goto_BinaryFile_AllocBinaryFile_dataset:
+ if( i_id_now == gi_max_binary_file ) { gi_max_binary_file++; }
+ p_binfile = BINFILE( i_id_now );
+ p_binfile->i_id = i_id_now;
+ p_binfile->i_refcount = 1;
+ gi_now_binary_file++;
+
+goto_BinaryFile_AllocBinaryFile_post:
+ return p_binfile;
+}
+
+
+
+/*----------------------------------------------------------------------
+OK
+----------------------------------------------------------------------*/
+LIBGOBLIN_BINARYFILE_EXTERN
+int
+ BinaryFile_FreeBinaryFile(
+ LibGoblin_BinaryFile *p_binfile )
+{
+ int i_id;
+
+ assert( NULL != p_binfile );
+
+ if( -0x01 == p_binfile->i_id ) { return 0x00; }
+
+ i_id = p_binfile->i_id;
+ BinaryFile_ClearBinaryFile( p_binfile );
+
+ if( gi_max_binary_file == (i_id + 1) )
+ { gi_max_binary_file--; }
+
+ gi_now_binary_file--;
+ if( 0 == gi_now_binary_file ) { gi_max_binary_file = 0; }
+
+ return 0x00;
+}
+
+
+/*----------------------------------------------------------------------
+OK
+----------------------------------------------------------------------*/
+LIBGOBLIN_BINARYFILE_EXTERN
+int
+ BinaryFile_Init(
+ void )
+{
+ int i_cnt;
+ LibGoblin_BinaryFile *p_binfile;
+
+ if( 0 != gi_max_binary_file ) {
+ return -0x01;
+ }
+
+ gp_binary_file = (LibGoblin_BinaryFile *)malloc(
+ sizeof( LibGoblin_BinaryFile ) * LIBGOBLIN_BINARYFILE_UNITS );
+ if( NULL == gp_binary_file ) {
+ return -0x02;
+ }
+
+ for( i_cnt = 0; i_cnt < LIBGOBLIN_BINARYFILE_UNITS; i_cnt++ ) {
+ p_binfile = BINFILE( i_cnt );
+ BinaryFile_ClearBinaryFile( p_binfile );
+ }
+
+ gi_alloc_binary_file = LIBGOBLIN_BINARYFILE_UNITS;
+ gi_max_binary_file = 0;
+ gi_now_binary_file = 0;
+
+ return 0x00;
+}
+
+
+/*----------------------------------------------------------------------
+OK
+----------------------------------------------------------------------*/
+LIBGOBLIN_BINARYFILE_EXTERN
+int
+ BinaryFile_Term(
+ void )
+{
+ LibGoblin_BinaryFile *p_binfile;
+
+ if( 0 < gi_now_binary_file ) {
+ for( ; gi_max_binary_file > 0; gi_max_binary_file-- ) {
+ p_binfile = BINFILE( gi_max_binary_file - 1 );
+ BinaryFile_FreeBinaryFile( p_binfile );
+ }
+ }
+
+ free( gp_binary_file );
+
+ gp_binary_file = NULL;
+ gi_alloc_binary_file = 0;
+ gi_max_binary_file = 0;
+ gi_now_binary_file = 0;
+
+ return 0x00;
+}
+
+
+/* EOF of drd64_.c ----------------------------------- */
Comment:
----------------------------------------------------------------------*/
-#ifndef DRD64_HEADER_LIBGOBLIN_LIBRARYINFO
-#define DRD64_HEADER_LIBGOBLIN_LIBRARYINFO
+#ifndef DRD64_HEADER_LIBGOBLIN_BINARYFILE
+#define DRD64_HEADER_LIBGOBLIN_BINARYFILE
-#ifdef DRD64_SRC_LIBGOBLIN_LIBRARYINFO
- #define LIBGOBLIN_LIBRARYINFO_EXTERN
+#ifdef DRD64_SRC_LIBGOBLIN_BINARYFILE
+ #define LIBGOBLIN_BINARYFILE_EXTERN
#else
- #define LIBGOBLIN_LIBRARYINFO_EXTERN extern
+ #define LIBGOBLIN_BINARYFILE_EXTERN extern
#endif
-#if defined DRD64_SRC_LIBGOBLIN_LIBRARYINFO
- #define LIBGOBLIN_LIBRARYINFO_INTERNALFUNC
-#elif defined DRD64_SRC_TEST_LIBGOBLIN_LIBRARYINFO
- #define LIBGOBLIN_LIBRARYINFO_INTERNALFUNC
+#if defined DRD64_SRC_LIBGOBLIN_BINARYFILE
+ #define LIBGOBLIN_BINARYFILE_INTERNALFUNC
+#elif defined DRD64_SRC_TEST_LIBGOBLIN_BINARYFILE
+ #define LIBGOBLIN_BINARYFILE_INTERNALFUNC
#endif
-#define LIBGOBLIN_LIBRARYINFO_UNITS 32
-#define LIBGOBLIN_LIBRARYINFO_MAX_BINFO 128
+#define LIBGOBLIN_BINARYFILE_UNITS 32
+#define LIBGOBLIN_BINARYFILE_MAX_BINFO 128
-#ifdef DRD64_SRC_LIBGOBLIN_LIBRARYINFO
-LibGoblin_LibraryInfo *gp_library_info = NULL;
-int gi_alloc_library_info = 0;
-int gi_max_library_info = 0;
-int gi_now_library_info = 0;
+#ifdef DRD64_SRC_LIBGOBLIN_BINARYFILE
+LibGoblin_BinaryFile *gp_binary_file = NULL;
+int gi_alloc_binary_file = 0;
+int gi_max_binary_file = 0;
+int gi_now_binary_file = 0;
#endif
-#define LIBINFO(n) ((LibGoblin_LibraryInfo *)(gp_library_info + (n)))
+#define BINFILE(n) ((LibGoblin_BinaryFile *)(gp_binary_file + (n)))
-LIBGOBLIN_LIBRARYINFO_EXTERN
- LibGoblin_LibraryInfo *LibraryInfo_GetLibraryInfo( int i_libid );
+LIBGOBLIN_BINARYFILE_EXTERN
+ LibGoblin_BinaryFile *BinaryFile_GetBinaryFile( int i_libid );
/*
-LIBGOBLIN_LIBRARYINFO_EXTERN
- LibGoblin_BinaryInfo *LibGoblin_LibraryInfo_AddBinaryInfo(
+LIBGOBLIN_BINARYFILE_EXTERN
+ LibGoblin_BinaryInfo *LibGoblin_BinaryFile_AddBinaryInfo(
LibGoblin_ProgramInfo *p_pginfo, const char *pstr_binname, int i_req_bid );
*/
-LIBGOBLIN_LIBRARYINFO_EXTERN
- LibGoblin_LibraryInfo *LibraryInfo_AllocLibraryInfo( void );
-LIBGOBLIN_LIBRARYINFO_EXTERN
- int LibraryInfo_FreeLibraryInfo( LibGoblin_LibraryInfo *p_libinfo );
-LIBGOBLIN_LIBRARYINFO_EXTERN
- int LibraryInfo_Init( void );
-LIBGOBLIN_LIBRARYINFO_EXTERN
- int LibraryInfo_Term( void );
-
-
-#ifdef LIBGOBLIN_LIBRARYINFO_INTERNALFUNC
-void LibraryInfo_ClearLibraryInfo( LibGoblin_LibraryInfo *p_libinfo );
+LIBGOBLIN_BINARYFILE_EXTERN
+ LibGoblin_BinaryFile *BinaryFile_AllocBinaryFile( void );
+LIBGOBLIN_BINARYFILE_EXTERN
+ int BinaryFile_FreeBinaryFile( LibGoblin_BinaryFile *p_libinfo );
+LIBGOBLIN_BINARYFILE_EXTERN
+ int BinaryFile_Init( void );
+LIBGOBLIN_BINARYFILE_EXTERN
+ int BinaryFile_Term( void );
+
+
+#ifdef LIBGOBLIN_BINARYFILE_INTERNALFUNC
+void BinaryFile_ClearBinaryFile( LibGoblin_BinaryFile *p_libinfo );
#endif
p_binfo = LibGoblin_BinInfo_GetBinInfo( i_bid );
if( NULL == p_binfo ) {
- return -0x01;
+ return NULL;
}
pcstr_result = LibGoblin_BinInfo_GetRPath( p_binfo, pstr_rpath );
LibGoblin_BinInfo_ClearBinInfo(
LibGoblin_BinaryInfo *p_binfo )
{
- int i_cnt;
-
assert( NULL != p_binfo );
memset( p_binfo, 0x00, sizeof( LibGoblin_BinaryInfo ) );
+ //XXX
p_binfo->i_id = -0x01;
- for( i_cnt = 0; i_cnt < LIBGOBLIN_BINFO_MAXFILES; i_cnt++ ) {
- p_binfo->t_binfile[i_cnt].i_fd = -0x01;
+
+ if( NULL != p_binfo->p_binfile ) {
+ p_binfo->p_binfile->i_fd = -0x01;
}
return;
return -0x02;
}
- p_bfile = &(p_binfo->t_binfile[LIBGOBLIN_BINFO_FILE_EXEC]);
- if( '\0' != p_bfile->str_filepath[0] ) {
+ p_bfile = p_binfo->p_binfile;
+ if( '\0' != p_bfile->str_path[0] ) {
return -0x03;
}
}
// Set Real-BinaryFile Path to LibGoblin_BinaryFile ---
- strncpy( p_bfile->str_filepath, pstr_realpath, DRD64_MAX_PATH );
+ strncpy( p_bfile->str_path, pstr_realpath, DRD64_MAX_PATH );
// Set ProgramFile Path to LibGoblin_BinaryInfo ---
for( pstr_temp = str_temp + i_len;
LIBGOBLIN_BINFO_EXTERN
LibGoblin_BinaryInfo *
LibGoblin_BinInfo_AllocBinInfo(
- LibGoblin_ProgramInfo *p_pginfo )
+ LibGoblin_ProgramInfo *p_pginfo,
+ const char *pstr_filename,
+ const char *pstr_path )
{
int i_cnt;
int i_id_now;
LibGoblin_BinaryInfo *p_binfo_base;
LibGoblin_BinaryInfo *p_binfo_now;
+ LibGoblin_BinaryFile *p_binfile;
p_binfo_now = NULL;
i_id_now = -1;
assert( NULL != p_binfo_now );
+ p_binfile = BinaryFile_AllocBinaryFile();
+ if( NULL == p_binfile ) {
+ return NULL;
+ }
+
LibGoblin_BinInfo_ClearBinInfo( p_binfo_now );
p_binfo_now->i_id = i_id_now;
p_binfo_now->b_phase = LIBGOBLIN_BINFO_PHASE_ALLOCED;
+ p_binfo_now->p_binfile = p_binfile;
p_binfo_now->pv_pginfo = (void *)p_pginfo;
return p_binfo_now;
LIBGOBLIN_API_BINFO
int
LibGoblin_AllocBinInfo(
- int i_pgid )
+ int i_pgid,
+ const char *pstr_filename,
+ const char *pstr_path )
{
LibGoblin_ProgramInfo *p_pginfo = NULL;
LibGoblin_BinaryInfo *p_binfo = NULL;
p_pginfo = LibGoblin_ProgInfo_GetProgInfo( i_pgid );
- p_binfo = LibGoblin_BinInfo_AllocBinInfo( p_pginfo );
+ p_binfo = LibGoblin_BinInfo_AllocBinInfo( p_pginfo, pstr_filename, pstr_path );
if( NULL == p_binfo ) {
return -0x01;
}
{
int i_binfoid;
int i_result;
- int i_cnt;
if( NULL == p_binfo ) { return 0x01; }
return -0x02;
}
- for( i_cnt = 0; i_cnt < LIBGOBLIN_BINFO_MAXFILES; i_cnt++ ) {
- if( NULL == p_binfo->t_binfile[i_cnt].p_elf ) {
- free( p_binfo->t_binfile[i_cnt].p_elf );
- p_binfo->t_binfile[i_cnt].p_elf = NULL;
- }
+ if( NULL == p_binfo->p_binfile->p_elf ) {
+ free( p_binfo->p_binfile->p_elf );
+ p_binfo->p_binfile->p_elf = NULL;
}
+ BinaryFile_FreeBinaryFile( p_binfo->p_binfile );
+ p_binfo->p_binfile = NULL;
+
i_binfoid = p_binfo->i_id;
LibGoblin_BinInfo_ClearBinInfo( p_binfo );
int LibGoblin_BinInfo_SetProgramPath(
LibGoblin_BinaryInfo *p_binfo, const char *pstr_progpath, const char *pstr_realpath );
LIBGOBLIN_BINFO_EXTERN
- LibGoblin_BinaryInfo *LibGoblin_BinInfo_AllocBinInfo( LibGoblin_ProgramInfo *p_pginfo );
+ LibGoblin_BinaryInfo *LibGoblin_BinInfo_AllocBinInfo(
+ LibGoblin_ProgramInfo *p_pginfo, const char *pstr_filename, const char *pstr_path );
LIBGOBLIN_BINFO_EXTERN
int LibGoblin_BinInfo_FreeBinInfo( LibGoblin_BinaryInfo *p_binfo );
LIBGOBLIN_BINFO_EXTERN
LIBGOBLIN_CHECKBIN_EXTERN
int
LibGoblin_CheckBinary(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
Byte *pb_data;
assert( NULL != p_binfo );
- pb_data = p_binfo->t_binfile[i_analyzefid].pb_binary;
+ pb_data = p_binfo->p_binfile->pb_binary;
assert( NULL != pb_data );
/* Analyze ELF Ident Header from Bits ---*/
LIBGOBLIN_CHECKBIN_EXTERN
int LibGoblin_CheckBinary(
- LibGoblin_BinaryInfo *p_bin, int i_analyzefid );
+ LibGoblin_BinaryInfo *p_binfo );
#endif /* DRD64_HEADER_LIBGOBLIN_CHECKBIN */
/* Get .debug_abbrev section Info */
pb_data_abbrev = LibGoblin_Elf_GetSection(
- &qw_size_abbrev, p_bin, 0,
+ &qw_size_abbrev, p_bin,
LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
if( NULL == pb_data_abbrev ) { return 0x00; }
/* Get .debug_abbrev section Info */
pb_data = LibGoblin_Elf_GetSection(
- &qw_size_abbrev, p_bin, 0,
+ &qw_size_abbrev, p_bin,
LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
if( NULL == pb_data ) { return 0x01; }
/* Get .debug_abbrev section Info */
pb_data = LibGoblin_Elf_GetSection(
- &qw_size_abbrev, p_bin, 0,
+ &qw_size_abbrev, p_bin,
LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
if( NULL == pb_data ) { return 0x01; }
/* Get .debug_abbrev section Info */
pb_data = LibGoblin_Elf_GetSection(
- &qw_size_info, p_bin, 0,
+ &qw_size_info, p_bin,
LIBGOBLIN_SECTION_ID_DEBUG_INFO );
if( NULL == pb_data ) { return 0x01; }
/* Get .debug_abbrev section Info */
pb_data = LibGoblin_Elf_GetSection(
- &qw_size, p_bin, 0,
+ &qw_size, p_bin,
LIBGOBLIN_SECTION_ID_DEBUG_LINE );
if( NULL == pb_data ) { return 0x01; }
LibGoblin_Elf_GetSection(
QWord *qw_secsize,
LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid,
+ //int i_analyzefid,
Byte b_secid )
{
Byte *pb_data;
LibGoblin_SectionInfo *p_sectbl;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[ i_analyzefid ]);
+ p_bfile = p_binfo->p_binfile;
pb_data = NULL;
*qw_secsize = 0;
LIBGOBLIN_ELF_EXTERN
int
LibGoblin_Elf_ReadELF_Phase1(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
int i_result = 0x00;
- Byte *pb_data;
- LibGoblin_BinaryFile *p_bfile;
- LibGoblin_SymbolWorkTable t_symwork;
+ //Byte *pb_data;
+ //LibGoblin_BinaryFile *p_bfile;
+ //LibGoblin_SymbolWorkTable t_symwork;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[ i_analyzefid ]);
- pb_data = p_bfile->pb_binary;
- assert( NULL != pb_data );
+ //p_bfile = p_binfo->p_binfile;
+ //pb_data = p_bfile->pb_binary;
+ //assert( NULL != pb_data );
/* ReCheck ELF Header -------------------*/
- i_result = LibGoblin_CheckBinary( p_binfo, i_analyzefid );
+ i_result = LibGoblin_CheckBinary( p_binfo );
if( 0x00 != i_result ) {
return i_result;
}
/* Analyze ELF Basical Struct & data -----*/
if( LIBGOBLIN_BINFO_TYPE_ELF64 == p_binfo->b_type ) {
- i_result = LibGoblin_Elf64_SetSectionInfo( p_binfo, i_analyzefid );
+ i_result = LibGoblin_Elf64_SetSectionInfo( p_binfo );
}
else if( LIBGOBLIN_BINFO_TYPE_ELF32 == p_binfo->b_type ) {
}
return -0x01;
}
- i_result = LibGoblin_Elf_DynVer_ReadDynamicSection( p_binfo, i_analyzefid );
+ i_result = LibGoblin_Elf_DynVer_ReadDynamicSection( p_binfo );
if( 0x00 > i_result ) {
return -0x02;
}
LIBGOBLIN_ELF_EXTERN
int
LibGoblin_Elf_ReadELF_Phase2(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
int i_result;
Byte *pb_data;
LibGoblin_SymbolWorkTable t_symwork;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[ i_analyzefid ]);
+ p_bfile = p_binfo->p_binfile;
pb_data = p_bfile->pb_binary;
assert( NULL != pb_data );
/* Create Symbol-Table ------------------*/
i_result = LibGoblin_Section_ReadSymtabSection_toWorkTable(
- p_binfo, i_analyzefid, &t_symwork );
+ p_binfo, &t_symwork );
if( 0x00 != i_result ) {
return i_result;
}
int LibGoblin_IsElf( Byte *p_data );
LIBGOBLIN_ELF_EXTERN
Byte *LibGoblin_Elf_GetSection(
- QWord *qw_secsize, LibGoblin_BinaryInfo *p_bin, int i_analyzefid, Byte b_secid );
+ QWord *qw_secsize, LibGoblin_BinaryInfo *p_bin, Byte b_secid );
LIBGOBLIN_ELF_EXTERN
- int LibGoblin_Elf_ReadELF_Phase1( LibGoblin_BinaryInfo *p_binfo, int i_analyzefid );
+ int LibGoblin_Elf_ReadELF_Phase1( LibGoblin_BinaryInfo *p_binfo );
LIBGOBLIN_ELF_EXTERN
- int LibGoblin_Elf_ReadELF_Phase2( LibGoblin_BinaryInfo *p_binfo, int i_analyzefid );
+ int LibGoblin_Elf_ReadELF_Phase2( LibGoblin_BinaryInfo *p_binfo );
#endif /* DRD64_HEADER_LIBGOBLIN_BINFO */
----------------------------------------------------------------------*/
int
LibGoblin_Elf64_SetSectionInfo(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
int i_cnt;
int i_globid;
LibGoblin_SectionInfo *p_globsec;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[i_analyzefid]);
+ p_bfile = p_binfo->p_binfile;
pb_data = p_bfile->pb_binary;
assert( NULL != pb_data );
p_globsec->pb_data = p_sectbl->pb_data;
p_globsec->pstr_secname = p_sectbl->pstr_secname;
p_globsec->qw_size = p_sectbl->qw_size;
- p_globsec->i_fid = i_analyzefid;
+ p_globsec->i_fid = 0; // XXX: i_analyzefid;
}
}
p_globsec->pb_data = p_sectbl->pb_data;
p_globsec->pstr_secname = p_sectbl->pstr_secname;
p_globsec->qw_size = p_sectbl->qw_size;
- p_globsec->i_fid = i_analyzefid;
+ p_globsec->i_fid = 0; // XXX: i_analyzefid;
}
return 0x00;
LIBGOBLIN_ELF64_EXTERN
int
LibGoblin_Elf64_Analyze(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
Byte *pb_data;
assert( NULL != p_binfo );
- pb_data = p_binfo->t_binfile[i_analyzefid].pb_binary;
+ pb_data = p_binfo->p_binfile->pb_binary;
assert( NULL != pb_data );
/* Read & Analyze Section Header */
- LibGoblin_Elf64_SetSectionInfo( p_binfo, i_analyzefid );
+ LibGoblin_Elf64_SetSectionInfo( p_binfo );
return 0x00;
}
LIBGOBLIN_ELF64_EXTERN
- int LibGoblin_Elf64_Analyze( LibGoblin_BinaryInfo *p_bin, int i_analyzefid );
+ int LibGoblin_Elf64_Analyze( LibGoblin_BinaryInfo *p_binfo );
LIBGOBLIN_ELF_DYNVER_EXTERN
int
LibGoblin_Elf_DynVer_ReadDynamicSection(
- LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid )
+ LibGoblin_BinaryInfo *p_binfo )
{
Byte *pb_data;
Byte *pb_dynstr;
LibGoblin_ProgramInfo *p_pginfo;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[i_analyzefid]);
+ p_bfile = p_binfo->p_binfile;
p_pginfo = (LibGoblin_ProgramInfo *)p_binfo->pv_pginfo;
// Read & Check SectionInfo ---
p_sec_dynamic = LibGoblin_Section_GetSectionInfo_fid(
- p_binfo, LIBGOBLIN_SECTION_ID_DYNAMIC, i_analyzefid );
+ p_binfo, LIBGOBLIN_SECTION_ID_DYNAMIC );
if( NULL == p_sec_dynamic ) {
return 0x01;
}
p_sec_dynstr = LibGoblin_Section_GetSectionInfo_fid(
- p_binfo, LIBGOBLIN_SECTION_ID_DYNSTR, i_analyzefid );
+ p_binfo, LIBGOBLIN_SECTION_ID_DYNSTR );
if( NULL == p_sec_dynstr ) {
return 0x02;
}
if( DT_NEEDED == qw_tag ) {
p_bintmp = LibGoblin_ProgInfo_AddBinaryInfo(
- p_pginfo, ((char *)(pb_dynstr + qw_value)), p_binfo->i_id );
+ p_pginfo, ((char *)(pb_dynstr + qw_value)), NULL, p_binfo->i_id );
}
else if( DT_RPATH == qw_tag ) {
LibGoblin_BinInfo_SetRPath( p_binfo, (const char *)(pb_dynstr + qw_value) );
LIBGOBLIN_ELF_DYNVER_EXTERN
int LibGoblin_Elf_DynVer_ReadDynamicSection(
- LibGoblin_BinaryInfo *p_binfo, int i_analyzefid );
+ LibGoblin_BinaryInfo *p_binfo );
#endif /* DRD64_HEADER_LIBGOBLIN_BINFO */
+++ /dev/null
-/*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
-
- D r . D e a m o n 6 4
- for INTEL64(R), AMD64(R)
-
- Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-OF THE POSSIBILITY OF SUCH DAMAGE.
-
-DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
-
-/* File Info -----------------------------------------------------------
-File: drd64_.c
-Function:
-Comment:
-----------------------------------------------------------------------*/
-
-#define DRD64_SRC_LIBGOBLIN_LIBRARYINFO
-#include"drd64_libgoblin.h"
-
-/*----------------------------------------------------------------------
-----------------------------------------------------------------------*/
-LIBGOBLIN_LIBRARYINFO_EXTERN
-LibGoblin_LibraryInfo *
- LibraryInfo_GetLibraryInfo(
- int i_libid )
-{
- if(( gi_max_library_info <= i_libid ) || ( 0 > i_libid ))
- { return NULL; }
-
- if( -0x01 == LIBINFO( i_libid )->i_id )
- { return NULL; }
-
- return LIBINFO( i_libid );
-}
-
-
-/*----------------------------------------------------------------------
-XXX
-----------------------------------------------------------------------*/
-/*
-LIBGOBLIN_LIBRARYINFO_EXTERN
-LibGoblin_BinaryInfo *
- LibGoblin_LibraryInfo_AddBinaryInfo(
- LibGoblin_LibraryInfo *p_pginfo,
- const char *pstr_binname,
- int i_req_bid )
-{
- int i_binfoid;
- int i_result;
- int i_cnt;
- LibGoblin_BinaryInfo *p_binfo = NULL;
-
- assert( NULL != p_pginfo );
-
- i_binfoid = p_pginfo->i_num_binfo;
- if( LIBGOBLIN_LIBRARYINFO_MAX_BINFO <= i_binfoid ) {
- return NULL;
- }
-
- // Check Alloced Same-Library ---
- for( i_cnt = 0; i_cnt < p_pginfo->i_num_binfo; i_cnt++ ) {
- if( !strncmp( (p_pginfo->p_binfo[ i_cnt ])->str_filename,
- pstr_binname, DRD64_MAX_PATH ) ) {
- return p_pginfo->p_binfo[ i_cnt ];
- }
- }
-
- // Alloc BinaryInfo ---
- p_binfo = LibGoblin_BinInfo_AllocBinInfo( p_pginfo );
- if( NULL == p_binfo ) {
- return NULL;
- }
-
- p_pginfo->p_binfo[ i_binfoid ] = p_binfo;
- p_pginfo->i_num_binfo++;
-
- i_result = LibGoblin_BinInfo_SetProgramName( p_binfo, pstr_binname, i_req_bid );
- if( 0x00 != i_result ) {
- LibGoblin_BinInfo_FreeBinInfo( p_binfo );
- // XXX - error check!
-
- return NULL;
- }
-
- return p_binfo;
-}
-*/
-
-
-/*----------------------------------------------------------------------
-OK
-----------------------------------------------------------------------*/
-void
- LibraryInfo_ClearLibraryInfo(
- LibGoblin_LibraryInfo *p_libinfo )
-{
- assert( NULL != p_libinfo );
-
- memset( p_libinfo, 0x00, sizeof( LibGoblin_LibraryInfo ) );
-
- p_libinfo->i_id = -0x01;
-
- return;
-}
-
-
-/*----------------------------------------------------------------------
-OK
-----------------------------------------------------------------------*/
-LIBGOBLIN_LIBRARYINFO_EXTERN
-LibGoblin_LibraryInfo *
- LibraryInfo_AllocLibraryInfo(
- void )
-{
- int i_cnt;
- int i_id_now = -0x01;
- LibGoblin_LibraryInfo *p_libinfo = NULL;
- LibGoblin_LibraryInfo *p_libbase;
-
- if( gi_now_library_info < gi_max_library_info ) {
- // Search Non-Used & Alloced LibraryInfo struct.
- for( i_cnt = 0; i_cnt < gi_max_library_info; i_cnt++ ) {
- if( -0x01 == LIBINFO( i_cnt )->i_id ) {
- p_libinfo = LIBINFO( i_cnt );
- i_id_now = i_cnt;
- goto goto_LibraryInfo_AllocLibraryInfo_dataset;
- }
- }
-
- // Bug -- Not Exist Non-used LibraryInfo struct.
- goto goto_LibraryInfo_AllocLibraryInfo_post;
- }
-
- if( gi_now_library_info == gi_alloc_library_info ) {
- p_libbase = (LibGoblin_LibraryInfo *)realloc( gp_library_info,
- sizeof( LibGoblin_LibraryInfo ) *
- ( gi_alloc_library_info + LIBGOBLIN_LIBRARYINFO_UNITS ) );
- if( NULL == p_libbase ) {
- goto goto_LibraryInfo_AllocLibraryInfo_post;
- }
-
- gp_library_info = p_libbase;
- gi_alloc_library_info += LIBGOBLIN_LIBRARYINFO_UNITS;
- }
-
- i_id_now = gi_now_library_info;
-
-goto_LibraryInfo_AllocLibraryInfo_dataset:
- if( i_id_now == gi_max_library_info ) { gi_max_library_info++; }
- p_libinfo = LIBINFO( i_id_now );
- p_libinfo->i_id = i_id_now;
- gi_now_library_info++;
-
-goto_LibraryInfo_AllocLibraryInfo_post:
- return p_libinfo;
-}
-
-
-
-/*----------------------------------------------------------------------
-OK
-----------------------------------------------------------------------*/
-LIBGOBLIN_LIBRARYINFO_EXTERN
-int
- LibraryInfo_FreeLibraryInfo(
- LibGoblin_LibraryInfo *p_libinfo )
-{
- int i_id;
-
- assert( NULL != p_libinfo );
-
- if( -0x01 == p_libinfo->i_id ) { return 0x00; }
-
- i_id = p_libinfo->i_id;
- LibraryInfo_ClearLibraryInfo( p_libinfo );
-
- if( gi_max_library_info == (i_id + 1) )
- { gi_max_library_info--; }
-
- gi_now_library_info--;
- if( 0 == gi_now_library_info ) { gi_max_library_info = 0; }
-
- return 0x00;
-}
-
-
-/*----------------------------------------------------------------------
-OK
-----------------------------------------------------------------------*/
-LIBGOBLIN_LIBRARYINFO_EXTERN
-int
- LibraryInfo_Init(
- void )
-{
- int i_cnt;
- LibGoblin_LibraryInfo *p_libinfo;
-
- if( 0 != gi_max_library_info ) {
- return -0x01;
- }
-
- gp_library_info = (LibGoblin_LibraryInfo *)malloc(
- sizeof( LibGoblin_LibraryInfo ) * LIBGOBLIN_LIBRARYINFO_UNITS );
- if( NULL == gp_library_info ) {
- return -0x02;
- }
-
- for( i_cnt = 0; i_cnt < LIBGOBLIN_LIBRARYINFO_UNITS; i_cnt++ ) {
- p_libinfo = LIBINFO( i_cnt );
- LibraryInfo_ClearLibraryInfo( p_libinfo );
- }
-
- gi_alloc_library_info = LIBGOBLIN_LIBRARYINFO_UNITS;
- gi_max_library_info = 0;
- gi_now_library_info = 0;
-
- return 0x00;
-}
-
-
-/*----------------------------------------------------------------------
-OK
-----------------------------------------------------------------------*/
-LIBGOBLIN_LIBRARYINFO_EXTERN
-int
- LibraryInfo_Term(
- void )
-{
- LibGoblin_LibraryInfo *p_libinfo;
-
- if( 0 < gi_now_library_info ) {
- for( ; gi_max_library_info > 0; gi_max_library_info-- ) {
- p_libinfo = LIBINFO( gi_max_library_info - 1 );
- LibraryInfo_FreeLibraryInfo( p_libinfo );
- }
- }
-
- free( gp_library_info );
-
- gp_library_info = NULL;
- gi_alloc_library_info = 0;
- gi_max_library_info = 0;
- gi_now_library_info = 0;
-
- return 0x00;
-}
-
-
-/* EOF of drd64_.c ----------------------------------- */
return -0x02;
}
- i_result = LibGoblin_ReadBinary_File( p_binfo, NULL, LIBGOBLIN_BINFO_FILE_EXEC );
+ i_result = LibGoblin_ReadBinary_File( p_binfo, NULL );
if( 0x00 != i_result ) {
return -0x03;
}
- p_bfile = NULL;
- p_bfile = &(p_binfo->t_binfile[LIBGOBLIN_BINFO_FILE_EXEC]);
+ p_bfile = p_binfo->p_binfile;
if( 0x00 == (DRD64_LIBFILETYPE_SUB_ELF & p_bfile->t_ftype.w_subtype) ) {
return -0x04;
}
- i_result = LibGoblin_Elf_ReadELF_Phase1( p_binfo, LIBGOBLIN_BINFO_FILE_EXEC );
+ //i_result = LibGoblin_Elf_ReadELF_Phase1( p_binfo, LIBGOBLIN_BINFO_FILE_EXEC );
+ i_result = LibGoblin_Elf_ReadELF_Phase1( p_binfo );
if( 0x00 != i_result ) {
return -0x05;
}
{
int i_result;
LibGoblin_ProgramInfo *p_pginfo;
- LibGoblin_BinaryInfo *p_binfo;
p_pginfo = LibGoblin_ProgInfo_GetProgInfo( i_pgid );
if( NULL == p_pginfo ) {
LibGoblin_LibraryFileList *p_libflist )
{
int i_result;
+ char *pstr_temp;
char *pstr_progfile;
+ char *pstr_path;
LibGoblin_ProgramInfo *p_pginfo;
LibGoblin_BinaryInfo *p_binfo;
p_libflist->i_start = 0;
p_libflist->i_end = 1;
- pstr_progfile = basename( pstr_progpath );
+ // XXX
+ pstr_temp = alloca( DRD64_MAX_PATH + 1);
+ strncpy( pstr_temp, pstr_progpath, DRD64_MAX_PATH );
+ pstr_progfile = basename( pstr_temp );
+
+ pstr_temp = alloca( DRD64_MAX_PATH + 1);
+ strncpy( pstr_temp, pstr_progpath, DRD64_MAX_PATH );
+ pstr_path = basename( pstr_temp );
- p_binfo = LibGoblin_ProgInfo_AddBinaryInfo( p_pginfo, pstr_progfile, 0 );
+ p_binfo = LibGoblin_ProgInfo_AddBinaryInfo( p_pginfo, pstr_progfile, pstr_path, 0 );
if( NULL == p_binfo ) {
return -0x01;
}
LibGoblin_BinaryInfo *
LibGoblin_ProgInfo_AddBinaryInfo(
LibGoblin_ProgramInfo *p_pginfo,
- const char *pstr_binname,
+ const char *pstr_binfilename,
+ const char *pstr_binpath,
int i_req_bid )
{
int i_binfoid;
// Check Alloced Same-Library ---
for( i_cnt = 0; i_cnt < p_pginfo->i_num_binfo; i_cnt++ ) {
if( !strncmp( (p_pginfo->p_binfo[ i_cnt ])->str_filename,
- pstr_binname, DRD64_MAX_PATH ) ) {
+ pstr_binfilename, DRD64_MAX_PATH ) ) {
return p_pginfo->p_binfo[ i_cnt ];
}
}
// Alloc BinaryInfo ---
- p_binfo = LibGoblin_BinInfo_AllocBinInfo( p_pginfo );
+ p_binfo = LibGoblin_BinInfo_AllocBinInfo( p_pginfo, pstr_binfilename, pstr_binpath );
if( NULL == p_binfo ) {
return NULL;
}
p_pginfo->p_binfo[ i_binfoid ] = p_binfo;
p_pginfo->i_num_binfo++;
- i_result = LibGoblin_BinInfo_SetProgramName( p_binfo, pstr_binname, i_req_bid );
+ i_result = LibGoblin_BinInfo_SetProgramName( p_binfo, pstr_binfilename, i_req_bid );
if( 0x00 != i_result ) {
LibGoblin_BinInfo_FreeBinInfo( p_binfo );
// XXX - error check!
int LibGoblin_ProgInfo_GetBinaryInfos( LibGoblin_ProgramInfo *p_pginfo );
LIBGOBLIN_PROGINFO_EXTERN
LibGoblin_BinaryInfo *LibGoblin_ProgInfo_AddBinaryInfo(
- LibGoblin_ProgramInfo *p_pginfo, const char *pstr_binname, int i_req_bid );
+ LibGoblin_ProgramInfo *p_pginfo, const char *pstr_binfilename, const char *pstr_binpath, int i_req_bid );
LIBGOBLIN_PROGINFO_EXTERN
LibGoblin_ProgramInfo *LibGoblin_ProgInfo_AllocProgInfo( void );
LIBGOBLIN_PROGINFO_EXTERN
int
LibGoblin_ReadBinary_File(
LibGoblin_BinaryInfo *p_binfo,
- const char *pstr_filepath,
- int i_filetype )
+ const char *pstr_filepath )
{
int i_result = 0x00;
int i_err;
LibGoblin_BinaryFile *p_bfile;
assert( NULL != p_binfo );
+ p_bfile = p_binfo->p_binfile;
+ assert( NULL != p_bfile );
if( NULL == pstr_filepath ) {
if ( LIBGOBLIN_BINFO_PHASE_SETPROG != p_binfo->b_phase ) {
return -0x01;
}
- pstr_binfile = p_binfo->t_binfile[i_filetype].str_filepath;
+ pstr_binfile = p_bfile->str_path;
if( '\0' == pstr_binfile ) {
return -0x02;
}
/* XXX : check i_filetype value */
- p_bfile = &(p_binfo->t_binfile[ i_filetype ]);
+ //p_bfile = &(p_binfo->t_binfile[ i_filetype ]);
/* Memory Mapping from Binary-file */
pb_head = mmap( NULL, t_ftype.dw_filesize, PROT_READ, MAP_SHARED, i_fd, 0 );
p_bfile->dw_flag = LIBGOBLIN_BINFO_FILE_MMAP;
p_binfo->b_phase = LIBGOBLIN_BINFO_PHASE_BINREAD;
if( NULL != pstr_filepath )
- { strncpy( p_bfile->str_filepath, pstr_binfile, DRD64_MAX_PATH ); }
+ { strncpy( p_bfile->str_path, pstr_binfile, DRD64_MAX_PATH ); }
//i_result = LibGoblin_AnalyzeBinary( p_binfo, i_filetype );
LibGoblin_ReadBinary_Memory(
LibGoblin_BinaryInfo *p_binfo,
Byte *pb_data,
- DWord dw_size,
- int i_filetype )
+ DWord dw_size )
{
int i_result;
LibGoblin_BinaryFile *p_bfile;
return -0x01;
}
- p_bfile = &(p_binfo->t_binfile[ i_filetype ]);
+ p_bfile = p_binfo->p_binfile;
+ assert( NULL != p_bfile );
memcpy( (void *)&(p_bfile->t_ftype), (void *)&t_ftype, sizeof( LibFileType_FileType ));
p_bfile->pb_binary = pb_data;
}
for( i_cnt = 0; i_cnt < LIBGOBLIN_BINFO_MAXFILES; i_cnt++ ) {
- p_bfile = &(p_binfo->t_binfile[ i_cnt ]);
+ p_bfile = p_binfo->p_binfile;
if( -0x01 == p_bfile->i_fd ) { continue; }
LIBGOBLIN_READBIN_EXTERN
int LibGoblin_ReadBinary_File(
- LibGoblin_BinaryInfo *p_binfo, const char *pstr_filepath, int i_filetype );
+ LibGoblin_BinaryInfo *p_binfo, const char *pstr_filepath );
LIBGOBLIN_READBIN_EXTERN
int LibGoblin_ReadBinary_Memory(
- LibGoblin_BinaryInfo *p_binfo, Byte *pb_data, DWord dw_size, int i_filetype );
+ LibGoblin_BinaryInfo *p_binfo, Byte *pb_data, DWord dw_size );
LIBGOBLIN_READBIN_EXTERN
int LibGoblin_ReadBinary_FreeBinary( LibGoblin_BinaryInfo *p_binfo );
LibGoblin_SectionInfo *
LibGoblin_Section_GetSectionInfo_fid(
LibGoblin_BinaryInfo *p_binfo,
- Byte b_secid,
- int i_analyzefid )
+ Byte b_secid )
{
LibGoblin_BinaryFile *p_bfile;
LibGoblin_SectionInfo *p_secinfo;
assert( NULL != p_binfo );
- p_bfile = &(p_binfo->t_binfile[ i_analyzefid ]);
+ p_bfile = p_binfo->p_binfile;
if( LIBGOBLIN_SECTION_ID_MAX <= b_secid ) { return NULL; }
Word
LibGoblin_Section_GetSectionID_fromSectionNumber_inElf(
LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid,
Word w_secnumber )
{
Byte b_secid;
return w_secnumber;
}
- p_bfile = &(p_binfo->t_binfile[i_analyzefid]);
+ p_bfile = p_binfo->p_binfile;
for( b_secid = 0; b_secid < LIBGOBLIN_SECTION_ID_MAX; b_secid++ ) {
p_secinfo = &(p_bfile->t_section[ b_secid ]);
int
LibGoblin_Section_ReadSymtabSection_toWorkTable(
LibGoblin_BinaryInfo *p_binfo,
- int i_analyzefid,
LibGoblin_SymbolWorkTable *p_symwork )
{
Byte *pb_symtab;
// Check BinaryInfo & Get SymbolEntires
p_secinfo = LibGoblin_Section_GetSectionInfo_fid(
- p_binfo, LIBGOBLIN_SECTION_ID_SYMTAB, i_analyzefid );
+ p_binfo, LIBGOBLIN_SECTION_ID_SYMTAB );
if( NULL == p_secinfo ) {
return -0x01;
}
char *LibGoblin_Section_GetSectionName( LibGoblin_BinaryInfo *p_binfo, Byte b_secid );
LIBGOBLIN_SECTION_EXTERN
LibGoblin_SectionInfo *LibGoblin_Section_GetSectionInfo_fid(
- LibGoblin_BinaryInfo *p_binfo, Byte b_secid, int i_analyzefid );
+ LibGoblin_BinaryInfo *p_binfo, Byte b_secid );
LIBGOBLIN_SECTION_EXTERN
LibGoblin_SectionInfo *LibGoblin_Section_GetSectionInfo(
LibGoblin_BinaryInfo *p_binfo, Byte b_secid );
LIBGOBLIN_SECTION_EXTERN
LibGoblin_SectionInfo *LibGoblin_Section_GetSectionInfo_fid(
- LibGoblin_BinaryInfo *p_binfo, Byte b_secid, int i_analyzefid );
+ LibGoblin_BinaryInfo *p_binfo, Byte b_secid );
LIBGOBLIN_SECTION_EXTERN
Word LibGoblin_Section_GetSectionID_fromSectionNumber_inElf(
- LibGoblin_BinaryInfo *p_binfo, int i_analyzefid, Word w_secnumber );
+ LibGoblin_BinaryInfo *p_binfo, Word w_secnumber );
LIBGOBLIN_SECTION_EXTERN
int LibGoblin_Section_ReadSymtabSection_toWorkTable(
- LibGoblin_BinaryInfo *p_binfo, int i_analyzefid,
+ LibGoblin_BinaryInfo *p_binfo,
LibGoblin_SymbolWorkTable *p_symwork );
#define LIBGOBLIN_BINFO_SECTION_DATA 0x01
#define LIBGOBLIN_BINFO_SECTION_BSS 0x02
-#define LIBGOBLIN_BINFO_PHASE_INIT 0x00
-#define LIBGOBLIN_BINFO_PHASE_ALLOCED 0x10
-#define LIBGOBLIN_BINFO_PHASE_SETNAME 0x20
-#define LIBGOBLIN_BINFO_PHASE_SETPROG 0x30
-#define LIBGOBLIN_BINFO_PHASE_BINREAD 0x40
-#define LIBGOBLIN_BINFO_PHASE_ANALYZED 0x50
-
-#define LIBGOBLIN_BINFO_MAXFILES 3
-#define LIBGOBLIN_BINFO_FILE_EXEC 0
-#define LIBGOBLIN_BINFO_FILE_CORE 1
-#define LIBGOBLIN_BINFO_FILE_DEBUG 2
#define LIBGOBLIN_BINFO_FILE_MMAP (DWord)0x01
#define LIBGOBLIN_BINFO_FILE_EXTALLOC (DWord)0x02
/*=====================================================================*/
+/*
typedef struct {
int i_id;
char str_libfilepath[DRD64_MAX_PATH];
char str_rpath[DRD64_MAX_PATH];
void *p_nextlib;
} LibGoblin_LibraryInfo;
-
+*/
/*=====================================================================*/
typedef struct {
+ int i_id;
+ int i_refcount;
+
/* Binary-File Info. */
int i_fd;
DWord dw_flag;
- char str_filepath[DRD64_MAX_PATH];
+ char str_filename[DRD64_MAX_PATH];
+ char str_path[DRD64_MAX_PATH];
+ char str_rpath[DRD64_MAX_PATH]; // .dyn Section rpath
LibFileType_FileType t_ftype;
/* Binary-File Memory Image Access Info. */
/*=====================================================================*/
+#define LIBGOBLIN_BINFO_PHASE_INIT 0x00
+#define LIBGOBLIN_BINFO_PHASE_ALLOCED 0x10
+#define LIBGOBLIN_BINFO_PHASE_SETNAME 0x20
+#define LIBGOBLIN_BINFO_PHASE_SETPROG 0x30
+#define LIBGOBLIN_BINFO_PHASE_BINREAD 0x40
+#define LIBGOBLIN_BINFO_PHASE_ANALYZED 0x50
+
+#define LIBGOBLIN_BINFO_MAXFILES 3
+#define LIBGOBLIN_BINFO_FILE_EXEC 0
+#define LIBGOBLIN_BINFO_FILE_CORE 1
+#define LIBGOBLIN_BINFO_FILE_DEBUG 2
+
typedef struct {
/* BinaryInfo Struct ID */
int i_id;
/* Exec. File Info. */
char str_filename[DRD64_MAX_PATH];
char str_path[DRD64_MAX_PATH];
- char str_rpath[DRD64_MAX_PATH];
+ char str_rpath[DRD64_MAX_PATH]; // .dynamic Section - rpath (.so location path)
int i_req_bid;
- LibGoblin_BinaryFile t_binfile[3];
+ LibGoblin_BinaryFile *p_binfile;
/* Binary-Format Depending Info. (ELF)*/
//void *p_format;
LibGoblin_SectionInfo t_section[LIBGOBLIN_SECTION_ID_MAX];
void *pv_pginfo;
+ void *pv_lib_binfile_next; // NEW
} LibGoblin_BinaryInfo;
int i_num_binfo;
LibGoblin_BinaryInfo *p_binfo[LIBGOBLIN_PROGINFO_MAX_BINFO];
+ LibGoblin_BinaryInfo *p_binfo_core; // NEW
+ LibGoblin_BinaryInfo *p_binfo_debug; // NEW
int i_opened_bid;
- LibGoblin_LibraryInfo *p_libinfo;
// Working Area
LibGoblin_LibraryFileList t_libflist;
Test_LibGoblin_System();
Test_LibGoblin_BinInfo();
Test_LibGoblin_ProgInfo();
- Test_LibGoblin_LibraryInfo();
+ Test_LibGoblin_BinaryFile();
Test_LibGoblin_ReadBinary();
Test_LibGoblin_SymWork();
Test_LibGoblin_LoadProg();
#endif
DRD64_TEST_LIBGOBLIN_PROGINFO_EXTERN int Test_LibGoblin_ProgInfo( void );
-#ifdef DRD64_SRC_TEST_LIBGOBLIN_LIBRARYINFO
- #define DRD64_TEST_LIBGOBLIN_LIBRARYINFO_EXTERN
+#ifdef DRD64_SRC_TEST_LIBGOBLIN_BINARYFILE
+ #define DRD64_TEST_LIBGOBLIN_BINARYFILE_EXTERN
#else
- #define DRD64_TEST_LIBGOBLIN_LIBRARYINFO_EXTERN extern
+ #define DRD64_TEST_LIBGOBLIN_BINARYFILE_EXTERN extern
#endif
-DRD64_TEST_LIBGOBLIN_LIBRARYINFO_EXTERN int Test_LibGoblin_LibraryInfo( void );
+DRD64_TEST_LIBGOBLIN_BINARYFILE_EXTERN int Test_LibGoblin_BinaryFile( void );
#ifdef DRD64_SRC_TEST_LIBGOBLIN_READBINARY
#define DRD64_TEST_LIBGOBLIN_READBINARY_EXTERN
Comment:
----------------------------------------------------------------------*/
-#define DRD64_SRC_TEST_LIBGOBLIN_PROGINFO
+#define DRD64_SRC_TEST_LIBGOBLIN_BINARYFILE
#include"drd64_libgoblin.h"
#include"test_libgoblin.h"
-/* LibraryInfo_AllocLibraryInfo() & FreeLibraryInfo() *****************/
+/* BinaryFile_AllocBinaryFile() & FreeBinaryFile() *****************/
/*--------------------------------------------------------------------*/
-void Test_LibraryInfo_AllocFree_test00_001( void )
+void Test_BinaryFile_AllocFree_test00_001( void )
{
int i_result;
- LibGoblin_LibraryInfo *p_libinfo;
+ LibGoblin_BinaryFile *p_binfile;
- i_result = LibraryInfo_Init();
+ i_result = BinaryFile_Init();
CU_ASSERT( 0x00 == i_result );
- p_libinfo = LibraryInfo_AllocLibraryInfo();
- CU_ASSERT( NULL != p_libinfo );
+ p_binfile = BinaryFile_AllocBinaryFile();
+ CU_ASSERT( NULL != p_binfile );
- i_result = LibraryInfo_FreeLibraryInfo( p_libinfo );
+ i_result = BinaryFile_FreeBinaryFile( p_binfile );
CU_ASSERT( 0x00 == i_result );
- i_result = LibraryInfo_Term();
+ i_result = BinaryFile_Term();
CU_ASSERT( 0x00 == i_result );
return;
/*--------------------------------------------------------------------*/
-void Test_LibraryInfo_AllocFree_test00_002( void )
+void Test_BinaryFile_AllocFree_test00_002( void )
{
int i_cnt;
int i_result;
- LibGoblin_LibraryInfo *p_libinfo;
+ LibGoblin_BinaryFile *p_binfile;
- i_result = LibraryInfo_Init();
+ i_result = BinaryFile_Init();
CU_ASSERT( 0x00 == i_result );
for( i_cnt = 0; i_cnt < 128; i_cnt++ ) {
- p_libinfo = LibraryInfo_AllocLibraryInfo();
- CU_ASSERT( NULL != p_libinfo );
- CU_ASSERT( i_cnt == p_libinfo->i_id );
+ p_binfile = BinaryFile_AllocBinaryFile();
+ CU_ASSERT( NULL != p_binfile );
+ CU_ASSERT( i_cnt == p_binfile->i_id );
}
for( i_cnt = 0; i_cnt < 128; i_cnt += 8 ) {
- p_libinfo = NULL;
- p_libinfo = LibraryInfo_GetLibraryInfo( i_cnt );
- CU_ASSERT( NULL != p_libinfo );
+ p_binfile = NULL;
+ p_binfile = BinaryFile_GetBinaryFile( i_cnt );
+ CU_ASSERT( NULL != p_binfile );
- i_result = LibraryInfo_FreeLibraryInfo( p_libinfo );
+ i_result = BinaryFile_FreeBinaryFile( p_binfile );
CU_ASSERT( 0x00 == i_result );
}
for( i_cnt = 0; i_cnt < 16; i_cnt++ ) {
- p_libinfo = NULL;
- p_libinfo = LibraryInfo_AllocLibraryInfo();
- CU_ASSERT( NULL != p_libinfo );
- CU_ASSERT( (i_cnt * 8) == p_libinfo->i_id );
+ p_binfile = NULL;
+ p_binfile = BinaryFile_AllocBinaryFile();
+ CU_ASSERT( NULL != p_binfile );
+ CU_ASSERT( (i_cnt * 8) == p_binfile->i_id );
}
for( i_cnt = 0; i_cnt < 128; i_cnt++ ) {
- p_libinfo = NULL;
- p_libinfo = LibraryInfo_GetLibraryInfo( i_cnt );
- CU_ASSERT( NULL != p_libinfo );
+ p_binfile = NULL;
+ p_binfile = BinaryFile_GetBinaryFile( i_cnt );
+ CU_ASSERT( NULL != p_binfile );
- i_result = LibraryInfo_FreeLibraryInfo( p_libinfo );
+ i_result = BinaryFile_FreeBinaryFile( p_binfile );
CU_ASSERT( 0x00 == i_result );
}
- p_libinfo = LibraryInfo_GetLibraryInfo( 0 );
- CU_ASSERT( NULL == p_libinfo );
+ p_binfile = BinaryFile_GetBinaryFile( 0 );
+ CU_ASSERT( NULL == p_binfile );
- i_result = LibraryInfo_Term();
+ i_result = BinaryFile_Term();
CU_ASSERT( 0x00 == i_result );
return;
}
-/* LibraryInfo_Init() & Term() ****************************************/
+/* BinaryFile_Init() & Term() ****************************************/
/*--------------------------------------------------------------------*/
-void Test_LibraryInfo_InitTerm_test00_001( void )
+void Test_BinaryFile_InitTerm_test00_001( void )
{
int i_result;
- i_result = LibraryInfo_Init();
+ i_result = BinaryFile_Init();
CU_ASSERT( 0x00 == i_result );
- i_result = LibraryInfo_Term();
+ i_result = BinaryFile_Term();
CU_ASSERT( 0x00 == i_result );
return;
/*----------------------------------------------------------------------
----------------------------------------------------------------------*/
-DRD64_TEST_LIBGOBLIN_LIBRARYINFO_EXTERN
+DRD64_TEST_LIBGOBLIN_BINARYFILE_EXTERN
int
- Test_LibGoblin_LibraryInfo(
+ Test_LibGoblin_BinaryFile(
void )
{
CU_pSuite pt_goblin;
- pt_goblin = CU_add_suite( "LibGoblin_LibraryInfo", NULL, NULL );
+ pt_goblin = CU_add_suite( "LibGoblin_BinaryFile", NULL, NULL );
- CU_add_test( pt_goblin, "LibraryInfo_InitTerm_test00_001",
- Test_LibraryInfo_InitTerm_test00_001 );
- CU_add_test( pt_goblin, "LibraryInfo_AllocFree_test00_001",
- Test_LibraryInfo_AllocFree_test00_001 );
- CU_add_test( pt_goblin, "LibraryInfo_AllocFree_test00_002",
- Test_LibraryInfo_AllocFree_test00_002 );
+ CU_add_test( pt_goblin, "BinaryFile_InitTerm_test00_001",
+ Test_BinaryFile_InitTerm_test00_001 );
+ CU_add_test( pt_goblin, "BinaryFile_AllocFree_test00_001",
+ Test_BinaryFile_AllocFree_test00_001 );
+ CU_add_test( pt_goblin, "BinaryFile_AllocFree_test00_002",
+ Test_BinaryFile_AllocFree_test00_002 );
return 0x00;
/* LibGoblin_BinInfo_AllocBinInfo() & FreeBinInfo() *******************/
/*--------------------------------------------------------------------*/
+/*
void Test_LibGoblin_BinInfo_AllocFree_test00_001( void )
{
int i_bid;
return;
}
-
+*/
/*--------------------------------------------------------------------*/
+/*
void Test_LibGoblin_BinInfo_AllocFree_test00_002( void )
{
int i_cnt;
return;
}
+*/
/* LibGoblin_BinInfo_Init() & Term() **********************************/
CU_pSuite pt_goblin;
pt_goblin = CU_add_suite( "LibGoblin_BinInfo", NULL, NULL );
-
CU_add_test( pt_goblin, "LibGoblin_BinInfo_InitTerm_test00_001",
Test_LibGoblin_BinInfo_InitTerm_test00_001 );
+/*
CU_add_test( pt_goblin, "LibGoblin_BinInfo_AllocFree_test00_001",
Test_LibGoblin_BinInfo_AllocFree_test00_001 );
CU_add_test( pt_goblin, "LibGoblin_BinInfo_AllocFree_test00_002",
Test_LibGoblin_BinInfo_AllocFree_test00_002 );
+*/
return 0x00;
i_result = LibGoblin_Init();
CU_ASSERT( 0x00 == i_result );
- i_binfoid = LibGoblin_AllocBinInfo( -1 );
+ i_binfoid = LibGoblin_AllocBinInfo( -1, "dwarftest", "../testdata/" );
CU_ASSERT( 0x00 == i_binfoid );
p_binfo = LibGoblin_BinInfo_GetBinInfo( i_binfoid );
CU_ASSERT( NULL != p_binfo );
i_result = LibGoblin_ReadBinary_File( p_binfo,
- "../testdata/dwarftest", LIBGOBLIN_BINFO_FILE_EXEC );
+ "../testdata/dwarftest" );
CU_ASSERT( 0x00 == i_result );
i_result = LibGoblin_Debug_Elf_PrintSectionTable( p_binfo, 0xff );
i_result = LibGoblin_Init();
CU_ASSERT( 0x00 == i_result );
- i_binfoid = LibGoblin_AllocBinInfo( -1 );
+ i_binfoid = LibGoblin_AllocBinInfo( -1, "dwarftest", "../testdata/" );
CU_ASSERT( 0x00 == i_binfoid );
p_binfo = LibGoblin_BinInfo_GetBinInfo( i_binfoid );
i_result = LibGoblin_BinInfo_SetProgramPath( p_binfo,
"../testdata/dwarftest", "../testdata/dwarftest" );
- i_result = LibGoblin_ReadBinary_File( p_binfo, NULL, LIBGOBLIN_BINFO_FILE_EXEC );
+ i_result = LibGoblin_ReadBinary_File( p_binfo, NULL );
CU_ASSERT( 0x00 == i_result );
i_result = LibGoblin_ReadBinary_FreeBinary( p_binfo );
i_result = LibGoblin_Init();
CU_ASSERT( 0x00 == i_result );
- i_binfoid = LibGoblin_AllocBinInfo( -1 );
+ i_binfoid = LibGoblin_AllocBinInfo( -1, "dwarftest", "../testdata/" );
CU_ASSERT( 0x00 == i_binfoid );
p_binfo = LibGoblin_BinInfo_GetBinInfo( i_binfoid );
sz_read = read( i_fd, pb_data, t_sb.st_size );
CU_ASSERT( sz_read == t_sb.st_size );
- i_result = LibGoblin_ReadBinary_Memory( p_binfo, pb_data,
- t_sb.st_size, LIBGOBLIN_BINFO_FILE_EXEC );
+ i_result = LibGoblin_ReadBinary_Memory( p_binfo, pb_data, t_sb.st_size );
CU_ASSERT( 0x00 == i_result );
i_result = LibGoblin_ReadBinary_FreeBinary( p_binfo );
#
## TESTPG_HEADER =
+#FLAGS_LINKER = -L. -lm -Xlinker -rpath -Xlinker .. -Xlinker -rpath -Xlinker .
FLAGS_LINKER = -L. -lm -Xlinker -rpath -Xlinker .
TESTPG02_TARGET_FULL = dwarftest
OSDN Git Service
