int main( int argc, char * const argv[] )
#endif
{
#if !defined( HAVE_GLOB_H )
libcsystem_glob_t *glob = NULL;
#endif
libcerror_error_t *error = NULL;
libcstring_system_character_t * const *source_filenames = NULL;
libcstring_system_character_t **ewf_filenames = NULL;
libcstring_system_character_t *option_header_codepage = NULL;
libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfdebug" );
libcstring_system_integer_t option = 0;
size_t first_filename_length = 0;
uint8_t verbose = 0;
int number_of_filenames = 0;
int header_codepage = LIBEWF_CODEPAGE_ASCII;
int result = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"ewftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "A:hqvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'A':
option_header_codepage = optarg;
break;
case (libcstring_system_integer_t) 'h':
ewfoutput_version_fprint(
stdout,
program );
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'q':
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
ewfoutput_version_fprint(
stdout,
program );
ewfoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
ewfoutput_version_fprint(
stdout,
program );
fprintf(
stderr,
"Missing EWF image file(s).\n" );
usage_fprint(
stdout );
goto on_error;
}
ewfoutput_version_fprint(
stdout,
program );
libcnotify_verbose_set(
verbose );
#if !defined( HAVE_LOCAL_LIBEWF )
libewf_notify_set_verbose(
verbose );
libewf_notify_set_stream(
stderr,
NULL );
#endif
if( option_header_codepage != NULL )
{
if( ewfinput_determine_header_codepage(
option_header_codepage,
&header_codepage,
&error ) != 1 )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
fprintf(
stderr,
"Unsupported header codepage defaulting to: ascii.\n" );
header_codepage = LIBEWF_CODEPAGE_ASCII;
}
}
if( libcsystem_signal_attach(
ewfdebug_signal_handler,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to attach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_initialize(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize glob.\n" );
goto on_error;
}
if( libcsystem_glob_resolve(
glob,
&( argv[ optind ] ),
argc - optind,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to resolve glob.\n" );
goto on_error;
}
source_filenames = glob->result;
number_of_filenames = glob->number_of_results;
#else
source_filenames = &( argv[ optind ] );
number_of_filenames = argc - optind;
#endif
if( number_of_filenames == 1 )
{
first_filename_length = libcstring_system_string_length(
source_filenames[ 0 ] );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
source_filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&ewf_filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
source_filenames[ 0 ],
first_filename_length,
LIBEWF_FORMAT_UNKNOWN,
&ewf_filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to resolve ewf file(s).\n" );
goto on_error;
}
source_filenames = (libcstring_system_character_t * const *) ewf_filenames;
}
if( libewf_handle_initialize(
&ewfdebug_input_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize input handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libewf_handle_open_wide(
ewfdebug_input_handle,
source_filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error );
#else
result = libewf_handle_open(
ewfdebug_input_handle,
source_filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error );
#endif
#if !defined( HAVE_GLOB_H )
if( libcsystem_glob_free(
&glob,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
#endif
if( ewf_filenames != NULL )
{
for( ; number_of_filenames > 0; number_of_filenames-- )
{
memory_free(
ewf_filenames[ number_of_filenames - 1 ] );
}
memory_free(
ewf_filenames );
}
if( ( ewfdebug_abort == 0 )
&& ( result != 1 ) )
{
fprintf(
stderr,
"Unable to open EWF file(s).\n" );
libewf_handle_close(
ewfdebug_input_handle,
NULL );
libewf_handle_free(
&ewfdebug_input_handle,
NULL );
return( EXIT_FAILURE );
}
/* TODO */
if( libewf_handle_close(
ewfdebug_input_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close EWF file(s).\n" );
libewf_handle_free(
&ewfdebug_input_handle,
NULL );
return( EXIT_FAILURE );
}
if( libewf_handle_free(
&ewfdebug_input_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free input handle.\n" );
return( EXIT_FAILURE );
}
if( libcsystem_signal_detach(
&error ) != 1 )
{
fprintf(
stderr,
"Unable to detach signal handler.\n" );
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( ewfdebug_abort != 0 )
{
fprintf(
stdout,
"%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n",
program );
return( EXIT_FAILURE );
}
fprintf(
stdout,
"Debug completed.\n" );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if !defined( HAVE_GLOB_H )
if( glob != NULL )
{
libcsystem_glob_free(
&glob,
NULL );
}
#endif
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libfsntfs_error_t *error = NULL;
libcstring_system_character_t *option_mft_entry_index = NULL;
libcstring_system_character_t *option_volume_offset = NULL;
libcstring_system_character_t *source = NULL;
char *program = "fsntfsinfo";
libcstring_system_integer_t option = 0;
size_t string_length = 0;
uint64_t mft_entry_index = 0;
int option_mode = FSNTFSINFO_MODE_VOLUME;
int verbose = 0;
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"fsntfstools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( libcsystem_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize system values.\n" );
goto on_error;
}
fsntfsoutput_version_fprint(
stdout,
program );
while( ( option = libcsystem_getopt(
argc,
argv,
_LIBCSTRING_SYSTEM_STRING( "E:hHo:UvV" ) ) ) != (libcstring_system_integer_t) -1 )
{
switch( option )
{
case (libcstring_system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_LIBCSTRING_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (libcstring_system_integer_t) 'E':
option_mode = FSNTFSINFO_MODE_MFT_ENTRY;
option_mft_entry_index = optarg;
break;
case (libcstring_system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (libcstring_system_integer_t) 'H':
option_mode = FSNTFSINFO_MODE_FILE_SYSTEM_HIERARCHY;
break;
case (libcstring_system_integer_t) 'o':
option_volume_offset = optarg;
break;
case (libcstring_system_integer_t) 'U':
option_mode = FSNTFSINFO_MODE_USN_CHANGE_JOURNAL;
break;
case (libcstring_system_integer_t) 'v':
verbose = 1;
break;
case (libcstring_system_integer_t) 'V':
fsntfsoutput_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file or device.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind ];
libcnotify_verbose_set(
verbose );
libfsntfs_notify_set_stream(
stderr,
NULL );
libfsntfs_notify_set_verbose(
verbose );
if( info_handle_initialize(
&fsntfsinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize info handle.\n" );
goto on_error;
}
if( option_volume_offset != NULL )
{
if( info_handle_set_volume_offset(
fsntfsinfo_info_handle,
option_volume_offset,
&error ) != 1 )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
fprintf(
stderr,
"Unsupported volume offset defaulting to: %" PRIi64 ".\n",
fsntfsinfo_info_handle->volume_offset );
}
}
if( info_handle_open_input(
fsntfsinfo_info_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open: %" PRIs_LIBCSTRING_SYSTEM ".\n",
source );
goto on_error;
}
switch( option_mode )
{
case FSNTFSINFO_MODE_FILE_SYSTEM_HIERARCHY:
if( info_handle_file_system_hierarchy_fprint(
fsntfsinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print file system hierarchy.\n" );
goto on_error;
}
break;
case FSNTFSINFO_MODE_MFT_ENTRY:
if( option_mft_entry_index == NULL )
{
fprintf(
stderr,
"Mising MFT entry index string.\n" );
goto on_error;
}
string_length = libcstring_system_string_length(
option_mft_entry_index );
if( ( string_length == 3 )
&& ( libcstring_system_string_compare(
option_mft_entry_index,
_LIBCSTRING_SYSTEM_STRING( "all" ),
3 ) == 0 ) )
{
if( info_handle_mft_entries_fprint(
fsntfsinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print MFT entries.\n" );
goto on_error;
}
}
else if( libcsystem_string_decimal_copy_to_64_bit(
option_mft_entry_index,
string_length + 1,
&mft_entry_index,
&error ) == 1 )
{
if( info_handle_mft_entry_fprint(
fsntfsinfo_info_handle,
mft_entry_index,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print MFT entry: %" PRIu64 ".\n",
mft_entry_index );
goto on_error;
}
}
else
{
fprintf(
stderr,
"Unable to copy MFT entry index string to 64-bit decimal.\n" );
goto on_error;
}
break;
case FSNTFSINFO_MODE_USN_CHANGE_JOURNAL:
if( fsntfsinfo_info_handle->input_volume == NULL )
{
fprintf(
stderr,
"Unable to print USN change journal ($UsnJrnl) information.\n" );
goto on_error;
}
if( info_handle_usn_change_journal_fprint(
fsntfsinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print USN change journal ($UsnJrnl) information.\n" );
goto on_error;
}
break;
case FSNTFSINFO_MODE_VOLUME:
default:
if( info_handle_volume_fprint(
fsntfsinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to print volume information.\n" );
goto on_error;
}
break;
}
if( info_handle_close_input(
fsntfsinfo_info_handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close info handle.\n" );
goto on_error;
}
if( info_handle_free(
&fsntfsinfo_info_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free info handle.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
if( fsntfsinfo_info_handle != NULL )
{
info_handle_free(
&fsntfsinfo_info_handle,
NULL );
}
return( EXIT_FAILURE );
}
/* Tests the libcdirectory_directory_entry_get_type function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_get_type(
void )
{
libcdirectory_directory_t *directory = NULL;
libcdirectory_directory_entry_t *directory_entry = NULL;
libcerror_error_t *error = NULL;
int result = 0;
uint8_t entry_type = 0;
/* Initialize test
*/
result = libcdirectory_directory_initialize(
&directory,
&error );
result = libcdirectory_directory_open(
directory,
".",
&error );
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
result = libcdirectory_directory_has_entry(
directory,
directory_entry,
"Makefile.am",
11,
LIBCDIRECTORY_ENTRY_TYPE_FILE,
0,
&error );
/* Test retrieving the type of a directory entry
*/
result = libcdirectory_directory_entry_get_type(
directory_entry,
&entry_type,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"entry_type",
entry_type,
LIBCDIRECTORY_ENTRY_TYPE_FILE );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libcdirectory_directory_entry_get_type(
NULL,
&entry_type,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libcdirectory_directory_entry_get_type(
directory_entry,
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
result = libcdirectory_directory_entry_free(
&directory_entry,
NULL );
result = libcdirectory_directory_free(
&directory,
NULL );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
if( directory != NULL )
{
libcdirectory_directory_free(
&directory,
NULL );
}
return( 0 );
}
/* Tests the libolecf_property_set_read_header_data function
* Returns 1 if successful or 0 if not
*/
int olecf_test_property_set_read_header_data(
void )
{
libcerror_error_t *error = NULL;
libolecf_property_set_t *property_set = NULL;
int result = 0;
/* Initialize test
*/
result = libolecf_property_set_initialize(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test regular cases
*/
result = libolecf_property_set_read_header_data(
(libolecf_internal_property_set_t *) property_set,
olecf_test_property_set_data1,
28,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libolecf_property_set_read_header_data(
NULL,
olecf_test_property_set_data1,
28,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libolecf_property_set_read_header_data(
(libolecf_internal_property_set_t *) property_set,
NULL,
28,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libolecf_property_set_read_header_data(
(libolecf_internal_property_set_t *) property_set,
olecf_test_property_set_data1,
0,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libolecf_property_set_read_header_data(
(libolecf_internal_property_set_t *) property_set,
olecf_test_property_set_data1,
(size_t) SSIZE_MAX + 1,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Test error case where byte order is invalid
*/
result = libolecf_property_set_read_header_data(
(libolecf_internal_property_set_t *) property_set,
olecf_test_property_set_error_data1,
28,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
result = libolecf_property_set_free(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( property_set != NULL )
{
libolecf_property_set_free(
&property_set,
NULL );
}
return( 0 );
}
/* Tests the libolecf_property_set_initialize function
* Returns 1 if successful or 0 if not
*/
int olecf_test_property_set_initialize(
void )
{
libcerror_error_t *error = NULL;
libolecf_property_set_t *property_set = NULL;
int result = 0;
#if defined( HAVE_OLECF_TEST_MEMORY )
int number_of_malloc_fail_tests = 1;
int number_of_memset_fail_tests = 1;
int test_number = 0;
#endif
/* Test regular cases
*/
result = libolecf_property_set_initialize(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
result = libolecf_property_set_free(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libolecf_property_set_initialize(
NULL,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
property_set = (libolecf_property_set_t *) 0x12345678UL;
result = libolecf_property_set_initialize(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
property_set = NULL;
#if defined( HAVE_OLECF_TEST_MEMORY )
for( test_number = 0;
test_number < number_of_malloc_fail_tests;
test_number++ )
{
/* Test libolecf_property_set_initialize with malloc failing
*/
olecf_test_malloc_attempts_before_fail = test_number;
result = libolecf_property_set_initialize(
&property_set,
&error );
if( olecf_test_malloc_attempts_before_fail != -1 )
{
olecf_test_malloc_attempts_before_fail = -1;
if( property_set != NULL )
{
libolecf_property_set_free(
&property_set,
NULL );
}
}
else
{
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
for( test_number = 0;
test_number < number_of_memset_fail_tests;
test_number++ )
{
/* Test libolecf_property_set_initialize with memset failing
*/
olecf_test_memset_attempts_before_fail = test_number;
result = libolecf_property_set_initialize(
&property_set,
&error );
if( olecf_test_memset_attempts_before_fail != -1 )
{
olecf_test_memset_attempts_before_fail = -1;
if( property_set != NULL )
{
libolecf_property_set_free(
&property_set,
NULL );
}
}
else
{
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
#endif /* defined( HAVE_OLECF_TEST_MEMORY ) */
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( property_set != NULL )
{
libolecf_property_set_free(
&property_set,
NULL );
}
return( 0 );
}
/* Frees a file_entry object
*/
void pyewf_file_entry_free(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_file_entry_free";
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file_entry.",
function );
return;
}
if( pyewf_file_entry->ob_type == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file_entry - missing ob_type.",
function );
return;
}
if( pyewf_file_entry->ob_type->tp_free == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file_entry - invalid ob_type - missing tp_free.",
function );
return;
}
if( pyewf_file_entry->file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file_entry - missing libewf file_entry.",
function );
return;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_free(
&( pyewf_file_entry->file_entry ),
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free file_entry.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free file_entry.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
}
if( pyewf_file_entry->handle_object != NULL )
{
Py_DecRef(
(PyObject *) pyewf_file_entry->handle_object );
}
pyewf_file_entry->ob_type->tp_free(
(PyObject*) pyewf_file_entry );
}
/* Seeks a certain offset in the file entry data
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_file_entry_seek_offset(
pyewf_file_entry_t *pyewf_file_entry,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_file_entry_seek_offset";
static char *keyword_list[] = { "offset", "whence", NULL };
off64_t offset = 0;
int whence = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf file_entry.",
function );
return( NULL );
}
if( pyewf_file_entry->file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf file_entry - missing libewf file_entry.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"L|i",
keyword_list,
&offset,
&whence ) == 0 )
{
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
offset = libewf_file_entry_seek_offset(
pyewf_file_entry->file_entry,
offset,
whence,
&error );
Py_END_ALLOW_THREADS
if( offset == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to seek offset.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to seek offset.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
Py_IncRef(
Py_None );
return( Py_None );
}
/* Retrieves the codepage used for header strings
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_header_codepage(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
const char *codepage_string = NULL;
static char *function = "pyewf_handle_get_header_codepage";
int header_codepage = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_header_codepage(
pyewf_handle->handle,
&header_codepage,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header codepage.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header codepage.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
codepage_string = pyewf_codepage_to_string(
header_codepage );
if( codepage_string == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: unsupported header codepage: %d.",
function,
header_codepage );
return( NULL );
}
string_object = PyString_FromString(
codepage_string );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert codepage string into string object.",
function );
return( NULL );
}
return( string_object );
}
/* Sets the codepage used for header strings
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_set_header_codepage(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
char *codepage_string = NULL;
static char *keyword_list[] = { "codepage", NULL };
static char *function = "pyewf_handle_set_header_codepage";
size_t codepage_string_length = 0;
uint32_t feature_flags = 0;
int header_codepage = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"s",
keyword_list,
&codepage_string ) == 0 )
{
return( NULL );
}
if( codepage_string == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid codepage string.",
function );
return( NULL );
}
codepage_string_length = libcstring_narrow_string_length(
codepage_string );
feature_flags = LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_KOI8
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_WINDOWS;
if( libclocale_codepage_copy_from_string(
&header_codepage,
codepage_string,
codepage_string_length,
feature_flags,
&error ) != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_RuntimeError,
"%s: unable to determine ASCII codepage.",
function );
}
else
{
PyErr_Format(
PyExc_RuntimeError,
"%s: unable to determine ASCII codepage.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_set_header_codepage(
pyewf_handle->handle,
header_codepage,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to set ASCII codepage.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to set ASCII codepage.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
Py_IncRef(
Py_None );
return( Py_None );
}
/* Opens a file for reading
* Returns 1 if successful or -1 on error
*/
int libevt_file_open_read(
libevt_internal_file_t *internal_file,
libcerror_error_t **error )
{
static char *function = "libevt_file_open_read";
off64_t last_record_offset = 0;
uint32_t end_of_file_record_offset = 0;
uint32_t first_record_offset = 0;
int result_record_read = 0;
int result_record_recovery = 0;
if( internal_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid internal file.",
function );
return( -1 );
}
if( internal_file->io_handle == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,
"%s: invalid internal file - missing IO handle.",
function );
return( -1 );
}
if( internal_file->io_handle->abort != 0 )
{
internal_file->io_handle->abort = 0;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"Reading file header:\n" );
}
#endif
if( libevt_io_handle_read_file_header(
internal_file->io_handle,
internal_file->file_io_handle,
&first_record_offset,
&end_of_file_record_offset,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read file header.",
function );
return( -1 );
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"Reading records:\n" );
}
#endif
result_record_read = libevt_io_handle_read_records(
internal_file->io_handle,
internal_file->file_io_handle,
first_record_offset,
end_of_file_record_offset,
internal_file->records_list,
&last_record_offset,
error );
if( result_record_read != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read records.",
function );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( ( error != NULL )
&& ( *error != NULL ) )
{
libcnotify_print_error_backtrace(
*error );
}
}
#endif
}
if( internal_file->io_handle->abort == 0 )
{
result_record_recovery = libevt_io_handle_recover_records(
internal_file->io_handle,
internal_file->file_io_handle,
first_record_offset,
end_of_file_record_offset,
last_record_offset,
internal_file->records_list,
internal_file->recovered_records_list,
error );
if( result_record_recovery != 1 )
{
#if defined( HAVE_DEBUG_OUTPUT )
if( result_record_read != 1 )
{
libcerror_error_free(
error );
}
#endif
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to recover records.",
function );
#if defined( HAVE_DEBUG_OUTPUT )
if( libcnotify_verbose != 0 )
{
if( ( error != NULL )
&& ( *error != NULL ) )
{
libcnotify_print_error_backtrace(
*error );
}
}
#endif
}
}
if( ( result_record_read != 1 )
&& ( result_record_recovery != 1 ) )
{
return( -1 );
}
if( ( error != NULL )
&& ( *error != NULL ) )
{
libcerror_error_free(
error );
}
if( internal_file->io_handle->abort != 0 )
{
internal_file->io_handle->abort = 0;
}
return( 1 );
}
/* Frees an block object
*/
void pyvshadow_block_free(
pyvshadow_block_t *pyvshadow_block )
{
libcerror_error_t *error = NULL;
struct _typeobject *ob_type = NULL;
static char *function = "pyvshadow_block_free";
if( pyvshadow_block == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid block.",
function );
return;
}
if( pyvshadow_block->block == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid block - missing libvshadow block.",
function );
return;
}
ob_type = Py_TYPE(
pyvshadow_block );
if( ob_type == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: missing ob_type.",
function );
return;
}
if( ob_type->tp_free == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid ob_type - missing tp_free.",
function );
return;
}
if( libvshadow_block_free(
&( pyvshadow_block->block ),
&error ) != 1 )
{
pyvshadow_error_raise(
error,
PyExc_IOError,
"%s: unable to free libvshadow block.",
function );
libcerror_error_free(
&error );
}
if( pyvshadow_block->store_object != NULL )
{
Py_DecRef(
(PyObject *) pyvshadow_block->store_object );
}
ob_type->tp_free(
(PyObject*) pyvshadow_block );
}
/* Creates a new string object from a GUID
* Returns a Python object if successful or NULL on error
*/
PyObject *pyvshadow_string_new_from_guid(
const uint8_t *guid_buffer,
size_t guid_buffer_size )
{
char guid_string[ 48 ];
libcerror_error_t *error = NULL;
libfguid_identifier_t *guid = NULL;
PyObject *string_object = NULL;
const char *errors = NULL;
static char *function = "pyvshadow_string_new_from_guid";
if( libfguid_identifier_initialize(
&guid,
&error ) != 1 )
{
pyvshadow_error_raise(
error,
PyExc_IOError,
"%s: unable to create GUID.",
function );
libcerror_error_free(
&error );
goto on_error;
}
if( libfguid_identifier_copy_from_byte_stream(
guid,
guid_buffer,
guid_buffer_size,
LIBFGUID_ENDIAN_LITTLE,
&error ) != 1 )
{
pyvshadow_error_raise(
error,
PyExc_IOError,
"%s: unable to copy byte stream to GUID.",
function );
libcerror_error_free(
&error );
goto on_error;
}
if( libfguid_identifier_copy_to_utf8_string(
guid,
(uint8_t *) guid_string,
48,
LIBFGUID_STRING_FORMAT_FLAG_USE_LOWER_CASE,
&error ) != 1 )
{
pyvshadow_error_raise(
error,
PyExc_IOError,
"%s: unable to copy GUID to string.",
function );
libcerror_error_free(
&error );
goto on_error;
}
if( libfguid_identifier_free(
&guid,
&error ) != 1 )
{
pyvshadow_error_raise(
error,
PyExc_IOError,
"%s: unable to free GUID.",
function );
libcerror_error_free(
&error );
goto on_error;
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
guid_string,
(Py_ssize_t) 36,
errors );
return( string_object );
on_error:
if( guid != NULL )
{
libfguid_identifier_free(
&guid,
NULL );
}
return( NULL );
}
/* Free an error and its elements
*/
void libcaes_error_free(
libcaes_error_t **error )
{
libcerror_error_free(
(libcerror_error_t **) error );
}
/* Free an error and its elements
*/
void libfcache_error_free(
libfcache_error_t **error )
{
libcerror_error_free(
(libcerror_error_t **) error );
}
/* Retrieves a specific sub file entry by index
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_sub_file_entry_by_index(
pyewf_file_entry_t *pyewf_file_entry,
int sub_file_entry_index )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
libewf_file_entry_t *sub_file_entry = NULL;
PyObject *file_entry_object = NULL;
static char *function = "pyewf_file_entry_get_sub_file_entry_by_index";
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_sub_file_entry(
pyewf_file_entry->file_entry,
sub_file_entry_index,
&sub_file_entry,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve sub file entry: %d.",
function,
sub_file_entry_index );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve sub file entry: %d.\n%s",
function,
sub_file_entry_index,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
file_entry_object = pyewf_file_entry_new(
sub_file_entry,
pyewf_file_entry->handle_object );
if( file_entry_object == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create file entry object.",
function );
goto on_error;
}
return( file_entry_object );
on_error:
if( sub_file_entry != NULL )
{
libewf_file_entry_free(
&sub_file_entry,
NULL );
}
return( NULL );
}
/* Retrieves a header value
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_header_value(
pyewf_handle_t *pyewf_handle,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_handle_get_header_value";
static char *keyword_list[] = { "identifier", NULL };
const char *errors = NULL;
char *header_value_identifier = NULL;
char *header_value = NULL;
size_t header_value_identifier_length = 0;
size_t header_value_size = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"s",
keyword_list,
&header_value_identifier ) == 0 )
{
return( NULL );
}
header_value_identifier_length = libcstring_narrow_string_length(
header_value_identifier );
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value_size(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
&header_value_size,
&error );
Py_END_ALLOW_THREADS
if( result == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s size.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s size.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Check if header value is present
*/
else if( result == 0 )
{
Py_IncRef(
Py_None );
return( Py_None );
}
header_value = (char *) PyMem_Malloc(
sizeof( char ) * header_value_size );
if( header_value == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create header value.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
(uint8_t *) header_value,
header_value_size,
&error );
Py_END_ALLOW_THREADS
if( result == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Check if the header value is present
*/
else if( result == 0 )
{
PyMem_Free(
header_value );
Py_IncRef(
Py_None );
return( Py_None );
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
header_value,
(Py_ssize_t) header_value_size - 1,
errors );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert UTF-8 header value: %s into Unicode.",
function,
header_value_identifier );
goto on_error;
}
PyMem_Free(
header_value );
return( string_object );
on_error:
if( header_value != NULL )
{
PyMem_Free(
header_value );
}
return( NULL );
}
/* Retrieves a file entries sequence and iterator object for the sub file entries
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_sub_file_entries(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *file_entries_object = NULL;
static char *function = "pyewf_file_entry_get_sub_file_entries";
int number_of_sub_file_entries = 0;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_number_of_sub_file_entries(
pyewf_file_entry->file_entry,
&number_of_sub_file_entries,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve number of sub file entries.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve number of sub file entries.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
file_entries_object = pyewf_file_entries_new(
pyewf_file_entry,
&pyewf_file_entry_get_sub_file_entry_by_index,
number_of_sub_file_entries );
if( file_entries_object == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create file entries object.",
function );
return( NULL );
}
return( file_entries_object );
}
/* Retrieves the header values
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_handle_get_header_values(
pyewf_handle_t *pyewf_handle )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *dictionary_object = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_handle_get_header_values";
const char *errors = NULL;
char *header_value = NULL;
char *header_value_identifier = NULL;
size_t header_value_identifier_length = 0;
size_t header_value_identifier_size = 0;
size_t header_value_size = 0;
uint32_t number_of_header_values = 0;
uint32_t header_value_index = 0;
int result = 0;
if( pyewf_handle == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid handle.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_number_of_header_values(
pyewf_handle->handle,
&number_of_header_values,
&error );
Py_END_ALLOW_THREADS
if( result == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: failed to retrieve number of header values.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: failed to retrieve number of header values.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
dictionary_object = PyDict_New();
for( header_value_index = 0;
header_value_index < number_of_header_values;
header_value_index++ )
{
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_header_value_identifier_size(
pyewf_handle->handle,
header_value_index,
&header_value_identifier_size,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header value: %d identifier size.",
function,
header_value_index );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header value: %d identifier size.\n%s",
function,
header_value_index,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
header_value_identifier = (char *) PyMem_Malloc(
sizeof( char ) * header_value_identifier_size );
if( header_value_identifier == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create header value identifier.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_header_value_identifier(
pyewf_handle->handle,
header_value_index,
(uint8_t *) header_value_identifier,
header_value_identifier_size,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header value: %d identifier.",
function,
header_value_index );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve header value: %d identifier.\n%s",
function,
header_value_index,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
header_value_identifier_length = libcstring_narrow_string_length(
header_value_identifier );
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value_size(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
&header_value_size,
&error );
Py_END_ALLOW_THREADS
if( result == -1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s size.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s size.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Ignore emtpy header values
*/
if( ( result != 0 )
&& ( header_value_size > 0 ) )
{
header_value = (char *) PyMem_Malloc(
sizeof( char ) * header_value_size );
if( header_value == NULL )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to create header value.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_handle_get_utf8_header_value(
pyewf_handle->handle,
(uint8_t *) header_value_identifier,
header_value_identifier_length,
(uint8_t *) header_value,
header_value_size,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s.",
function,
header_value_identifier );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve UTF-8 header value: %s.\n%s",
function,
header_value_identifier,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
header_value,
header_value_size - 1,
errors );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert UTF-8 header value: %s into Unicode.",
function,
header_value_identifier );
goto on_error;
}
if( PyDict_SetItemString(
dictionary_object,
header_value_identifier,
string_object ) != 0 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to set header value: %s in dictionary.",
function,
header_value_identifier );
goto on_error;
}
string_object = NULL;
PyMem_Free(
header_value );
header_value = NULL;
}
PyMem_Free(
header_value_identifier );
header_value_identifier = NULL;
}
/* Reads a buffer of file entry data at a specific offset from EWF file(s)
* Returns a Python object holding the data if successful or NULL on error
*/
PyObject *pyewf_file_entry_read_random(
pyewf_file_entry_t *pyewf_file_entry,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *result_data = NULL;
static char *function = "pyewf_file_entry_read_random";
static char *keyword_list[] = { "size", "offset", NULL };
off64_t read_offset = 0;
ssize_t read_count = 0;
int read_size = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf file_entry.",
function );
return( NULL );
}
if( pyewf_file_entry->file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid pyewf file_entry - missing libewf file_entry.",
function );
return( NULL );
}
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"i|L",
keyword_list,
&read_size,
&read_offset ) == 0 )
{
return( NULL );
}
if( read_size < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
if( read_size > INT_MAX )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read size value exceeds maximum.",
function );
return( NULL );
}
if( read_offset < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid argument read offset value less than zero.",
function );
return( NULL );
}
/* Make sure the data fits into a memory buffer
*/
result_data = PyString_FromStringAndSize(
NULL,
read_size );
Py_BEGIN_ALLOW_THREADS
read_count = libewf_file_entry_read_random(
pyewf_file_entry->file_entry,
PyString_AsString(
result_data ),
(size_t) read_size,
(off64_t) read_offset,
&error );
Py_END_ALLOW_THREADS
if( read_count != (ssize_t) read_size )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to read data.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to read data.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
return( result_data );
}
/* Tests the libvhdi_check_file_signature_wide function
* Returns 1 if successful or 0 if not
*/
int vhdi_test_check_file_signature_wide(
const system_character_t *source )
{
wchar_t wide_source[ 256 ];
libcerror_error_t *error = NULL;
int result = 0;
if( source != NULL )
{
/* Initialize test
*/
result = vhdi_test_get_wide_source(
source,
wide_source,
256,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test check file signature
*/
result = libvhdi_check_file_signature_wide(
wide_source,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
}
/* Test error cases
*/
result = libvhdi_check_file_signature_wide(
NULL,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libvhdi_check_file_signature_wide(
L"",
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
if( source != NULL )
{
#if defined( HAVE_VHDI_TEST_MEMORY )
/* Test libvhdi_check_file_signature_wide with malloc failing in libbfio_file_initialize
*/
vhdi_test_malloc_attempts_before_fail = 0;
result = libvhdi_check_file_signature_wide(
wide_source,
&error );
if( vhdi_test_malloc_attempts_before_fail != -1 )
{
vhdi_test_malloc_attempts_before_fail = -1;
}
else
{
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
#endif /* defined( HAVE_VHDI_TEST_MEMORY ) */
}
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
return( 0 );
}
/* Retrieves the size
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_size(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_file_entry_get_size";
size64_t size = 0;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_size(
pyewf_file_entry->file_entry,
&size,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve size.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve size.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
#if defined( HAVE_LONG_LONG )
if( size > (size64_t) LLONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: size value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLongLong(
(long long) size ) );
#else
if( size > (size64_t) LONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: size value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLong(
(long) size ) );
#endif
}
/* Tests the libvhdi_check_file_signature_file_io_handle function
* Returns 1 if successful or 0 if not
*/
int vhdi_test_check_file_signature_file_io_handle(
const system_character_t *source )
{
uint8_t empty_block[ 8192 ];
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
void *memset_result = NULL;
size_t source_length = 0;
int result = 0;
/* Initialize test
*/
memset_result = memory_set(
empty_block,
0,
sizeof( uint8_t ) * 8192 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"memset_result",
memset_result );
if( source != NULL )
{
/* Initialize test
*/
result = libbfio_file_initialize(
&file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
source_length = system_string_length(
source );
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
result = libbfio_file_set_name_wide(
file_io_handle,
source,
source_length,
&error );
#else
result = libbfio_file_set_name(
file_io_handle,
source,
source_length,
&error );
#endif
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
result = libbfio_handle_open(
file_io_handle,
LIBBFIO_OPEN_READ,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test check file signature
*/
result = libvhdi_check_file_signature_file_io_handle(
file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
}
/* Test error cases
*/
result = libvhdi_check_file_signature_file_io_handle(
NULL,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
if( source != NULL )
{
result = libbfio_handle_close(
file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
result = libbfio_handle_free(
&file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NULL(
"file_io_handle",
file_io_handle );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
}
/* Test check file signature with data too small
*/
result = vhdi_test_open_file_io_handle(
&file_io_handle,
empty_block,
sizeof( uint8_t ) * 1,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
result = libvhdi_check_file_signature_file_io_handle(
file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
result = vhdi_test_close_file_io_handle(
&file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test check file signature with empty block
*/
result = vhdi_test_open_file_io_handle(
&file_io_handle,
empty_block,
sizeof( uint8_t ) * 8192,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
VHDI_TEST_ASSERT_IS_NOT_NULL(
"file_io_handle",
file_io_handle );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
result = libvhdi_check_file_signature_file_io_handle(
file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
result = vhdi_test_close_file_io_handle(
&file_io_handle,
&error );
VHDI_TEST_ASSERT_EQUAL_INT(
"result",
result,
0 );
VHDI_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( 0 );
}
/* Tests the libolecf_property_set_get_class_identifier function
* Returns 1 if successful or 0 if not
*/
int olecf_test_property_set_get_class_identifier(
void )
{
uint8_t guid_data[ 16 ];
libcerror_error_t *error = NULL;
libolecf_property_set_t *property_set = NULL;
int result = 0;
/* Initialize test
*/
result = libolecf_property_set_initialize(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test regular cases
*/
result = libolecf_property_set_get_class_identifier(
property_set,
guid_data,
16,
&error );
OLECF_TEST_ASSERT_NOT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libolecf_property_set_get_class_identifier(
NULL,
guid_data,
16,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libolecf_property_set_get_class_identifier(
property_set,
NULL,
16,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libolecf_property_set_get_class_identifier(
property_set,
guid_data,
0,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libolecf_property_set_get_class_identifier(
property_set,
guid_data,
(size_t) SSIZE_MAX + 1,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
/* Clean up
*/
result = libolecf_property_set_free(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( property_set != NULL )
{
libolecf_property_set_free(
&property_set,
NULL );
}
return( 0 );
}
int main( int argc, char * const argv[] )
#endif
{
libcerror_error_t *error = NULL;
libevt_file_t *file = NULL;
size_t string_length = 0;
uint32_t feature_flags = 0;
int ascii_codepage = 0;
int result = 0;
if( argc != 2 )
{
fprintf(
stderr,
"Unsupported number of arguments.\n" );
return( EXIT_FAILURE );
}
feature_flags = LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_ISO_8859
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_KOI8
| LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_WINDOWS;
string_length = libcstring_system_string_length(
argv[ 1 ] );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libclocale_codepage_copy_from_string_wide(
&ascii_codepage,
argv[ 1 ],
string_length,
feature_flags,
&error );
#else
result = libclocale_codepage_copy_from_string(
&ascii_codepage,
argv[ 1 ],
string_length,
feature_flags,
&error );
#endif
if( result == -1 )
{
fprintf(
stderr,
"Unable to determine ASCII codepage from: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ 1 ] );
goto on_error;
}
if( libevt_file_initialize(
&file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create file.\n" );
goto on_error;
}
if( libevt_file_set_ascii_codepage(
file,
ascii_codepage,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to set codepage: %" PRIs_LIBCSTRING_SYSTEM ".\n",
argv[ 1 ] );
goto on_error;
}
if( libevt_file_free(
&file,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free file.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcerror_error_backtrace_fprint(
error,
stdout );
libcerror_error_free(
&error );
}
if( file != NULL )
{
libevt_file_free(
&file,
NULL );
}
return( -1 );
}
/* Tests the libolecf_property_set_get_number_of_sections function
* Returns 1 if successful or 0 if not
*/
int olecf_test_property_set_get_number_of_sections(
void )
{
libcerror_error_t *error = NULL;
libolecf_property_set_t *property_set = NULL;
int number_of_sections = 0;
int number_of_sections_is_set = 0;
int result = 0;
/* Initialize test
*/
result = libolecf_property_set_initialize(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test regular cases
*/
result = libolecf_property_set_get_number_of_sections(
property_set,
&number_of_sections,
&error );
OLECF_TEST_ASSERT_NOT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
number_of_sections_is_set = result;
/* Test error cases
*/
result = libolecf_property_set_get_number_of_sections(
NULL,
&number_of_sections,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
if( number_of_sections_is_set != 0 )
{
result = libolecf_property_set_get_number_of_sections(
property_set,
NULL,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
OLECF_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
/* Clean up
*/
result = libolecf_property_set_free(
&property_set,
&error );
OLECF_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
OLECF_TEST_ASSERT_IS_NULL(
"property_set",
property_set );
OLECF_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( property_set != NULL )
{
libolecf_property_set_free(
&property_set,
NULL );
}
return( 0 );
}
/* Retrieves the entry modification date and time as an integer
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_entry_modification_time_as_integer(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
static char *function = "pyewf_file_entry_get_entry_modification_time_as_integer";
uint32_t posix_time = 0;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: invalid file entry.",
function );
return( NULL );
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_entry_modification_time(
pyewf_file_entry->file_entry,
&posix_time,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve entry modification time.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve entry modification time.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
return( NULL );
}
#if defined( HAVE_LONG_LONG )
if( (uint64_t) posix_time > (uint64_t) LLONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: POSIX time value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLongLong(
(long long) posix_time ) );
#else
if( (uint64_t) posix_time > (uint64_t) LONG_MAX )
{
PyErr_Format(
PyExc_OverflowError,
"%s: POSIX time value exceeds maximum.",
function );
return( NULL );
}
return( PyLong_FromLong(
(long) posix_time ) );
#endif
}
/* Tests the libcdirectory_directory_entry_copy function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_copy(
void )
{
libcdirectory_directory_entry_t *destination_directory_entry = NULL;
libcdirectory_directory_entry_t *directory_entry = NULL;
libcerror_error_t *error = NULL;
int result = 0;
/* Initialize test
*/
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
result = libcdirectory_directory_entry_initialize(
&destination_directory_entry,
&error );
/* Test directory entry copy
*/
result = libcdirectory_directory_entry_copy(
destination_directory_entry,
directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libcdirectory_directory_entry_copy(
NULL,
directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libcdirectory_directory_entry_copy(
destination_directory_entry,
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
#if defined( HAVE_CDIRECTORY_TEST_MEMORY )
/* Test libcdirectory_directory_entry_initialize with memcpy failing
*/
cdirectory_test_memcpy_attempts_before_fail = 0;
result = libcdirectory_directory_entry_copy(
destination_directory_entry,
directory_entry,
&error );
if( cdirectory_test_memcpy_attempts_before_fail != -1 )
{
cdirectory_test_memcpy_attempts_before_fail = -1;
}
else
{
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
#endif /* defined( HAVE_CDIRECTORY_TEST_MEMORY ) */
/* Clean up
*/
result = libcdirectory_directory_entry_free(
&destination_directory_entry,
NULL );
result = libcdirectory_directory_entry_free(
&directory_entry,
NULL );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( destination_directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&destination_directory_entry,
NULL );
}
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
return( 0 );
}
/* Retrieves the MD5 hash
* Returns a Python object holding the offset if successful or NULL on error
*/
PyObject *pyewf_file_entry_get_hash_value_md5(
pyewf_file_entry_t *pyewf_file_entry )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
libcerror_error_t *error = NULL;
PyObject *string_object = NULL;
const char *errors = NULL;
uint8_t *hash_value = NULL;
static char *function = "pyewf_file_entry_get_hash_value_md5";
size_t hash_value_size = 33;
int result = 0;
if( pyewf_file_entry == NULL )
{
PyErr_Format(
PyExc_TypeError,
"%s: invalid file entry.",
function );
return( NULL );
}
hash_value = (uint8_t *) PyMem_Malloc(
sizeof( uint8_t ) * hash_value_size );
if( hash_value == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to create hash value.",
function );
goto on_error;
}
Py_BEGIN_ALLOW_THREADS
result = libewf_file_entry_get_utf8_hash_value_md5(
pyewf_file_entry->file_entry,
hash_value,
hash_value_size,
&error );
Py_END_ALLOW_THREADS
if( result != 1 )
{
if( libcerror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve hash value MD5.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to retrieve hash value MD5.\n%s",
function,
error_string );
}
libcerror_error_free(
&error );
goto on_error;
}
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
string_object = PyUnicode_DecodeUTF8(
(char *) hash_value,
(Py_ssize_t) hash_value_size - 1,
errors );
PyMem_Free(
hash_value );
return( string_object );
on_error:
if( hash_value != NULL )
{
PyMem_Free(
hash_value );
}
return( NULL );
}
/* Tests the libcdirectory_directory_entry_initialize function
* Returns 1 if successful or 0 if not
*/
int cdirectory_test_directory_entry_initialize(
void )
{
libcdirectory_directory_entry_t *directory_entry = NULL;
libcerror_error_t *error = NULL;
int result = 0;
#if defined( HAVE_CDIRECTORY_TEST_MEMORY )
int number_of_malloc_fail_tests = 1;
int number_of_memset_fail_tests = 1;
int test_number = 0;
#endif
/* Test regular cases
*/
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
result = libcdirectory_directory_entry_free(
&directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libcdirectory_directory_entry_initialize(
NULL,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
directory_entry = (libcdirectory_directory_entry_t *) 0x12345678UL;
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
directory_entry = NULL;
#if defined( HAVE_CDIRECTORY_TEST_MEMORY )
for( test_number = 0;
test_number < number_of_malloc_fail_tests;
test_number++ )
{
/* Test libcdirectory_directory_entry_initialize with malloc failing
*/
cdirectory_test_malloc_attempts_before_fail = test_number;
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
if( cdirectory_test_malloc_attempts_before_fail != -1 )
{
cdirectory_test_malloc_attempts_before_fail = -1;
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
}
else
{
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
for( test_number = 0;
test_number < number_of_memset_fail_tests;
test_number++ )
{
/* Test libcdirectory_directory_entry_initialize with memset failing
*/
cdirectory_test_memset_attempts_before_fail = test_number;
result = libcdirectory_directory_entry_initialize(
&directory_entry,
&error );
if( cdirectory_test_memset_attempts_before_fail != -1 )
{
cdirectory_test_memset_attempts_before_fail = -1;
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
}
else
{
CDIRECTORY_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
CDIRECTORY_TEST_ASSERT_IS_NULL(
"directory_entry",
directory_entry );
CDIRECTORY_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
#endif /* defined( HAVE_CDIRECTORY_TEST_MEMORY ) */
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( directory_entry != NULL )
{
libcdirectory_directory_entry_free(
&directory_entry,
NULL );
}
return( 0 );
}
/* Tests the libfsntfs_security_descriptor_index_initialize function
* Returns 1 if successful or 0 if not
*/
int fsntfs_test_security_descriptor_index_initialize(
void )
{
libbfio_handle_t *file_io_handle = NULL;
libcerror_error_t *error = NULL;
libfsntfs_attribute_t *data_attribute = NULL;
libfsntfs_io_handle_t *io_handle = NULL;
libfsntfs_security_descriptor_index_t *security_descriptor_index = NULL;
int result = 0;
#if defined( HAVE_FSNTFS_TEST_MEMORY )
int number_of_malloc_fail_tests = 1;
int number_of_memset_fail_tests = 1;
int test_number = 0;
#endif
/* Initialize test
*/
result = libfsntfs_io_handle_initialize(
&io_handle,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"io_handle",
io_handle );
FSNTFS_TEST_ASSERT_IS_NULL(
"error",
error );
io_handle->cluster_block_size = 4096;
result = libfsntfs_attribute_initialize(
&data_attribute,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"data_attribute",
data_attribute );
FSNTFS_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test regular cases
*/
result = libfsntfs_security_descriptor_index_initialize(
&security_descriptor_index,
io_handle,
file_io_handle,
data_attribute,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"security_descriptor_index",
security_descriptor_index );
FSNTFS_TEST_ASSERT_IS_NULL(
"error",
error );
result = libfsntfs_security_descriptor_index_free(
&security_descriptor_index,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
FSNTFS_TEST_ASSERT_IS_NULL(
"security_descriptor_index",
security_descriptor_index );
FSNTFS_TEST_ASSERT_IS_NULL(
"error",
error );
/* Test error cases
*/
result = libfsntfs_security_descriptor_index_initialize(
NULL,
io_handle,
file_io_handle,
data_attribute,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
security_descriptor_index = (libfsntfs_security_descriptor_index_t *) 0x12345678UL;
result = libfsntfs_security_descriptor_index_initialize(
&security_descriptor_index,
io_handle,
file_io_handle,
data_attribute,
&error );
security_descriptor_index = NULL;
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
result = libfsntfs_security_descriptor_index_initialize(
&security_descriptor_index,
io_handle,
file_io_handle,
NULL,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
#if defined( HAVE_FSNTFS_TEST_MEMORY )
for( test_number = 0;
test_number < number_of_malloc_fail_tests;
test_number++ )
{
/* Test libfsntfs_security_descriptor_index_initialize with malloc failing
*/
fsntfs_test_malloc_attempts_before_fail = test_number;
result = libfsntfs_security_descriptor_index_initialize(
&security_descriptor_index,
io_handle,
file_io_handle,
data_attribute,
&error );
if( fsntfs_test_malloc_attempts_before_fail != -1 )
{
fsntfs_test_malloc_attempts_before_fail = -1;
if( security_descriptor_index != NULL )
{
libfsntfs_security_descriptor_index_free(
&security_descriptor_index,
NULL );
}
}
else
{
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
FSNTFS_TEST_ASSERT_IS_NULL(
"security_descriptor_index",
security_descriptor_index );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
for( test_number = 0;
test_number < number_of_memset_fail_tests;
test_number++ )
{
/* Test libfsntfs_security_descriptor_index_initialize with memset failing
*/
fsntfs_test_memset_attempts_before_fail = test_number;
result = libfsntfs_security_descriptor_index_initialize(
&security_descriptor_index,
io_handle,
file_io_handle,
data_attribute,
&error );
if( fsntfs_test_memset_attempts_before_fail != -1 )
{
fsntfs_test_memset_attempts_before_fail = -1;
if( security_descriptor_index != NULL )
{
libfsntfs_security_descriptor_index_free(
&security_descriptor_index,
NULL );
}
}
else
{
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
-1 );
FSNTFS_TEST_ASSERT_IS_NULL(
"security_descriptor_index",
security_descriptor_index );
FSNTFS_TEST_ASSERT_IS_NOT_NULL(
"error",
error );
libcerror_error_free(
&error );
}
}
#endif /* defined( HAVE_FSNTFS_TEST_MEMORY ) */
/* Clean up
*/
result = libfsntfs_internal_attribute_free(
(libfsntfs_internal_attribute_t **) &data_attribute,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
FSNTFS_TEST_ASSERT_IS_NULL(
"data_attribute",
data_attribute );
FSNTFS_TEST_ASSERT_IS_NULL(
"error",
error );
result = libfsntfs_io_handle_free(
&io_handle,
&error );
FSNTFS_TEST_ASSERT_EQUAL_INT(
"result",
result,
1 );
FSNTFS_TEST_ASSERT_IS_NULL(
"io_handle",
io_handle );
FSNTFS_TEST_ASSERT_IS_NULL(
"error",
error );
return( 1 );
on_error:
if( error != NULL )
{
libcerror_error_free(
&error );
}
if( security_descriptor_index != NULL )
{
libfsntfs_security_descriptor_index_free(
&security_descriptor_index,
NULL );
}
if( data_attribute != NULL )
{
libfsntfs_internal_attribute_free(
(libfsntfs_internal_attribute_t **) &data_attribute,
NULL );
}
if( io_handle != NULL )
{
libfsntfs_io_handle_free(
&io_handle,
NULL );
}
return( 0 );
}
