/* Retrieves the pyewf/libewf version
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_get_version(
PyObject *self )
{
const char *errors = NULL;
const char *version_string = NULL;
size_t version_string_length = 0;
Py_BEGIN_ALLOW_THREADS
version_string = libewf_get_version();
Py_END_ALLOW_THREADS
version_string_length = libcstring_narrow_string_length(
version_string );
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
return( PyUnicode_DecodeUTF8(
version_string,
(Py_ssize_t) version_string_length,
errors ) );
}
/* Retrieves the pyewf/libewf version
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_get_version(
PyObject *self )
{
const char *errors = NULL;
const char *version_string = NULL;
size_t version_string_size = 0;
version_string = libewf_get_version();
version_string_size = 1 + libcstring_narrow_string_length(
version_string );
return( PyUnicode_DecodeUTF8(
version_string,
(Py_ssize_t) version_string_size,
errors ) );
}
/* Reads a buffer of data at the specified offset
* Returns number of bytes read if successful or a negative errno value otherwise
*/
int vshadowmount_fuse_read(
const char *path,
char *buffer,
size_t size,
off_t offset,
struct fuse_file_info *file_info )
{
libcerror_error_t *error = NULL;
static char *function = "vshadowmount_fuse_read";
size_t path_length = 0;
ssize_t read_count = 0;
int result = 0;
int store_index = 0;
int string_index = 0;
if( path == NULL )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid path.",
function );
result = -EINVAL;
goto on_error;
}
if( size > (size_t) INT_MAX )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid size value exceeds maximum.",
function );
result = -EINVAL;
goto on_error;
}
if( file_info == NULL )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file info.",
function );
result = -EINVAL;
goto on_error;
}
path_length = libcstring_narrow_string_length(
path );
if( ( path_length <= vshadowmount_fuse_path_prefix_length )
|| ( path_length > ( vshadowmount_fuse_path_prefix_length + 3 ) )
|| ( libcstring_narrow_string_compare(
path,
vshadowmount_fuse_path_prefix,
vshadowmount_fuse_path_prefix_length ) != 0 ) )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported path.",
function );
result = -ENOENT;
goto on_error;
}
string_index = vshadowmount_fuse_path_prefix_length;
store_index = path[ string_index++ ] - '0';
if( string_index < (int) path_length )
{
store_index *= 10;
store_index += path[ string_index++ ] - '0';
}
if( string_index < (int) path_length )
{
store_index *= 10;
store_index += path[ string_index++ ] - '0';
}
store_index -= 1;
if( mount_handle_seek_offset(
vshadowmount_mount_handle,
store_index,
(off64_t) offset,
SEEK_SET,
&error ) == -1 )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_SEEK_FAILED,
"%s: unable to seek offset in mount handle.",
function );
result = -EIO;
goto on_error;
}
read_count = mount_handle_read_buffer(
vshadowmount_mount_handle,
store_index,
(uint8_t *) buffer,
size,
&error );
if( read_count == -1 )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_READ_FAILED,
"%s: unable to read from mount handle.",
function );
result = -EIO;
goto on_error;
}
return( (int) read_count );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
return( result );
}
/* 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 );
}
/* Determines if a file contains a BDE volume signature
* Returns 1 if true, 0 if not or -1 on error
*/
int libbde_check_volume_signature(
const char *filename,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
static char *function = "libbde_check_volume_signature";
size_t filename_length = 0;
int result = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
filename_length = libcstring_narrow_string_length(
filename );
if( filename_length == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
goto on_error;
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
if( libbfio_file_set_name(
file_io_handle,
filename,
filename_length,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set filename in file IO handle.",
function );
goto on_error;
}
result = libbde_check_volume_signature_file_io_handle(
file_io_handle,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to check volume signature using a file handle.",
function );
goto on_error;
}
if( libbfio_handle_free(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to free file IO handle.",
function );
goto on_error;
}
return( result );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
PyObject *arguments PYOLECF_ATTRIBUTE_UNUSED )
{
const char *errors = NULL;
const char *version_string = NULL;
size_t version_string_length = 0;
PYOLECF_UNREFERENCED_PARAMETER( self )
PYOLECF_UNREFERENCED_PARAMETER( arguments )
Py_BEGIN_ALLOW_THREADS
version_string = libolecf_get_version();
Py_END_ALLOW_THREADS
version_string_length = libcstring_narrow_string_length(
version_string );
/* Pass the string length to PyUnicode_DecodeUTF8
* otherwise it makes the end of string character is part
* of the string
*/
return( PyUnicode_DecodeUTF8(
version_string,
(Py_ssize_t) version_string_length,
errors ) );
}
/* Checks if the file has an Object Linking and Embedding (OLE) Compound File (CF) signature
* Returns a Python object if successful or NULL on error
*/
PyObject *pyolecf_check_file_signature(
/* Determines the system string size from the UTF-8 string
* Returns 1 if successful or -1 on error
*/
int libcsystem_string_size_from_utf8_string(
const uint8_t *utf8_string,
size_t utf8_string_size,
size_t *string_size,
libcerror_error_t **error )
{
static char *function = "libcsystem_string_size_from_utf8_string";
if( utf8_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid UTF-8 string.",
function );
return( -1 );
}
if( utf8_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid UTF-8 string size value exceeds maximum.",
function );
return( -1 );
}
if( string_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid string size.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
#if SIZEOF_WCHAR_T == 4
if( libuna_utf32_string_size_from_utf8(
(libuna_utf8_character_t *) utf8_string,
utf8_string_size,
string_size,
error ) != 1 )
#elif SIZEOF_WCHAR_T == 2
if( libuna_utf16_string_size_from_utf8(
(libuna_utf8_character_t *) utf8_string,
utf8_string_size,
string_size,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine string size.",
function );
return( -1 );
}
#else
if( libclocale_codepage == 0 )
{
*string_size = 1 + libcstring_narrow_string_length(
(char *) utf8_string );
}
else if( libuna_byte_stream_size_from_utf8(
(libuna_utf8_character_t *) utf8_string,
utf8_string_size,
libclocale_codepage,
string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine string size.",
function );
return( -1 );
}
#endif
return( 1 );
}
/* Fetches an error
*/
void VARARGS(
pyexe_error_fetch,
libcerror_error_t **error,
int error_domain,
int error_code,
const char *,
format_string )
{
va_list argument_list;
char error_string[ PYEXE_ERROR_STRING_SIZE ];
PyObject *exception_traceback = NULL;
PyObject *exception_type = NULL;
PyObject *exception_value = NULL;
PyObject *string_object = NULL;
static char *function = "pyexe_error_fetch";
char *exception_string = NULL;
size_t error_string_length = 0;
int print_count = 0;
#if PY_MAJOR_VERSION >= 3
PyObject *utf8_string_object = NULL;
#endif
if( format_string == NULL )
{
PyErr_Format(
PyExc_ValueError,
"%s: missing format string.",
function );
return;
}
VASTART(
argument_list,
const char *,
format_string );
print_count = PyOS_vsnprintf(
error_string,
PYEXE_ERROR_STRING_SIZE,
format_string,
argument_list );
VAEND(
argument_list );
if( print_count < 0 )
{
PyErr_Format(
PyExc_ValueError,
"%s: unable to format error string.",
function );
return;
}
error_string_length = libcstring_narrow_string_length(
error_string );
if( ( error_string_length >= 1 )
&& ( error_string[ error_string_length - 1 ] == '.' ) )
{
error_string[ error_string_length - 1 ] = 0;
}
PyErr_Fetch(
&exception_type,
&exception_value,
&exception_traceback );
string_object = PyObject_Repr(
exception_value );
#if PY_MAJOR_VERSION >= 3
utf8_string_object = PyUnicode_AsUTF8String(
string_object );
if( utf8_string_object != NULL )
{
exception_string = PyBytes_AsString(
utf8_string_object );
}
#else
exception_string = PyString_AsString(
string_object );
#endif
if( exception_string != NULL )
{
libcerror_error_set(
error,
error_domain,
error_code,
"%s with error: %s.",
error_string,
exception_string );
}
else
{
libcerror_error_set(
error,
error_domain,
error_code,
"%s.",
error_string );
}
#if PY_MAJOR_VERSION >= 3
if( utf8_string_object != NULL )
{
Py_DecRef(
utf8_string_object );
}
#endif
Py_DecRef(
string_object );
return;
}
int main( int argc, char * const argv[] )
#endif
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
wchar_t **filenames = NULL;
#else
char **filenames = NULL;
#endif
libewf_error_t *error = NULL;
int number_of_filenames = 0;
int filename_iterator = 0;
if( argc < 2 )
{
fprintf(
stderr,
"Missing filename(s).\n" );
return( EXIT_FAILURE );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
argv[ 1 ],
libcstring_wide_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
argv[ 1 ],
libcstring_narrow_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to glob filenames.\n" );
goto on_error;
}
if( number_of_filenames < 0 )
{
fprintf(
stderr,
"Invalid number of filenames.\n" );
return( EXIT_FAILURE );
}
else if( number_of_filenames == 0 )
{
fprintf(
stderr,
"Missing filenames.\n" );
return( EXIT_FAILURE );
}
for( filename_iterator = 0;
filename_iterator < number_of_filenames;
filename_iterator++ )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
fprintf(
stdout,
"%ls",
filenames[ filename_iterator ] );
#else
fprintf(
stdout,
"%s",
filenames[ filename_iterator ] );
#endif
if( filename_iterator == ( number_of_filenames - 1 ) )
{
fprintf(
stdout,
"\n" );
}
else
{
fprintf(
stdout,
" " );
}
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide_free(
filenames,
number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libewf_error_backtrace_fprint(
error,
stderr );
libewf_error_free(
&error );
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
libcstring_system_character_t **filenames = NULL;
libewf_error_t *error = NULL;
libewf_handle_t *handle = NULL;
size64_t media_size = 0;
int number_of_filenames = 0;
if( argc < 2 )
{
fprintf(
stderr,
"Missing filename(s).\n" );
return( EXIT_FAILURE );
}
#if defined( HAVE_DEBUG_OUTPUT ) && defined( EWF_TEST_SEEK_VERBOSE )
libewf_notify_set_verbose(
1 );
libewf_notify_set_stream(
stderr,
NULL );
#endif
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide(
argv[ 1 ],
libcstring_wide_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob(
argv[ 1 ],
libcstring_narrow_string_length(
argv[ 1 ] ),
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to glob filenames.\n" );
goto on_error;
}
if( number_of_filenames < 0 )
{
fprintf(
stderr,
"Invalid number of filenames.\n" );
goto on_error;
}
else if( number_of_filenames == 0 )
{
fprintf(
stderr,
"Missing filenames.\n" );
goto on_error;
}
/* Initialization
*/
if( libewf_handle_initialize(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to create handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error ) != 1 )
#else
if( libewf_handle_open(
handle,
filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open handle.\n" );
goto on_error;
}
if( libewf_handle_get_media_size(
handle,
&media_size,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve media size.\n" );
goto on_error;
}
if( ewf_handle_test_seek(
handle,
media_size ) != 1 )
{
fprintf(
stderr,
"Unable to seek in handle.\n" );
goto on_error;
}
/* Clean up
*/
if( libewf_handle_close(
handle,
&error ) != 0 )
{
fprintf(
stderr,
"Unable to close handle.\n" );
goto on_error;
}
if( libewf_handle_free(
&handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to free handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide_free(
filenames,
number_of_filenames,
&error ) != 1 )
#else
if( libewf_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libewf_error_backtrace_fprint(
error,
stderr );
libewf_error_free(
&error );
}
if( handle != NULL )
{
libewf_handle_close(
handle,
NULL );
libewf_handle_free(
&handle,
NULL );
}
if( filenames != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
libewf_glob_wide_free(
filenames,
number_of_filenames,
NULL );
#else
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
#endif
}
return( EXIT_FAILURE );
}
int main( int argc, char * const argv[] )
#endif
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
wchar_t *full_path = NULL;
#else
char *full_path = NULL;
#endif
libcerror_error_t *error = NULL;
size_t full_path_size = 0;
if( argc < 2 )
{
fprintf(
stderr,
"Missing filename.\n" );
return( EXIT_FAILURE );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libcpath_path_get_full_path_wide(
argv[ 1 ],
libcstring_wide_string_length(
argv[ 1 ] ),
&full_path,
&full_path_size,
&error ) != 1 )
#else
if( libcpath_path_get_full_path(
argv[ 1 ],
libcstring_narrow_string_length(
argv[ 1 ] ),
&full_path,
&full_path_size,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to determine full path.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
fprintf(
stdout,
"%ls",
full_path );
#else
fprintf(
stdout,
"%s",
full_path );
#endif
memory_free(
full_path );
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libcerror_error_backtrace_fprint(
error,
stderr );
libcerror_error_free(
&error );
}
if( full_path != NULL )
{
memory_free(
full_path );
}
return( EXIT_FAILURE );
}
/* Retrieves the codepage for the locale character set
* Returns the codepage or 0 if the character set is UTF-8
* The codepage will default to LIBCSTRING_CODEPAGE_ASCII the codepage cannot be determined
*/
int libcstring_locale_get_codepage(
void )
{
char *locale = NULL;
char *charset = NULL;
size_t charset_length = 0;
size_t locale_length = 0;
int codepage = 0;
#if defined( HAVE_LANGINFO_CODESET )
charset = nl_langinfo(
CODESET );
#endif
if( ( charset != NULL )
&& ( charset[ 0 ] != 0 ) )
{
charset_length = libcstring_narrow_string_length(
charset );
}
else
{
#if defined( HAVE_SETLOCALE ) || ( defined( __BORLANDC__ ) && __BORLANDC__ <= 0x0520 )
locale = setlocale(
LC_CTYPE,
"" );
/* Check if the locale returned is not "C"
*/
if( ( locale != NULL )
&& ( locale[ 0 ] != 0 ) )
{
if( ( locale[ 0 ] == 'C' )
&& ( locale[ 1 ] != 0 ) )
{
locale = NULL;
}
}
#endif
#if defined( HAVE_GETENV ) || defined( WINAPI )
/* Check if the locale can be determined from the environment variables
*/
if( ( locale == NULL )
|| ( locale[ 0 ] == 0 ) )
{
locale = getenv(
"LC_ALL" );
}
if( ( locale == NULL )
|| ( locale[ 0 ] == 0 ) )
{
locale = getenv(
"LC_TYPE" );
}
if( ( locale == NULL )
|| ( locale[ 0 ] == 0 ) )
{
locale = getenv(
"LANG" );
}
#endif
if( ( locale == NULL )
|| ( locale[ 0 ] == 0 ) )
{
return( LIBCSTRING_CODEPAGE_ASCII );
}
locale_length = libcstring_narrow_string_length(
locale );
charset = libcstring_narrow_string_search_character(
locale,
'.',
locale_length + 1 );
if( charset == NULL )
{
return( LIBCSTRING_CODEPAGE_ASCII );
}
charset++;
charset_length = locale_length - (size_t) ( charset - locale );
}
/* Determine codepage
*/
codepage = LIBCSTRING_CODEPAGE_ASCII;
if( codepage == LIBCSTRING_CODEPAGE_ASCII )
{
if( charset_length == 5 )
{
if( libcstring_narrow_string_compare(
"UTF-8",
charset,
5 ) == 0 )
{
codepage = 0;
}
}
}
if( codepage == LIBCSTRING_CODEPAGE_ASCII )
{
if( charset_length >= 3 )
{
if( libcstring_narrow_string_compare(
"874",
charset,
3 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_874;
}
}
}
if( codepage == LIBCSTRING_CODEPAGE_ASCII )
{
if( charset_length >= 4 )
{
if( libcstring_narrow_string_compare(
"1250",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1250;
}
else if( libcstring_narrow_string_compare(
"1251",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1251;
}
else if( libcstring_narrow_string_compare(
"1252",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1252;
}
else if( libcstring_narrow_string_compare(
"1253",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1253;
}
else if( libcstring_narrow_string_compare(
"1254",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1254;
}
else if( libcstring_narrow_string_compare(
"1255",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1255;
}
else if( libcstring_narrow_string_compare(
"1256",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1256;
}
else if( libcstring_narrow_string_compare(
"1257",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1257;
}
else if( libcstring_narrow_string_compare(
"1258",
charset,
4 ) == 0 )
{
codepage = LIBCSTRING_CODEPAGE_WINDOWS_1258;
}
else if( libcstring_narrow_string_compare(
"utf8",
charset,
4 ) == 0 )
{
codepage = 0;
}
}
}
return( codepage );
}
/* 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;
}
/* Globs filenames according to the EWF segment file naming schema
* Returns a Python object if successful or NULL on error
*/
PyObject *pyewf_glob(
PyObject *self,
PyObject *arguments,
PyObject *keywords )
{
char error_string[ PYEWF_ERROR_STRING_SIZE ];
char **filenames = NULL;
liberror_error_t *error = NULL;
PyObject *list_object = NULL;
PyObject *string_object = NULL;
static char *function = "pyewf_glob";
static char *keyword_list[] = { "filename", NULL };
const char *errors = NULL;
const char *filename = NULL;
size_t filename_length = 0;
int filename_index = 0;
int number_of_filenames = 0;
if( PyArg_ParseTupleAndKeywords(
arguments,
keywords,
"|s",
keyword_list,
&filename ) == 0 )
{
return( NULL );
}
filename_length = libcstring_narrow_string_length(
filename );
if( libewf_glob(
filename,
filename_length,
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
&error ) != 1 )
{
if( liberror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to glob filenames.",
function );
}
else
{
PyErr_Format(
PyExc_IOError,
"%s: unable to glob filenames.\n%s",
function,
error_string );
}
liberror_error_free(
&error );
return( NULL );
}
list_object = PyList_New(
(Py_ssize_t) number_of_filenames );
for( filename_index = 0;
filename_index < number_of_filenames;
filename_index++ )
{
filename_length = libcstring_narrow_string_length(
filenames[ filename_index ] );
string_object = PyUnicode_DecodeUTF8(
filenames[ filename_index ],
filename_length,
errors );
if( string_object == NULL )
{
PyErr_Format(
PyExc_IOError,
"%s: unable to convert UTF-8 filename: %d into Unicode.",
function,
filename_index );
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
Py_DecRef(
list_object );
return( NULL );
}
if( PyList_SetItem(
list_object,
(Py_ssize_t) filename_index,
string_object ) != 0 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to set filename: %d in list.",
function,
filename_index );
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
Py_DecRef(
string_object );
Py_DecRef(
list_object );
return( NULL );
}
}
if( libewf_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
{
if( liberror_error_backtrace_sprint(
error,
error_string,
PYEWF_ERROR_STRING_SIZE ) == -1 )
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free globbed filenames.",
function );
}
else
{
PyErr_Format(
PyExc_MemoryError,
"%s: unable to free globbed filenames.\n%s",
function,
error_string );
}
liberror_error_free(
&error );
Py_DecRef(
list_object );
return( NULL );
}
return( list_object );
}
int main( int argc, char * const argv[] )
#endif
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
wchar_t **filenames = NULL;
#else
char **filenames = NULL;
#endif
libsmraw_error_t *error = NULL;
int number_of_filenames = 0;
if( argc != 2 )
{
fprintf(
stderr,
"Unsupported number of arguments.\n" );
return( EXIT_FAILURE );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libsmraw_glob_wide(
argv[ 1 ],
libcstring_wide_string_length(
argv[ 1 ] ),
&filenames,
&number_of_filenames,
&error ) != 1 )
#else
if( libsmraw_glob(
argv[ 1 ],
libcstring_narrow_string_length(
argv[ 1 ] ),
&filenames,
&number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to glob filenames.\n" );
goto on_error;
}
if( number_of_filenames < 0 )
{
fprintf(
stderr,
"Invalid number of filenames.\n" );
goto on_error;
}
else if( number_of_filenames == 0 )
{
fprintf(
stderr,
"Missing filenames.\n" );
goto on_error;
}
/* Case 0: single open and close of a handle using filenames
*/
fprintf(
stdout,
"Testing single open close of: %s with access: read\t",
filenames[ 0 ] );
if( smraw_test_single_open_close_handle(
filenames,
number_of_filenames,
LIBSMRAW_OPEN_READ,
1 ) != 1 )
{
fprintf(
stderr,
"Unable to test single open close.\n" );
goto on_error;
}
fprintf(
stdout,
"Testing single open close of: NULL with access: read\t" );
if( smraw_test_single_open_close_handle(
NULL,
0,
LIBSMRAW_OPEN_READ,
-1 ) != 1 )
{
fprintf(
stderr,
"Unable to test single open close.\n" );
goto on_error;
}
/* Case 1: multiple open and close of a handle using filenames
*/
fprintf(
stdout,
"Testing multi open close of: %s with access: read\t",
filenames[ 0 ] );
if( smraw_test_multi_open_close_handle(
filenames,
number_of_filenames,
LIBSMRAW_OPEN_READ,
1 ) != 1 )
{
fprintf(
stderr,
"Unable to test multi open close.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libsmraw_glob_wide_free(
filenames,
number_of_filenames,
&error ) != 1 )
#else
if( libsmraw_glob_free(
filenames,
number_of_filenames,
&error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
return( EXIT_SUCCESS );
on_error:
if( error != NULL )
{
libsmraw_error_backtrace_fprint(
error,
stderr );
libsmraw_error_free(
&error );
}
if( filenames != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
libsmraw_glob_wide_free(
filenames,
number_of_filenames,
NULL );
#else
libsmraw_glob_free(
filenames,
number_of_filenames,
NULL );
#endif
}
return( EXIT_FAILURE );
}
/* Determines and retrieves the bus type
* Returns 1 if successful or -1 on error
*/
int libsmdev_scsi_get_bus_type(
int file_descriptor,
uint8_t *bus_type,
liberror_error_t **error )
{
#if defined( SCSI_IOCTL_PROBE_HOST )
union
{
int length;
char buffer[ 128 ];
} sg_probe_host;
size_t sg_probe_host_length = 0;
#endif
static char *function = "libsmdev_scsi_get_bus_type";
if( file_descriptor == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file descriptor.",
function );
return( -1 );
}
if( bus_type == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid bus type.",
function );
return( -1 );
}
*bus_type = LIBSMDEV_BUS_TYPE_UNKNOWN;
#if defined( SCSI_IOCTL_PROBE_HOST )
sg_probe_host.length = 127;
if( ioctl(
file_descriptor,
SCSI_IOCTL_PROBE_HOST,
&sg_probe_host ) == -1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_IO,
LIBERROR_IO_ERROR_IOCTL_FAILED,
"%s: unable to query device for: SCSI_IOCTL_PROBE_HOST.",
function );
return( -1 );
}
sg_probe_host.buffer[ 127 ] = 0;
sg_probe_host_length = libcstring_narrow_string_length(
sg_probe_host.buffer );
#if defined( HAVE_DEBUG_OUTPUT )
if( libnotify_verbose != 0 )
{
libnotify_printf(
"%s: SCSI_IOCTL_PROBE_HOST (length: %d): %s\n",
function,
sg_probe_host_length,
sg_probe_host.buffer );
libnotify_printf(
"\n" );
}
#endif
if( sg_probe_host_length >= 4 )
{
if( libcstring_narrow_string_compare(
sg_probe_host.buffer,
"ahci",
4 ) == 0 )
{
*bus_type = LIBSMDEV_BUS_TYPE_ATA;
}
else if( libcstring_narrow_string_compare(
sg_probe_host.buffer,
"pata",
4 ) == 0 )
{
*bus_type = LIBSMDEV_BUS_TYPE_ATA;
}
else if( libcstring_narrow_string_compare(
sg_probe_host.buffer,
"sata",
4 ) == 0 )
{
*bus_type = LIBSMDEV_BUS_TYPE_ATA;
}
}
/* Serial Bus Protocol (SBP-2)
*/
else if( ( sg_probe_host_length == 15 )
&& ( libcstring_narrow_string_compare(
sg_probe_host.buffer,
"SBP-2 IEEE-1394",
15 ) == 0 ) )
{
*bus_type = LIBSMDEV_BUS_TYPE_FIREWIRE;
}
else if( ( sg_probe_host_length == 43 )
&& ( libcstring_narrow_string_compare(
sg_probe_host.buffer,
"SCSI emulation for USB Mass Storage devices",
43 ) == 0 ) )
{
*bus_type = LIBSMDEV_BUS_TYPE_USB;
}
#endif
return( 1 );
}
/* Sets an error and adds a system specific error string if possible
* Creates the error if necessary
* The error domain and code are set only the first time and the error message is appended for back tracing
*/
void VARARGS(
libcerror_system_set_error,
libcerror_error_t **error,
int error_domain,
int error_code,
uint32_t system_error_code,
const char *,
format_string )
{
va_list argument_list;
libcerror_internal_error_t *internal_error = NULL;
libcstring_system_character_t *system_format_string = NULL;
void *reallocation = NULL;
size_t format_string_length = 0;
size_t message_size = LIBCERROR_MESSAGE_INCREMENT_SIZE;
size_t string_index = 0;
int message_index = 0;
int print_count = 0;
if( error == NULL )
{
return;
}
if( format_string == NULL )
{
return;
}
format_string_length = libcstring_narrow_string_length(
format_string );
if( format_string_length > message_size )
{
message_size = ( ( format_string_length / LIBCERROR_MESSAGE_INCREMENT_SIZE ) + 1 )
* LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
do
{
reallocation = memory_reallocate(
system_format_string,
sizeof( libcstring_system_character_t ) * ( format_string_length + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
system_format_string = (libcstring_system_character_t *) reallocation;
#if defined( __BORLANDC__ ) || defined( _MSC_VER )
print_count = libcstring_wide_string_snwprintf(
system_format_string,
format_string_length + 1,
L"%S",
format_string );
#else
print_count = libcstring_wide_string_snwprintf(
system_format_string,
format_string_length + 1,
L"%s",
format_string );
#endif
if( print_count <= -1 )
{
format_string_length += LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
else if( ( (size_t) print_count > format_string_length )
|| ( system_format_string[ print_count ] != 0 ) )
{
format_string_length = (size_t) print_count;
print_count = -1;
}
if( format_string_length >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
goto on_error;
}
}
while( print_count <= -1 );
#else
system_format_string = (libcstring_system_character_t *) format_string;
#endif
#if defined( __BORLANDC__ ) || defined( _MSC_VER )
/* Rewrite %s to %S
*/
string_index = 0;
while( string_index < format_string_length )
{
if( system_format_string[ string_index ] == 0 )
{
break;
}
else if( system_format_string[ string_index ] == (libcstring_system_character_t) '%' )
{
string_index++;
if( system_format_string[ string_index ] == (libcstring_system_character_t) 's' )
{
system_format_string[ string_index ] = (libcstring_system_character_t) 'S';
}
}
string_index++;
}
#endif
if( *error == NULL )
{
internal_error = memory_allocate_structure(
libcerror_internal_error_t );
if( internal_error == NULL )
{
goto on_error;
}
internal_error->domain = error_domain;
internal_error->code = error_code;
internal_error->number_of_messages = 0;
internal_error->messages = NULL;
internal_error->sizes = NULL;
*error = (libcerror_error_t *) internal_error;
}
else
{
internal_error = (libcerror_internal_error_t *) *error;
}
reallocation = memory_reallocate(
internal_error->messages,
sizeof( libcstring_system_character_t * ) * ( internal_error->number_of_messages + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
internal_error->messages = (libcstring_system_character_t **) reallocation;
reallocation = memory_reallocate(
internal_error->sizes,
sizeof( size_t ) * ( internal_error->number_of_messages + 1 ) );
if( reallocation == NULL )
{
goto on_error;
}
internal_error->sizes = (size_t *) reallocation;
message_index = internal_error->number_of_messages;
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
internal_error->number_of_messages += 1;
do
{
reallocation = memory_reallocate(
internal_error->messages[ message_index ],
sizeof( libcstring_system_character_t ) * message_size );
if( reallocation == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
break;
}
internal_error->messages[ message_index ] = (libcstring_system_character_t *) reallocation;
VASTART(
argument_list,
const char *,
format_string );
print_count = libcstring_system_string_vsprintf(
internal_error->messages[ message_index ],
message_size,
system_format_string,
argument_list );
VAEND(
argument_list );
if( print_count <= -1 )
{
message_size += LIBCERROR_MESSAGE_INCREMENT_SIZE;
}
else if( ( (size_t) print_count > message_size )
|| ( ( internal_error->messages[ message_index ] )[ print_count ] != 0 ) )
{
message_size = (size_t) ( print_count + 1 );
print_count = -1;
}
if( message_size >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
break;
}
internal_error->sizes[ message_index ] = (size_t) print_count + 1;
}
while( print_count <= -1 );
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
memory_free(
system_format_string );
system_format_string = NULL;
#endif
string_index = internal_error->sizes[ message_index ] - 1;
if( ( internal_error->messages[ message_index ] != NULL )
&& ( ( internal_error->messages[ message_index ] )[ string_index - 1 ] == (libcstring_system_character_t) '.' ) )
{
string_index -= 1;
}
reallocation = memory_reallocate(
internal_error->messages[ message_index ],
sizeof( libcstring_system_character_t ) * ( message_size + 13 + 512 ) );
if( reallocation == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
goto on_error;
}
internal_error->messages[ message_index ] = (libcstring_system_character_t *) reallocation;
if( libcstring_system_string_copy(
&( ( internal_error->messages[ message_index ] )[ string_index ] ),
_LIBCSTRING_SYSTEM_STRING( " with error: " ),
13 ) == NULL )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
goto on_error;
}
internal_error->sizes[ message_index ] += 13;
string_index += 13;
print_count = libcerror_system_copy_string_from_error_number(
&( ( internal_error->messages[ message_index ] )[ string_index ] ),
512,
system_error_code );
if( print_count == -1 )
{
goto on_error;
}
message_size += (size_t) print_count;
if( message_size >= LIBCERROR_MESSAGE_MAXIMUM_SIZE )
{
memory_free(
internal_error->messages[ message_index ] );
internal_error->messages[ message_index ] = NULL;
internal_error->sizes[ message_index ] = 0;
goto on_error;
}
internal_error->sizes[ message_index ] += print_count;
return;
on_error:
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( system_format_string != NULL )
{
memory_free(
system_format_string );
}
#endif
if( ( *error == NULL )
&& ( internal_error != NULL ) )
{
memory_free(
internal_error );
}
return;
}
/* Determines the operating system string
* Returns 1 if successful or -1 on error
*/
int platform_get_operating_system(
libcstring_system_character_t *operating_system_string,
size_t operating_system_string_size,
liberror_error_t **error )
{
#if defined( HAVE_UNAME ) && !defined( WINAPI )
struct utsname utsname_buffer;
#endif
char *operating_system = NULL;
static char *function = "platform_get_operating_system";
size_t operating_system_length = 0;
#if defined( WINAPI )
DWORD windows_version = 0;
DWORD windows_major_version = 0;
DWORD windows_minor_version = 0;
/*
DWORD windows_build_number = 0;
*/
#endif
if( operating_system_string == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid operating system string.",
function );
return( -1 );
}
#if defined( WINAPI )
operating_system = "Windows";
windows_version = GetVersion();
windows_major_version = (DWORD) ( LOBYTE( LOWORD( windows_version ) ) );
windows_minor_version = (DWORD) ( HIBYTE( LOWORD( windows_version ) ) );
/*
if( windows_version < 0x80000000 )
{
windows_build_number = (DWORD)( HIWORD( windows_version ) );
}
*/
if( windows_major_version == 3 )
{
if( windows_version < 0x80000000 )
{
if( windows_minor_version == 51 )
{
operating_system = "Windows NT 3.51";
}
}
}
else if( windows_major_version == 4 )
{
if( windows_version < 0x80000000 )
{
if( windows_minor_version == 0 )
{
operating_system = "Windows NT 4";
}
}
else
{
if( windows_minor_version == 0 )
{
operating_system = "Windows 95";
}
else if( windows_minor_version == 10 )
{
operating_system = "Windows 98";
}
else if( windows_minor_version == 90 )
{
operating_system = "Windows ME";
}
}
}
else if( windows_major_version == 5 )
{
if( windows_version < 0x80000000 )
{
if( windows_minor_version == 0 )
{
operating_system = "Windows 2000";
}
else if( windows_minor_version == 1 )
{
operating_system = "Windows XP";
}
else if( windows_minor_version == 2 )
{
operating_system = "Windows 2003";
}
}
}
else if( windows_major_version == 6 )
{
if( windows_version < 0x80000000 )
{
if( windows_minor_version == 0 )
{
operating_system = "Windows Vista/2008";
}
else if( windows_minor_version == 1 )
{
operating_system = "Windows 7";
}
}
}
#elif defined( HAVE_UNAME )
/* Determine the operating system
*/
if( uname(
&utsname_buffer ) == 0 )
{
operating_system = utsname_buffer.sysname;
}
else
{
operating_system = "Undetermined";
}
#else
/* Have configure determine the operating system
*/
operating_system = LIBEWF_OPERATING_SYSTEM;
#endif
operating_system_length = libcstring_narrow_string_length(
operating_system );
if( operating_system_string_size < ( operating_system_length + 1 ) )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: operating system string too small.",
function );
return( -1 );
}
if( libsystem_string_copy_from_utf8_string(
operating_system_string,
operating_system_string_size,
(uint8_t *) operating_system,
operating_system_length + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_CONVERSION,
LIBERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to set operating system string.",
function );
return( -1 );
}
return( 1 );
}
/* Appends file handles to the pool for the corresponding filenames
* Returns 1 if successful or -1 on error
*/
int libbfio_file_pool_append_handles_for_names(
libbfio_pool_t *pool,
char * const names[],
int number_of_names,
int access_flags,
liberror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
static char *function = "libbfio_file_pool_append_handles_for_names";
size_t name_length = 0;
int pool_entry = 0;
int name_iterator = 0;
if( pool == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid pool.",
function );
return( -1 );
}
if( names == NULL )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid names.",
function );
return( -1 );
}
if( number_of_names <= 0 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_ARGUMENTS,
LIBERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,
"%s: invalid number of names zero or less.",
function );
return( -1 );
}
for( name_iterator = 0;
name_iterator < number_of_names;
name_iterator++ )
{
name_length = libcstring_narrow_string_length(
names[ name_iterator ] );
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle: %d.",
function,
name_iterator );
return( -1 );
}
if( libbfio_file_set_name(
file_io_handle,
names[ name_iterator ],
name_length + 1,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set name in file IO handle: %d.",
function,
name_iterator );
libbfio_handle_free(
&file_io_handle,
NULL );
return( -1 );
}
if( libbfio_pool_append_handle(
pool,
&pool_entry,
file_io_handle,
access_flags,
error ) != 1 )
{
liberror_error_set(
error,
LIBERROR_ERROR_DOMAIN_RUNTIME,
LIBERROR_RUNTIME_ERROR_APPEND_FAILED,
"%s: unable to append file IO handle: %d to pool.",
function,
name_iterator );
libbfio_handle_free(
&file_io_handle,
NULL );
return( -1 );
}
file_io_handle = NULL;
}
return( 1 );
}
/* Generate an xhash
* Sets xhash and xhash size
* Returns 1 if successful or -1 on error
*/
int libewf_hash_values_generate_xhash(
libfvalue_table_t *hash_values,
uint8_t **xhash,
size_t *xhash_size,
libcerror_error_t **error )
{
libfvalue_value_t *hash_value = NULL;
uint8_t *identifier = NULL;
char *xml_head = NULL;
char *xml_xhash_close_tag = NULL;
char *xml_xhash_open_tag = NULL;
static char *function = "libewf_hash_values_generate_xhash";
size_t xhash_index = 0;
size_t identifier_size = 0;
size_t value_string_size = 0;
size_t xml_head_length = 0;
size_t xml_xhash_close_tag_length = 0;
size_t xml_xhash_open_tag_length = 0;
int hash_value_index = 0;
int number_of_hash_values = 0;
int result = 0;
if( xhash == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid xhash.",
function );
return( -1 );
}
if( *xhash != NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: xhash already created.",
function );
return( -1 );
}
if( xhash_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid xhash size.",
function );
return( -1 );
}
if( libfvalue_table_get_number_of_values(
hash_values,
&number_of_hash_values,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of hash values.",
function );
goto on_error;
}
xml_head = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
xml_head_length = libcstring_narrow_string_length(
xml_head );
xml_xhash_open_tag = "<xhash>\n";
xml_xhash_open_tag_length = libcstring_narrow_string_length(
xml_xhash_open_tag );
xml_xhash_close_tag = "</xhash>\n\n";
xml_xhash_close_tag_length = libcstring_narrow_string_length(
xml_xhash_close_tag );
/* Reserve space for the UTF-8 byte order mark and the XML skeleton data
*/
*xhash_size = 3 + xml_head_length + xml_xhash_open_tag_length + xml_xhash_close_tag_length;
for( hash_value_index = 0;
hash_value_index < number_of_hash_values;
hash_value_index++ )
{
if( libfvalue_table_get_value_by_index(
hash_values,
hash_value_index,
&hash_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( libfvalue_value_get_identifier(
hash_value,
&identifier,
&identifier_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier of hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( ( identifier == NULL )
|| ( identifier_size == 0 ) )
{
#if defined( HAVE_VERBOSE_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: missing identifier for hash value: %d.\n",
function,
hash_value_index );
}
#endif
continue;
}
result = libfvalue_value_get_utf8_string_size(
hash_value,
0,
&value_string_size,
error );
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve string size of hash value: %s.",
function,
(char *) identifier );
goto on_error;
}
if( ( result != 0 )
&& ( value_string_size > 1 ) )
{
/* Reserve space for a leading tab, <identifier>value</identifier> and a newline
*/
*xhash_size += 7 + ( 2 * ( identifier_size - 1 ) ) + ( value_string_size - 1 );
}
}
/* Reserve space for the end-of-string character
*/
*xhash_size += 1;
*xhash = (uint8_t *) memory_allocate(
sizeof( uint8_t ) * *xhash_size );
if( *xhash == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: unable to create xhash.",
function );
goto on_error;
}
( *xhash )[ xhash_index++ ] = 0xef;
( *xhash )[ xhash_index++ ] = 0xbb;
( *xhash )[ xhash_index++ ] = 0xbf;
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
xml_head,
xml_head_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy XML head string.",
function );
goto on_error;
}
xhash_index += xml_head_length;
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
xml_xhash_open_tag,
xml_xhash_open_tag_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy xhash open tag string.",
function );
goto on_error;
}
xhash_index += xml_xhash_open_tag_length;
for( hash_value_index = 0;
hash_value_index < number_of_hash_values;
hash_value_index++ )
{
if( libfvalue_table_get_value_by_index(
hash_values,
hash_value_index,
&hash_value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( libfvalue_value_get_identifier(
hash_value,
&identifier,
&identifier_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier of hash value: %d.",
function,
hash_value_index );
goto on_error;
}
if( ( identifier == NULL )
|| ( identifier_size == 0 ) )
{
#if defined( HAVE_VERBOSE_OUTPUT )
if( libcnotify_verbose != 0 )
{
libcnotify_printf(
"%s: missing identifier for hash value: %d.\n",
function,
hash_value_index );
}
#endif
continue;
}
result = libfvalue_value_get_utf8_string_size(
hash_value,
0,
&value_string_size,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve string size of hash value: %s.",
function,
(char *) identifier );
goto on_error;
}
if( ( result != 0 )
&& ( value_string_size > 1 ) )
{
( *xhash )[ xhash_index++ ] = (uint8_t) '\t';
( *xhash )[ xhash_index++ ] = (uint8_t) '<';
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
(char *) identifier,
identifier_size - 1 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy %s open tag string.",
function,
(char *) identifier );
goto on_error;
}
xhash_index += identifier_size - 1;
( *xhash )[ xhash_index++ ] = (uint8_t) '>';
if( libfvalue_value_copy_to_utf8_string_with_index(
hash_value,
0,
*xhash,
*xhash_size,
&xhash_index,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy string of hash value: %s.",
function,
(char *) identifier );
goto on_error;
}
( *xhash )[ xhash_index - 1 ] = (uint8_t) '<';
( *xhash )[ xhash_index++ ] = (uint8_t) '/';
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
(char *) identifier,
identifier_size - 1 ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy %s close tag string.",
function,
(char *) identifier );
goto on_error;
}
xhash_index += identifier_size - 1;
( *xhash )[ xhash_index++ ] = (uint8_t) '>';
( *xhash )[ xhash_index++ ] = (uint8_t) '\n';
}
}
if( libcstring_narrow_string_copy(
(char *) &( ( *xhash )[ xhash_index ] ),
xml_xhash_close_tag,
xml_xhash_close_tag_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_COPY_FAILED,
"%s: unable to copy xhash close tag string.",
function );
goto on_error;
}
xhash_index += xml_xhash_close_tag_length;
/* Make sure the string is terminated
*/
( *xhash )[ xhash_index ] = 0;
return( 1 );
on_error:
if( *xhash != NULL )
{
memory_free(
*xhash );
*xhash = NULL;
}
*xhash_size = 0;
return( -1 );
}
/* Opens the registry file
* Returns 1 if successful or -1 on error
*/
int registry_file_open(
registry_file_t *registry_file,
const libcstring_system_character_t *filename,
libcerror_error_t **error )
{
libcstring_system_character_t *name = NULL;
libregf_key_t *sub_key = NULL;
libregf_value_t *value = NULL;
static char *function = "registry_file_open";
const char *sub_key_path = NULL;
const char *value_name = NULL;
size_t name_size = 0;
size_t sub_key_path_length = 0;
size_t value_name_length = 0;
int number_of_sub_keys = 0;
int result = 0;
if( registry_file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid registry file.",
function );
return( -1 );
}
if( registry_file->is_open != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
"%s: invalid registry file already open.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libregf_file_open_wide(
registry_file->regf_file,
filename,
LIBREGF_OPEN_READ,
error ) != 1 )
#else
if( libregf_file_open(
registry_file->regf_file,
filename,
LIBREGF_OPEN_READ,
error ) != 1 )
#endif
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open REGF file.",
function );
goto on_error;
}
if( libregf_file_get_root_key(
registry_file->regf_file,
&( registry_file->root_key ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root key.",
function );
goto on_error;
}
if( libregf_key_get_number_of_sub_keys(
registry_file->root_key,
&number_of_sub_keys,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of sub keys of root key.",
function );
goto on_error;
}
result = 0;
if( number_of_sub_keys == 1 )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name_size(
registry_file->root_key,
&name_size,
error );
#else
result = libregf_key_get_utf8_name_size(
registry_file->root_key,
&name_size,
error );
#endif
if( ( result != 1 )
|| ( name_size == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root key name size.",
function );
goto on_error;
}
if( ( name_size > (size_t) SSIZE_MAX )
|| ( ( sizeof( libcstring_system_character_t ) * name_size ) > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid name size value exceeds maximum.",
function );
goto on_error;
}
name = libcstring_system_string_allocate(
name_size );
if( name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name(
registry_file->root_key,
(uint16_t *) name,
name_size,
error );
#else
result = libregf_key_get_utf8_name(
registry_file->root_key,
(uint8_t *) name,
name_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve root key name.",
function );
goto on_error;
}
result = 0;
/* TODO what about Windows NT4 */
if( name_size == 13 )
{
/* Root key used by Windows 2000, XP, 2003
*/
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "$$$PROTO.HIV" ),
12 ) == 0 )
{
result = 1;
}
}
else if( name_size == 53 )
{
/* Root key used by Windows Vista, 2008, 7
*/
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "CMI-CreateHive{" ),
15 ) == 0 )
{
if( name[ 51 ] == (libcstring_system_character_t) '}' )
{
result = 1;
}
}
}
else if( name_size == 58 )
{
/* Root key used by Windows 8
*/
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "CsiTool-CreateHive-{" ),
20 ) == 0 )
{
if( name[ 56 ] == (libcstring_system_character_t) '}' )
{
result = 1;
}
}
}
memory_free(
name );
name = NULL;
}
if( result != 0 )
{
if( libregf_key_get_sub_key(
registry_file->root_key,
0,
&( registry_file->base_key ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve base key.",
function );
goto on_error;
}
}
else
{
/* E.g. for the SAM registry file the root key is the base
*/
registry_file->base_key = registry_file->root_key;
}
/* Determine the registry file type based on the name of the base key
*/
/* TODO refactor to separate function */
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name_size(
registry_file->base_key,
&name_size,
error );
#else
result = libregf_key_get_utf8_name_size(
registry_file->base_key,
&name_size,
error );
#endif
if( ( result != 1 )
|| ( name_size == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve base key name size.",
function );
goto on_error;
}
if( ( name_size > (size_t) SSIZE_MAX )
|| ( ( sizeof( libcstring_system_character_t ) * name_size ) > (size_t) SSIZE_MAX ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid name size value exceeds maximum.",
function );
goto on_error;
}
name = libcstring_system_string_allocate(
name_size );
if( name == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
result = libregf_key_get_utf16_name(
registry_file->base_key,
(uint16_t *) name,
name_size,
error );
#else
result = libregf_key_get_utf8_name(
registry_file->base_key,
(uint8_t *) name,
name_size,
error );
#endif
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve base key name.",
function );
goto on_error;
}
/* TODO add more types */
if( name_size == 4 )
{
if( libcstring_system_string_compare_no_case(
name,
_LIBCSTRING_SYSTEM_STRING( "SAM" ),
3 ) == 0 )
{
registry_file->type = REGISTRY_FILE_TYPE_SAM;
}
}
memory_free(
name );
name = NULL;
/* TODO still needed ? */
if( libregf_key_get_number_of_sub_keys(
registry_file->base_key,
&number_of_sub_keys,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of sub keys of base key.",
function );
goto on_error;
}
/* TODO refactor to separate function */
/* Get the current control set from:
* SYSTEM\Select\Current
*/
sub_key_path = "Select";
sub_key_path_length = libcstring_narrow_string_length(
sub_key_path );
result = libregf_key_get_sub_key_by_utf8_path(
registry_file->base_key,
(uint8_t *) sub_key_path,
sub_key_path_length,
&sub_key,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve sub key: %s.",
function,
sub_key_path );
goto on_error;
}
else if( result != 0 )
{
value_name = "Current";
value_name_length = libcstring_narrow_string_length(
value_name );
result = libregf_key_get_value_by_utf8_name(
sub_key,
(uint8_t *) value_name,
value_name_length,
&value,
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve value: %s.",
function,
value_name );
goto on_error;
}
else if( result != 0 )
{
if( libregf_value_get_value_32bit(
value,
&( registry_file->current_control_set ),
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve 32-bit value: %s.",
function,
value_name );
goto on_error;
}
if( libregf_value_free(
&value,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free value.",
function );
goto on_error;
}
}
}
if( libregf_key_free(
&sub_key,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free sub key.",
function );
goto on_error;
}
/* Retrieve the control set 1 key: SYSTEM\ControlSet001
*/
sub_key_path = "ControlSet001";
sub_key_path_length = libcstring_narrow_string_length(
sub_key_path );
result = libregf_key_get_sub_key_by_utf8_path(
registry_file->base_key,
(uint8_t *) sub_key_path,
sub_key_path_length,
&( registry_file->control_set1_key ),
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve sub key: %s.",
function,
sub_key_path );
goto on_error;
}
/* Retrieve the control set 2 key: SYSTEM\ControlSet002
*/
sub_key_path = "ControlSet002";
sub_key_path_length = libcstring_narrow_string_length(
sub_key_path );
result = libregf_key_get_sub_key_by_utf8_path(
registry_file->base_key,
(uint8_t *) sub_key_path,
sub_key_path_length,
&( registry_file->control_set2_key ),
error );
if( result == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve sub key: %s.",
function,
sub_key_path );
goto on_error;
}
if( ( registry_file->current_control_set != 0 )
|| ( registry_file->control_set1_key != NULL )
|| ( registry_file->control_set2_key != NULL ) )
{
if( ( registry_file->current_control_set != 1 )
&& ( registry_file->current_control_set != 2 ) )
{
/* TODO print debug notification */
registry_file->current_control_set = 1;
}
if( ( registry_file->current_control_set == 1 )
&& ( registry_file->control_set1_key != NULL ) )
{
registry_file->current_control_set_key = registry_file->control_set1_key;
}
else if( ( registry_file->current_control_set == 2 )
&& ( registry_file->control_set2_key != NULL ) )
{
registry_file->current_control_set_key = registry_file->control_set2_key;
}
}
registry_file->is_open = 1;
return( 1 );
on_error:
if( value != NULL )
{
libregf_value_free(
&value,
NULL );
}
if( sub_key != NULL )
{
libregf_key_free(
&sub_key,
NULL );
}
if( registry_file->control_set2_key != NULL )
{
libregf_key_free(
&( registry_file->control_set2_key ),
NULL );
}
if( registry_file->control_set1_key != NULL )
{
libregf_key_free(
&( registry_file->control_set1_key ),
NULL );
}
if( ( registry_file->base_key != NULL )
&& ( registry_file->base_key != registry_file->root_key ) )
{
libregf_key_free(
&( registry_file->base_key ),
NULL );
}
if( name != NULL )
{
memory_free(
name );
}
if( registry_file->root_key != NULL )
{
libregf_key_free(
&( registry_file->root_key ),
NULL );
}
libregf_file_close(
registry_file->regf_file,
NULL );
return( -1 );
}
/* Tests seeking in a handle
* Returns 1 if successful, 0 if not or -1 on error
*/
int ewf_test_seek_handle(
libcstring_system_character_t *source,
libcerror_error_t **error )
{
libcstring_system_character_t **filenames = NULL;
libewf_handle_t *handle = NULL;
size64_t media_size = 0;
size_t string_length = 0;
int number_of_filenames = 0;
int result = 0;
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
string_length = libcstring_wide_string_length(
source );
if( libewf_glob_wide(
source,
string_length,
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
error ) != 1 )
#else
string_length = libcstring_narrow_string_length(
source );
if( libewf_glob(
source,
string_length,
LIBEWF_FORMAT_UNKNOWN,
&filenames,
&number_of_filenames,
error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to glob filenames.\n" );
goto on_error;
}
if( number_of_filenames < 0 )
{
fprintf(
stderr,
"Invalid number of filenames.\n" );
goto on_error;
}
else if( number_of_filenames == 0 )
{
fprintf(
stderr,
"Missing filenames.\n" );
goto on_error;
}
if( libewf_handle_initialize(
&handle,
error ) != 1 )
{
fprintf(
stderr,
"Unable to create handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_handle_open_wide(
handle,
(wchar_t * const *) filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
error ) != 1 )
#else
if( libewf_handle_open(
handle,
(char * const *) filenames,
number_of_filenames,
LIBEWF_OPEN_READ,
error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to open handle.\n" );
goto on_error;
}
if( libewf_handle_get_media_size(
handle,
&media_size,
error ) != 1 )
{
fprintf(
stderr,
"Unable to retrieve media size.\n" );
goto on_error;
}
result = ewf_test_seek(
handle,
media_size );
if( result == -1 )
{
fprintf(
stderr,
"Unable to seek in handle.\n" );
goto on_error;
}
if( libewf_handle_close(
handle,
error ) != 0 )
{
fprintf(
stderr,
"Unable to close handle.\n" );
goto on_error;
}
if( libewf_handle_free(
&handle,
error ) != 1 )
{
fprintf(
stderr,
"Unable to free handle.\n" );
goto on_error;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libewf_glob_wide_free(
filenames,
number_of_filenames,
error ) != 1 )
#else
if( libewf_glob_free(
filenames,
number_of_filenames,
error ) != 1 )
#endif
{
fprintf(
stderr,
"Unable to free glob.\n" );
goto on_error;
}
return( result );
on_error:
if( handle != NULL )
{
libewf_handle_close(
handle,
NULL );
libewf_handle_free(
&handle,
NULL );
}
if( filenames != NULL )
{
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
libewf_glob_wide_free(
filenames,
number_of_filenames,
NULL );
#else
libewf_glob_free(
filenames,
number_of_filenames,
NULL );
#endif
}
return( -1 );
}
/* Opens a file
* Returns 0 if successful or a negative errno value otherwise
*/
int vshadowmount_fuse_open(
const char *path,
struct fuse_file_info *file_info )
{
libcerror_error_t *error = NULL;
static char *function = "vshadowmount_fuse_open";
size_t path_length = 0;
int result = 0;
if( path == NULL )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid path.",
function );
result = -EINVAL;
goto on_error;
}
if( file_info == NULL )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file info.",
function );
result = -EINVAL;
goto on_error;
}
path_length = libcstring_narrow_string_length(
path );
if( ( path_length <= vshadowmount_fuse_path_prefix_length )
|| ( path_length > ( vshadowmount_fuse_path_prefix_length + 3 ) )
|| ( libcstring_narrow_string_compare(
path,
vshadowmount_fuse_path_prefix,
vshadowmount_fuse_path_prefix_length ) != 0 ) )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported path.",
function );
result = -ENOENT;
goto on_error;
}
if( ( file_info->flags & 0x03 ) != O_RDONLY )
{
libcerror_error_set(
&error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
"%s: write access currently not supported.",
function );
result = -EACCES;
goto on_error;
}
return( 0 );
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
return( result );
}
/* Opens a file
* Returns 1 if successful or -1 on error
*/
int libmsiecf_file_open(
libmsiecf_file_t *file,
const char *filename,
int access_flags,
libcerror_error_t **error )
{
libbfio_handle_t *file_io_handle = NULL;
libmsiecf_internal_file_t *internal_file = NULL;
static char *function = "libmsiecf_file_open";
if( file == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid file.",
function );
return( -1 );
}
internal_file = (libmsiecf_internal_file_t *) file;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
if( ( ( access_flags & LIBMSIECF_ACCESS_FLAG_READ ) == 0 )
&& ( ( access_flags & LIBMSIECF_ACCESS_FLAG_WRITE ) == 0 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: unsupported access flags.",
function );
return( -1 );
}
if( ( access_flags & LIBMSIECF_ACCESS_FLAG_WRITE ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE,
"%s: write access currently not supported.",
function );
return( -1 );
}
if( libbfio_file_initialize(
&file_io_handle,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,
"%s: unable to create file IO handle.",
function );
goto on_error;
}
#if defined( HAVE_DEBUG_OUTPUT )
if( libbfio_handle_set_track_offsets_read(
file_io_handle,
1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set track offsets read in file IO handle.",
function );
goto on_error;
}
#endif
if( libbfio_file_set_name(
file_io_handle,
filename,
libcstring_narrow_string_length(
filename ) + 1,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to set filename in file IO handle.",
function );
goto on_error;
}
if( libmsiecf_file_open_file_io_handle(
file,
file_io_handle,
access_flags,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open file: %s.",
function,
filename );
goto on_error;
}
internal_file->file_io_handle_created_in_library = 1;
return( 1 );
on_error:
if( file_io_handle != NULL )
{
libbfio_handle_free(
&file_io_handle,
NULL );
}
return( -1 );
}
/* 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 );
}
