/* Sets the password * Returns 1 if successful or -1 on error */ int mount_handle_set_password( mount_handle_t *mount_handle, const libcstring_system_character_t *string, libcerror_error_t **error ) { static char *function = "mount_handle_set_password"; if( mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid mount handle.", function ); return( -1 ); } if( string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid string.", function ); return( -1 ); } mount_handle->password = string; mount_handle->password_length = libcstring_system_string_length( mount_handle->password ); return( 1 ); }
/* Sets the ascii codepage * Returns 1 if successful or -1 on error */ int info_handle_set_ascii_codepage( info_handle_t *info_handle, const libcstring_system_character_t *string, libcerror_error_t **error ) { static char *function = "info_handle_set_ascii_codepage"; size_t string_length = 0; uint32_t feature_flags = 0; int result = 0; if( info_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid info handle.", function ); return( -1 ); } feature_flags = LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_KOI8 | LIBCLOCALE_CODEPAGE_FEATURE_FLAG_HAVE_WINDOWS; string_length = libcstring_system_string_length( string ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) result = libclocale_codepage_copy_from_string_wide( &( info_handle->ascii_codepage ), string, string_length, feature_flags, error ); #else result = libclocale_codepage_copy_from_string( &( info_handle->ascii_codepage ), string, string_length, feature_flags, error ); #endif if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to determine ASCII codepage.", function ); return( -1 ); } return( result ); }
/* Retrieves a descriptive string of the error number * This function uses the POSIX strerror function or equivalent * Returns the string_length if successful or -1 on error */ int libcerror_system_copy_string_from_error_number( libcstring_system_character_t *string, size_t string_size, uint32_t error_number ) { #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) const wchar_t *static_error_string = NULL; #else const char *static_error_string = NULL; #endif size_t static_error_string_length = 0; if( string == NULL ) { return( -1 ); } if( string_size > (size_t) INT_MAX ) { return( -1 ); } /* Sanity check */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) && !defined( WINAPI ) #error Missing wide character strerror function #endif #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) static_error_string = _wcserror( (int) error_number ); #else static_error_string = strerror( (int) error_number ); #endif if( static_error_string == NULL ) { return( -1 ); } static_error_string_length = libcstring_system_string_length( static_error_string ); if( libcstring_system_string_copy( string, static_error_string, static_error_string_length ) == NULL ) { return( -1 ); } string[ static_error_string_length ] = 0; return( (int) static_error_string_length ); }
/* Sets the format * Returns 1 if successful, 0 if unsupported value or -1 on error */ int mount_handle_set_format( mount_handle_t *mount_handle, const libcstring_system_character_t *string, libcerror_error_t **error ) { static char *function = "mount_handle_set_format"; size_t string_length = 0; int result = 0; if( mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid mount handle.", function ); return( -1 ); } string_length = libcstring_system_string_length( string ); if( string_length == 3 ) { if( libcstring_system_string_compare( string, _LIBCSTRING_SYSTEM_STRING( "raw" ), 3 ) == 0 ) { mount_handle->input_format = MOUNT_HANDLE_INPUT_FORMAT_RAW; result = 1; } } else if( string_length == 5 ) { if( libcstring_system_string_compare( string, _LIBCSTRING_SYSTEM_STRING( "files" ), 5 ) == 0 ) { mount_handle->input_format = MOUNT_HANDLE_INPUT_FORMAT_FILES; result = 1; } } return( result ); }
/* Sets the volume offset * Returns 1 if successful or -1 on error */ int info_handle_set_volume_offset( info_handle_t *info_handle, const libcstring_system_character_t *string, libcerror_error_t **error ) { static char *function = "info_handle_set_volume_offset"; size_t string_length = 0; uint64_t value_64bit = 0; if( info_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid info handle.", function ); return( -1 ); } string_length = libcstring_system_string_length( string ); if( libcsystem_string_decimal_copy_to_64_bit( string, string_length + 1, &value_64bit, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy string to 64-bit decimal.", function ); return( -1 ); } info_handle->volume_offset = (off64_t) value_64bit; return( 1 ); }
/* Retrieves a descriptive string of the error number * This function uses the POSIX strerror_r function or equivalent * Returns the string_length if successful or -1 on error */ int libcerror_system_copy_string_from_error_number( libcstring_system_character_t *string, size_t string_size, uint32_t error_number ) { size_t string_length = 0; if( string == NULL ) { return( -1 ); } if( string_size > (size_t) INT_MAX ) { return( -1 ); } /* Sanity check */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) #error Missing wide character strerror_r function #endif #if defined( STRERROR_R_CHAR_P ) if( strerror_r( (int) error_number, string, string_size ) == NULL ) #else if( strerror_r( (int) error_number, string, string_size ) != 0 ) #endif { return( -1 ); } string[ string_size - 1 ] = (libcstring_system_character_t) 0; string_length = libcstring_system_string_length( string ); return( (int) string_length ); }
/* Retrieves a descriptive string of the error number * This function uses the Visual Studio C runtime library functions * Returns the string_length if successful or -1 on error */ int libcerror_system_copy_string_from_error_number( libcstring_system_character_t *string, size_t string_size, uint32_t error_number ) { size_t string_length = 0; if( string == NULL ) { return( -1 ); } if( string_size > (size_t) INT_MAX ) { return( -1 ); } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( _wcserror_s( string, string_size, (int) error_number ) != 0 ) #else if( strerror_s( string, string_size, (int) error_number ) != 0 ) #endif { return( -1 ); } string[ string_size - 1 ] = 0; string_length = libcstring_system_string_length( string ); return( (int) string_length ); }
/* Sets the volume key data * Returns 1 if successful or -1 on error */ int wipekey_handle_set_volume_key_data( wipekey_handle_t *wipekey_handle, const libcstring_system_character_t *string, libcerror_error_t **error ) { static char *function = "wipekey_handle_set_volume_key_data"; size_t string_length = 0; uint32_t base16_variant = 0; if( wipekey_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid wipekey handle.", function ); return( -1 ); } string_length = libcstring_system_string_length( string ); if( memory_set( wipekey_handle->volume_key_data, 0, 16 ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear volume key data.", function ); goto on_error; } base16_variant = LIBUNA_BASE16_VARIANT_RFC4648; #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( _BYTE_STREAM_HOST_IS_ENDIAN_BIG ) { base16_variant |= LIBUNA_BASE16_VARIANT_ENCODING_UTF16_BIG_ENDIAN; } else { base16_variant |= LIBUNA_BASE16_VARIANT_ENCODING_UTF16_LITTLE_ENDIAN; } #endif if( string_length != 32 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE, "%s: unsupported string length.", function ); goto on_error; } if( libuna_base16_stream_copy_to_byte_stream( (uint8_t *) string, string_length, wipekey_handle->volume_key_data, 16, base16_variant, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy volume key data.", function ); goto on_error; } return( 1 ); on_error: memory_set( wipekey_handle->volume_key_data, 0, 16 ); return( -1 ); }
/* Retrieves a descriptive string of the error number * Returns 1 if successful or -1 on error */ int libsmdev_error_string_copy_from_error_number( libcstring_system_character_t *string, size_t string_size, int error_number, liberror_error_t **error ) { static char *function = "libsmdev_error_string_copy_from_error_number"; #if ( defined( HAVE_STRERROR ) && !defined( HAVE_STRERROR_R ) && !defined( WINAPI ) ) || ( defined( WINAPI ) && defined( USE_CRT_FUNCTIONS ) && !defined( _MSC_VER ) ) #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) const wchar_t *static_error_string = NULL; #else const char *static_error_string = NULL; #endif size_t static_error_string_length = 0; #endif if( string == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid string.", function ); return( -1 ); } if( string_size > (size_t) SSIZE_MAX ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid string size value exceeds maximum.", function ); return( -1 ); } /* Use the WINAPI error string function */ #if defined( WINAPI ) && !defined( USE_CRT_FUNCTIONS ) #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( FormatMessageW( FORMAT_MESSAGE_FROM_SYSTEM, NULL, (DWORD) error_number, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), string, string_size, NULL ) == 0 ) #else if( FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM, NULL, (DWORD) error_number, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), string, string_size, NULL ) == 0 ) #endif { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } /* Use MSVSC++ specific CRT error string functions */ #elif defined( USE_CRT_FUNCTIONS ) && defined( _MSC_VER ) #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( _wcserror_s( string, string_size, error_number ) != 0 ) #else if( strerror_s( string, string_size, error_number ) != 0 ) #endif { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } /* Use POSIX specific error string functions */ #elif defined( HAVE_STRERROR_R ) /* Sanity check */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) #error Missing wide character strerror_r function #endif #if defined( STRERROR_R_CHAR_P ) if( strerror_r( error_number, string, string_size ) == NULL ) #else if( strerror_r( error_number, string, string_size ) != 0 ) #endif { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } /* Use the static error string function */ #elif defined( HAVE_STRERROR ) || defined( WINAPI ) /* Sanity check */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) && !defined( WINAPI ) #error Missing wide character strerror function #endif #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) static_error_string = _wcserror( error_number ); #else static_error_string = strerror( error_number ); #endif if( static_error_string == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to create static error string.", function ); return( -1 ); } static_error_string_length = libcstring_system_string_length( static_error_string ); if( libcstring_system_string_copy( string, static_error_string, static_error_string_length ) == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } string[ static_error_string_length ] = 0; #else #error Missing strerror function #endif return( 1 ); }
/* Resolves filenames with wildcards (globs) * Returns the number of results if successful or -1 on error */ int libsystem_glob_resolve( libsystem_glob_t *glob, libcstring_system_character_t * const patterns[], int number_of_patterns, liberror_error_t **error ) { #if defined( HAVE_IO_H ) || defined( WINAPI ) libsystem_find_data_t find_data; libcstring_system_character_t find_path[ _MAX_PATH ]; libcstring_system_character_t find_drive[ _MAX_DRIVE ]; libcstring_system_character_t find_directory[ _MAX_DIR ]; libcstring_system_character_t find_name[ _MAX_FNAME ]; libcstring_system_character_t find_extension[ _MAX_EXT ]; intptr_t find_handle = 0; #endif static char *function = "libsystem_glob_resolve"; size_t find_path_length = 0; int globs_found = 0; int iterator = 0; if( glob == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_ARGUMENTS, LIBERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid glob.", function ); return( -1 ); } for( iterator = 0; iterator < number_of_patterns; iterator++ ) { if( patterns[ iterator ] == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_VALUE_MISSING, "%s: missing pattern value.", function ); return( -1 ); } #if defined( _MSC_VER ) if( libsystem_path_split( patterns[ iterator ], find_drive, _MAX_DRIVE, find_directory, _MAX_DIR, find_name, _MAX_FNAME, find_extension, _MAX_EXT ) != 0 ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to split path.", function ); return( -1 ); } #else libsystem_path_split( patterns[ iterator ], find_drive, _MAX_DRIVE, find_directory, _MAX_DIR, find_name, _MAX_FNAME, find_extension, _MAX_EXT ); #endif find_handle = libsystem_find_first( patterns[ iterator ], &find_data ); if( find_handle != -1 ) { do { if( libsystem_glob_resize( glob, glob->number_of_results + 1, error ) != 1 ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_RESIZE_FAILED, "%s: unable to resize glob.", function ); return( -1 ); } #if defined( _MSC_VER ) if( libsystem_path_make( find_path, _MAX_PATH, find_drive, find_directory, find_data.name, _LIBCSTRING_SYSTEM_STRING( "" ) ) != 0 ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to make path.", function ); return( -1 ); } #elif defined( __BORLANDC__ ) && __BORLANDC__ <= 0x0520 libsystem_path_make( find_path, _MAX_PATH, find_drive, find_directory, find_data.ff_name, _LIBCSTRING_SYSTEM_STRING( "" ) ); #else libsystem_path_make( find_path, _MAX_PATH, find_drive, find_directory, find_data.name, _LIBCSTRING_SYSTEM_STRING( "" ) ); #endif find_path_length = libcstring_system_string_length( find_path ); glob->result[ glob->number_of_results - 1 ] = (libcstring_system_character_t *) memory_allocate( sizeof( libcstring_system_character_t ) * ( find_path_length + 1 ) ); if( glob->result[ glob->number_of_results - 1 ] == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_MEMORY, LIBERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create glob result.", function ); return( -1 ); } if( libcstring_system_string_copy( glob->result[ glob->number_of_results - 1 ], find_path, find_path_length ) == NULL ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set glob result.", function ); memory_free( glob->result[ glob->number_of_results - 1 ] ); glob->result[ glob->number_of_results - 1 ] = NULL; return( -1 ); } ( glob->result[ glob->number_of_results - 1 ] )[ find_path_length ] = 0; globs_found++; if( globs_found > (int32_t) UINT16_MAX ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS, "%s: too many globs found.", function ); return( -1 ); } } while( libsystem_find_next( find_handle, &find_data ) == 0 ); if( errno != ENOENT ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_GET_FAILED, "%s: error finding next file entry.", function ); return( -1 ); } if( libsystem_find_close( find_handle ) != 0 ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: error closing find handle.", function ); return( -1 ); } } else if( errno != ENOENT ) { liberror_error_set( error, LIBERROR_ERROR_DOMAIN_RUNTIME, LIBERROR_RUNTIME_ERROR_GET_FAILED, "%s: error finding file entry.", function ); return( -1 ); } } return( 1 ); }
/* Retrieves a ctime formatted string * The string must be at least 32 characters of size including the end of string character * Returns 1 if successful or -1 on error */ int process_status_get_ctime_string( const time_t *timestamp, libcstring_system_character_t *string, size_t string_size, libcerror_error_t **error ) { static char *function = "process_status_get_ctime_string"; #if ( defined( HAVE_CTIME ) && !defined( HAVE_CTIME_R ) ) || ( defined( WINAPI ) && !defined( _MSC_VER ) ) const libcstring_system_character_t *static_ctime_string = NULL; size_t static_ctime_string_length = 0; #endif if( timestamp == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid timestamp.", function ); return( -1 ); } if( string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid string.", function ); return( -1 ); } if( string_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid string size value exceeds maximum.", function ); return( -1 ); } if( string_size < 32 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL, "%s: string too small.", function ); return( -1 ); } #if defined( _MSC_VER ) #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( _wctime_s( string, string_size, timestamp ) != 0 ) #else if( ctime_s( string, string_size, timestamp ) != 0 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } #elif defined( HAVE_CTIME_R ) /* Sanity check */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) #error Missing wide character ctime_r function #endif #if defined( HAVE_CTIME_R_SIZE ) if( ctime_r( timestamp, string, string_size ) == NULL ) #else if( ctime_r( timestamp, string ) == NULL ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } #else /* Sanity check */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) && !defined( WINAPI ) #error Missing wide character ctime function #endif #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) static_ctime_string = _wctime( timestamp ); #else static_ctime_string = ctime( timestamp ); #endif if( static_ctime_string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to create static ctime string.", function ); return( -1 ); } static_ctime_string_length = libcstring_system_string_length( static_ctime_string ); if( libcstring_system_string_copy( string, static_ctime_string, static_ctime_string_length ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set string.", function ); return( -1 ); } string[ static_ctime_string_length ] = 0; #endif return( 1 ); }
/* Opens the mount handle * Returns 1 if successful or -1 on error */ int mount_handle_open_input( mount_handle_t *mount_handle, const libcstring_system_character_t *filename, libcerror_error_t **error ) { libbfio_handle_t *file_io_handle = NULL; libvslvm_logical_volume_t *logical_volume = NULL; static char *function = "mount_handle_open_input"; size_t filename_length = 0; int entry_index = 0; int logical_volume_index = 0; int number_of_logical_volumes = 0; int result = 0; if( mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid mount handle.", function ); return( -1 ); } if( libbfio_file_range_initialize( &file_io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize file IO handle.", function ); goto on_error; } filename_length = libcstring_system_string_length( filename ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbfio_file_range_set_name_wide( file_io_handle, filename, filename_length, error ) != 1 ) #else if( libbfio_file_range_set_name( file_io_handle, filename, filename_length, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set file name.", function ); goto on_error; } if( libbfio_file_range_set( file_io_handle, mount_handle->volume_offset, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set volume offset.", function ); goto on_error; } if( libvslvm_handle_open_file_io_handle( mount_handle->input_handle, file_io_handle, LIBVSLVM_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input handle.", function ); goto on_error; } if( libbfio_pool_append_handle( mount_handle->physical_volume_file_io_pool, &entry_index, file_io_handle, LIBBFIO_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input handle.", function ); goto on_error; } /* The takes over management of the file IO handle */ file_io_handle = NULL; /* TODO determine if the first file is a metadata only file and change filenames accordingly */ if( libvslvm_handle_open_physical_volume_files_file_io_pool( mount_handle->input_handle, mount_handle->physical_volume_file_io_pool, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open physical volume files.", function ); goto on_error; } if( libvslvm_handle_get_volume_group( mount_handle->input_handle, &( mount_handle->volume_group ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve volume group.", function ); goto on_error; } if( libvslvm_volume_group_get_number_of_logical_volumes( mount_handle->volume_group, &number_of_logical_volumes, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve number of logical volumes.", function ); goto on_error; } for( logical_volume_index = 0; logical_volume_index < number_of_logical_volumes; logical_volume_index++ ) { if( libvslvm_volume_group_get_logical_volume( mount_handle->volume_group, logical_volume_index, &logical_volume, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve logical volume: %d.", function, logical_volume_index ); goto on_error; } if( libcdata_array_append_entry( mount_handle->logical_volumes_array, &entry_index, (intptr_t *) logical_volume, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_APPEND_FAILED, "%s: unable to append logical volume to array.", function ); goto on_error; } logical_volume = NULL; } return( 1 ); on_error: if( logical_volume != NULL ) { libvslvm_logical_volume_free( &logical_volume, NULL ); } if( mount_handle->volume_group != NULL ) { libvslvm_volume_group_free( &( mount_handle->volume_group ), NULL ); } if( mount_handle->input_handle != NULL ) { libvslvm_handle_free( &( mount_handle->input_handle ), NULL ); } if( file_io_handle != NULL ) { libbfio_handle_free( &file_io_handle, NULL ); } libcdata_array_empty( mount_handle->logical_volumes_array, (int (*)(intptr_t **, libcerror_error_t **)) &libvslvm_logical_volume_free, NULL ); return( -1 ); }
int main( int argc, char * const argv[] ) #endif { libcstring_system_character_t acquiry_operating_system[ 32 ]; libcstring_system_character_t input_buffer[ EWFEXPORT_INPUT_BUFFER_SIZE ]; libcstring_system_character_t * const *argv_filenames = NULL; liberror_error_t *error = NULL; #if !defined( LIBSYSTEM_HAVE_GLOB ) libsystem_glob_t *glob = NULL; #endif libcstring_system_character_t *acquiry_software_version = NULL; libcstring_system_character_t *log_filename = NULL; libcstring_system_character_t *option_additional_digest_types = NULL; libcstring_system_character_t *option_compression_level = NULL; libcstring_system_character_t *option_format = NULL; libcstring_system_character_t *option_header_codepage = NULL; libcstring_system_character_t *option_maximum_segment_size = NULL; libcstring_system_character_t *option_offset = NULL; libcstring_system_character_t *option_process_buffer_size = NULL; libcstring_system_character_t *option_sectors_per_chunk = NULL; libcstring_system_character_t *option_size = NULL; libcstring_system_character_t *option_target_filename = NULL; libcstring_system_character_t *program = _LIBCSTRING_SYSTEM_STRING( "ewfexport" ); libcstring_system_character_t *request_string = NULL; log_handle_t *log_handle = NULL; libcstring_system_integer_t option = 0; size64_t media_size = 0; size_t string_length = 0; uint8_t calculate_md5 = 1; uint8_t print_status_information = 1; uint8_t swap_byte_pairs = 0; uint8_t verbose = 0; uint8_t zero_chunk_on_error = 0; int interactive_mode = 1; int number_of_filenames = 0; int result = 1; libsystem_notify_set_stream( stderr, NULL ); libsystem_notify_set_verbose( 1 ); if( libsystem_initialize( "ewftools", &error ) != 1 ) { ewfoutput_version_fprint( stderr, program ); fprintf( stderr, "Unable to initialize system values.\n" ); goto on_error; } #if defined( WINAPI ) && !defined( __CYGWIN__ ) #if defined( _MSC_VER ) if( _setmode( _fileno( stdout ), _O_BINARY ) == -1 ) #else if( setmode( _fileno( stdout ), _O_BINARY ) == -1 ) #endif { ewfoutput_version_fprint( stderr, program ); fprintf( stderr, "Unable to set stdout to binary mode.\n" ); usage_fprint( stdout ); goto on_error; } #endif while( ( option = libsystem_getopt( argc, argv, _LIBCSTRING_SYSTEM_STRING( "A:b:B:c:d:f:hl:o:p:qsS:t:uvVw" ) ) ) != (libcstring_system_integer_t) -1 ) { switch( option ) { case (libcstring_system_integer_t) '?': default: ewfoutput_version_fprint( stderr, program ); fprintf( stderr, "Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n", argv[ optind - 1 ] ); usage_fprint( stderr ); goto on_error; case (libcstring_system_integer_t) 'A': option_header_codepage = optarg; break; case (libcstring_system_integer_t) 'b': option_sectors_per_chunk = optarg; break; case (libcstring_system_integer_t) 'B': option_size = optarg; break; case (libcstring_system_integer_t) 'c': option_compression_level = optarg; break; case (libcstring_system_integer_t) 'd': option_additional_digest_types = optarg; break; case (libcstring_system_integer_t) 'f': option_format = optarg; break; case (libcstring_system_integer_t) 'h': ewfoutput_version_fprint( stderr, program ); usage_fprint( stderr ); return( EXIT_SUCCESS ); case (libcstring_system_integer_t) 'l': log_filename = optarg; break; case (libcstring_system_integer_t) 'o': option_offset = optarg; break; case (libcstring_system_integer_t) 'p': option_process_buffer_size = optarg; break; case (libcstring_system_integer_t) 'q': print_status_information = 0; break; case (libcstring_system_integer_t) 's': swap_byte_pairs = 1; break; case (libcstring_system_integer_t) 'S': option_maximum_segment_size = optarg; break; case (libcstring_system_integer_t) 't': option_target_filename = optarg; break; case (libcstring_system_integer_t) 'u': interactive_mode = 0; break; case (libcstring_system_integer_t) 'v': verbose = 1; break; case (libcstring_system_integer_t) 'V': ewfoutput_version_fprint( stderr, program ); ewfoutput_copyright_fprint( stderr ); return( EXIT_SUCCESS ); case (libcstring_system_integer_t) 'w': zero_chunk_on_error = 1; break; } } if( optind == argc ) { ewfoutput_version_fprint( stderr, program ); fprintf( stderr, "Missing EWF image file(s).\n" ); usage_fprint( stderr ); goto on_error; } ewfoutput_version_fprint( stderr, program ); libsystem_notify_set_verbose( verbose ); libewf_notify_set_verbose( verbose ); libewf_notify_set_stream( stderr, NULL ); #if !defined( LIBSYSTEM_HAVE_GLOB ) if( libsystem_glob_initialize( &glob, &error ) != 1 ) { fprintf( stderr, "Unable to initialize glob.\n" ); goto on_error; } if( libsystem_glob_resolve( glob, &( argv[ optind ] ), argc - optind, &error ) != 1 ) { fprintf( stderr, "Unable to resolve glob.\n" ); goto on_error; } argv_filenames = glob->result; number_of_filenames = glob->number_of_results; #else argv_filenames = &( argv[ optind ] ); number_of_filenames = argc - optind; #endif if( export_handle_initialize( &ewfexport_export_handle, calculate_md5, &error ) != 1 ) { fprintf( stderr, "Unable to create export handle.\n" ); goto on_error; } if( libsystem_signal_attach( ewfexport_signal_handler, &error ) != 1 ) { fprintf( stderr, "Unable to attach signal handler.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } result = export_handle_open_input( ewfexport_export_handle, argv_filenames, number_of_filenames, &error ); if( ewfexport_abort != 0 ) { goto on_abort; } if( result != 1 ) { fprintf( stderr, "Unable to open EWF file(s).\n" ); goto on_error; } #if !defined( LIBSYSTEM_HAVE_GLOB ) if( libsystem_glob_free( &glob, &error ) != 1 ) { fprintf( stderr, "Unable to free glob.\n" ); goto on_error; } #endif if( export_handle_get_input_media_size( ewfexport_export_handle, &media_size, &error ) != 1 ) { fprintf( stderr, "Unable to retrieve input media size.\n" ); goto on_error; } if( option_header_codepage != NULL ) { result = export_handle_set_header_codepage( ewfexport_export_handle, option_header_codepage, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set header codepage.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stderr, "Unsupported header codepage defaulting to: ascii.\n" ); } } if( option_target_filename != NULL ) { if( export_handle_set_string( ewfexport_export_handle, option_target_filename, &( ewfexport_export_handle->target_filename ), &( ewfexport_export_handle->target_filename_size ), &error ) != 1 ) { fprintf( stderr, "Unable to set target filename.\n" ); goto on_error; } } else if( interactive_mode == 0 ) { /* Make sure the target filename is set in unattended mode */ if( export_handle_set_string( ewfexport_export_handle, _LIBCSTRING_SYSTEM_STRING( "export" ), &( ewfexport_export_handle->target_filename ), &( ewfexport_export_handle->target_filename_size ), &error ) != 1 ) { fprintf( stderr, "Unable to set target filename.\n" ); goto on_error; } } if( option_compression_level != NULL ) { result = export_handle_set_compression_values( ewfexport_export_handle, option_compression_level, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set compression values.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stderr, "Unsupported compression level defaulting to: none.\n" ); } } if( option_format != NULL ) { result = export_handle_set_format( ewfexport_export_handle, option_format, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set format.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stderr, "Unsupported output format defaulting to: raw.\n" ); } } if( option_sectors_per_chunk != NULL ) { result = export_handle_set_sectors_per_chunk( ewfexport_export_handle, option_sectors_per_chunk, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set sectors per chunk.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stderr, "Unsupported sectors per chunk defaulting to: 64.\n" ); } } if( option_maximum_segment_size != NULL ) { result = export_handle_set_maximum_segment_size( ewfexport_export_handle, option_maximum_segment_size, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set maximum segment size.\n" ); goto on_error; } if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF ) { if( ( result == 0 ) || ( ewfexport_export_handle->maximum_segment_size < EWFCOMMON_MINIMUM_SEGMENT_FILE_SIZE ) || ( ( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 ) && ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) ) || ( ( ewfexport_export_handle->ewf_format != LIBEWF_FORMAT_ENCASE6 ) && ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT ) ) ) { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE; fprintf( stderr, "Unsupported maximum segment size defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->maximum_segment_size ); } } else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) { if( ( result == 0 ) || ( ( ewfexport_export_handle->maximum_segment_size != 0 ) && ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) ) ) { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE; fprintf( stderr, "Unsupported maximum segment size defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->maximum_segment_size ); } } } if( option_offset != NULL ) { string_length = libcstring_system_string_length( option_offset ); if( libsystem_string_to_uint64( option_offset, string_length + 1, &ewfexport_export_handle->export_offset, &error ) != 1 ) { libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); ewfexport_export_handle->export_offset = 0; fprintf( stderr, "Unsupported export offset defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->export_offset ); } } if( option_size != NULL ) { string_length = libcstring_system_string_length( option_size ); if( libsystem_string_to_uint64( option_size, string_length + 1, &ewfexport_export_handle->export_size, &error ) != 1 ) { libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); ewfexport_export_handle->export_size = 0; fprintf( stderr, "Unsupported export size defaulting to: all bytes.\n" ); } } if( option_process_buffer_size != NULL ) { result = export_handle_set_process_buffer_size( ewfexport_export_handle, option_process_buffer_size, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set process buffer size.\n" ); goto on_error; } else if( ( result == 0 ) || ( ewfexport_export_handle->process_buffer_size > (size_t) SSIZE_MAX ) ) { ewfexport_export_handle->process_buffer_size = 0; fprintf( stderr, "Unsupported process buffer size defaulting to: chunk size.\n" ); } } if( option_additional_digest_types != NULL ) { result = export_handle_set_additional_digest_types( ewfexport_export_handle, option_additional_digest_types, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set additional digest types.\n" ); goto on_error; } } /* Initialize values */ if( ( ewfexport_export_handle->export_size == 0 ) || ( ewfexport_export_handle->export_size > ( media_size - ewfexport_export_handle->export_offset ) ) ) { ewfexport_export_handle->export_size = media_size - ewfexport_export_handle->export_offset; } /* Request the necessary case data */ if( interactive_mode != 0 ) { if( libsystem_signal_detach( &error ) != 1 ) { fprintf( stderr, "Unable to detach signal handler.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } fprintf( stderr, "Information for export required, please provide the necessary input\n" ); if( option_format == NULL ) { result = export_handle_prompt_for_format( ewfexport_export_handle, _LIBCSTRING_SYSTEM_STRING( "Export to format" ), &error ); if( result == -1 ) { fprintf( stderr, "Unable to determine format.\n" ); goto on_error; } } if( option_target_filename == NULL ) { if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF ) { request_string = _LIBCSTRING_SYSTEM_STRING( "Target path and filename without extension" ); } else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_FILES ) { request_string = _LIBCSTRING_SYSTEM_STRING( "Target path" ); } else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) { request_string = _LIBCSTRING_SYSTEM_STRING( "Target path and filename without extension or - for stdout" ); } } if( request_string != NULL ) { do { result = export_handle_prompt_for_string( ewfexport_export_handle, request_string, &( ewfexport_export_handle->target_filename ), &( ewfexport_export_handle->target_filename_size ), &error ); if( result == -1 ) { fprintf( stderr, "Unable to determine target.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stdout, "Target is required, please try again or terminate using Ctrl^C.\n" ); } } while( result != 1 ); } if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF ) { if( option_compression_level == NULL ) { result = export_handle_prompt_for_compression_level( ewfexport_export_handle, _LIBCSTRING_SYSTEM_STRING( "Use compression" ), &error ); if( result == -1 ) { fprintf( stderr, "Unable to determine compression level.\n" ); goto on_error; } } if( option_maximum_segment_size == NULL ) { result = export_handle_prompt_for_maximum_segment_size( ewfexport_export_handle, _LIBCSTRING_SYSTEM_STRING( "Evidence segment file size in bytes" ), &error ); if( result == -1 ) { fprintf( stderr, "Unable to determine maximum segment size.\n" ); goto on_error; } if( ( ewfexport_export_handle->maximum_segment_size < EWFCOMMON_MINIMUM_SEGMENT_FILE_SIZE ) || ( ( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 ) && ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) ) || ( ( ewfexport_export_handle->ewf_format != LIBEWF_FORMAT_ENCASE6 ) && ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT ) ) ) { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE; fprintf( stderr, "Unsupported maximum segment size defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->maximum_segment_size ); } } if( option_sectors_per_chunk == NULL ) { result = export_handle_prompt_for_sectors_per_chunk( ewfexport_export_handle, _LIBCSTRING_SYSTEM_STRING( "The number of sectors to read at once" ), &error ); if( result == -1 ) { fprintf( stderr, "Unable to determine sectors per chunk.\n" ); goto on_error; } } } else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) { if( ( ewfexport_export_handle->target_filename != NULL ) && ( ( ewfexport_export_handle->target_filename )[ 0 ] == (libcstring_system_character_t) '-' ) && ( ( ewfexport_export_handle->target_filename )[ 1 ] == 0 ) ) { /* No need for segment files when exporting to stdout */ } else if( option_maximum_segment_size == NULL ) { result = export_handle_prompt_for_maximum_segment_size( ewfexport_export_handle, _LIBCSTRING_SYSTEM_STRING( "Evidence segment file size in bytes (0 is unlimited)" ), &error ); if( result == -1 ) { fprintf( stderr, "Unable to determine maximum segment size.\n" ); goto on_error; } if( ( ewfexport_export_handle->maximum_segment_size != 0 ) && ( ewfexport_export_handle->maximum_segment_size >= (uint64_t) EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT ) ) { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_DEFAULT_SEGMENT_FILE_SIZE; fprintf( stderr, "Unsupported maximum segment size defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->maximum_segment_size ); } } } if( ( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF ) || ( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) ) { if( option_offset == NULL ) { if( ewfinput_get_size_variable( stderr, input_buffer, EWFEXPORT_INPUT_BUFFER_SIZE, _LIBCSTRING_SYSTEM_STRING( "Start export at offset" ), 0, media_size, ewfexport_export_handle->export_offset, &( ewfexport_export_handle->export_offset ), &error ) == -1 ) { libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); ewfexport_export_handle->export_offset = 0; fprintf( stderr, "Unable to determine export offset defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->export_offset ); } } if( option_size == NULL ) { if( ewfinput_get_size_variable( stderr, input_buffer, EWFEXPORT_INPUT_BUFFER_SIZE, _LIBCSTRING_SYSTEM_STRING( "Number of bytes to export" ), 0, media_size - ewfexport_export_handle->export_offset, ewfexport_export_handle->export_size, &( ewfexport_export_handle->export_size ), &error ) == -1 ) { libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); ewfexport_export_handle->export_size = media_size - ewfexport_export_handle->export_offset; fprintf( stderr, "Unable to determine export size defaulting to: %" PRIu64 ".\n", ewfexport_export_handle->export_size ); } } } if( libsystem_signal_attach( ewfexport_signal_handler, &error ) != 1 ) { fprintf( stderr, "Unable to attach signal handler.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } } else { if( ewfexport_export_handle->maximum_segment_size == 0 ) { if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_EWF ) { if( ewfexport_export_handle->ewf_format == LIBEWF_FORMAT_ENCASE6 ) { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT; } else { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_32BIT; } } else if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_RAW ) { ewfexport_export_handle->maximum_segment_size = EWFCOMMON_MAXIMUM_SEGMENT_FILE_SIZE_64BIT; } } } fprintf( stderr, "\n" ); if( log_filename != NULL ) { if( log_handle_initialize( &log_handle, &error ) != 1 ) { fprintf( stderr, "Unable to create log handle.\n" ); goto on_error; } if( log_handle_open( log_handle, log_filename, &error ) != 1 ) { fprintf( stderr, "Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n", log_filename ); goto on_error; } } if( ewfexport_export_handle->output_format == EXPORT_HANDLE_OUTPUT_FORMAT_FILES ) { result = export_handle_export_single_files( ewfexport_export_handle, ewfexport_export_handle->target_filename, print_status_information, log_handle, &error ); if( result != 1 ) { fprintf( stderr, "Unable to export single files.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } } else { if( export_handle_open_output( ewfexport_export_handle, ewfexport_export_handle->target_filename, &error ) != 1 ) { fprintf( stderr, "Unable to open output.\n" ); goto on_error; } if( platform_get_operating_system( acquiry_operating_system, 32, &error ) != 1 ) { fprintf( stderr, "Unable to determine operating system.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); acquiry_operating_system[ 0 ] = 0; } acquiry_software_version = _LIBCSTRING_SYSTEM_STRING( LIBEWF_VERSION_STRING ); if( export_handle_set_output_values( ewfexport_export_handle, acquiry_operating_system, program, acquiry_software_version, zero_chunk_on_error, &error ) != 1 ) { fprintf( stderr, "Unable to set output values.\n" ); goto on_error; } result = export_handle_export_input( ewfexport_export_handle, swap_byte_pairs, print_status_information, log_handle, &error ); if( result != 1 ) { fprintf( stderr, "Unable to export input.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } } if( log_handle != NULL ) { if( log_handle_close( log_handle, &error ) != 0 ) { fprintf( stderr, "Unable to close log file: %" PRIs_LIBCSTRING_SYSTEM ".\n", log_filename ); goto on_error; } if( log_handle_free( &log_handle, &error ) != 1 ) { fprintf( stderr, "Unable to free log handle.\n" ); goto on_error; } } on_abort: if( export_handle_close( ewfexport_export_handle, &error ) != 0 ) { fprintf( stderr, "Unable to close export handle.\n" ); goto on_error; } if( libsystem_signal_detach( &error ) != 1 ) { fprintf( stderr, "Unable to detach signal handler.\n" ); libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } if( export_handle_free( &ewfexport_export_handle, &error ) != 1 ) { fprintf( stderr, "Unable to free export handle.\n" ); goto on_error; } if( ewfexport_abort != 0 ) { fprintf( stdout, "%" PRIs_LIBCSTRING_SYSTEM ": ABORTED\n", program ); return( EXIT_FAILURE ); } if( result != 1 ) { fprintf( stdout, "%" PRIs_LIBCSTRING_SYSTEM ": FAILURE\n", program ); return( EXIT_FAILURE ); } fprintf( stdout, "%" PRIs_LIBCSTRING_SYSTEM ": SUCCESS\n", program ); return( EXIT_SUCCESS ); on_error: if( error != NULL ) { libsystem_notify_print_error_backtrace( error ); liberror_error_free( &error ); } if( log_handle != NULL ) { log_handle_close( log_handle, NULL ); log_handle_free( &log_handle, NULL ); } if( ewfexport_export_handle != NULL ) { export_handle_close( ewfexport_export_handle, NULL ); export_handle_free( &ewfexport_export_handle, NULL ); } #if !defined( LIBSYSTEM_HAVE_GLOB ) if( glob != NULL ) { libsystem_glob_free( &glob, NULL ); } #endif return( EXIT_FAILURE ); }
int main( int argc, char * const argv[] ) #endif { libcstring_system_character_t *option_chunk_size = NULL; libcstring_system_character_t *option_compression_level = NULL; libcstring_system_character_t *option_maximum_segment_size = NULL; libcstring_system_character_t *option_media_size = NULL; libcerror_error_t *error = NULL; libcstring_system_integer_t option = 0; size64_t chunk_size = 0; size64_t maximum_segment_size = 0; size64_t media_size = 0; size_t string_length = 0; uint8_t compression_flags = 0; int8_t compression_level = LIBEWF_COMPRESSION_NONE; while( ( option = libcsystem_getopt( argc, argv, _LIBCSTRING_SYSTEM_STRING( "b:B:c:S:" ) ) ) != (libcstring_system_integer_t) -1 ) { switch( option ) { case (libcstring_system_integer_t) '?': default: fprintf( stderr, "Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n", argv[ optind - 1 ] ); return( EXIT_FAILURE ); case (libcstring_system_integer_t) 'b': option_chunk_size = optarg; break; case (libcstring_system_integer_t) 'c': option_compression_level = optarg; break; case (libcstring_system_integer_t) 'B': option_media_size = optarg; break; case (libcstring_system_integer_t) 'S': option_maximum_segment_size = optarg; break; } } if( optind == argc ) { fprintf( stderr, "Missing EWF image filename.\n" ); return( EXIT_FAILURE ); } if( option_chunk_size != NULL ) { string_length = libcstring_system_string_length( option_chunk_size ); if( libcsystem_string_decimal_copy_to_64_bit( option_chunk_size, string_length + 1, &chunk_size, &error ) != 1 ) { fprintf( stderr, "Unsupported chunk size.\n" ); goto on_error; } } if( option_compression_level != NULL ) { string_length = libcstring_system_string_length( option_compression_level ); if( string_length != 1 ) { fprintf( stderr, "Unsupported compression level.\n" ); goto on_error; } if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'n' ) { compression_level = LIBEWF_COMPRESSION_NONE; compression_flags = 0; } else if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'e' ) { compression_level = LIBEWF_COMPRESSION_NONE; compression_flags = LIBEWF_COMPRESS_FLAG_USE_EMPTY_BLOCK_COMPRESSION; } else if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'f' ) { compression_level = LIBEWF_COMPRESSION_FAST; compression_flags = 0; } else if( option_compression_level[ 0 ] == (libcstring_system_character_t) 'b' ) { compression_level = LIBEWF_COMPRESSION_BEST; compression_flags = 0; } else { fprintf( stderr, "Unsupported compression level.\n" ); goto on_error; } } if( option_maximum_segment_size != NULL ) { string_length = libcstring_system_string_length( option_maximum_segment_size ); if( libcsystem_string_decimal_copy_to_64_bit( option_maximum_segment_size, string_length + 1, &maximum_segment_size, &error ) != 1 ) { fprintf( stderr, "Unsupported maximum segment size.\n" ); goto on_error; } } if( option_media_size != NULL ) { string_length = libcstring_system_string_length( option_media_size ); if( libcsystem_string_decimal_copy_to_64_bit( option_media_size, string_length + 1, &media_size, &error ) != 1 ) { fprintf( stderr, "Unsupported media size.\n" ); goto on_error; } } if( ewf_test_write_chunk( argv[ optind ], media_size, maximum_segment_size, compression_level, compression_flags, &error ) != 1 ) { fprintf( stderr, "Unable to test write.\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 *option_offset = NULL; libcstring_system_character_t *option_size = NULL; libcstring_system_character_t *target_filename = NULL; libcerror_error_t *error = NULL; libcstring_system_integer_t option = 0; off64_t write_offset = 0; size64_t write_size = 0; size_t string_length = 0; while( ( option = libcsystem_getopt( argc, argv, _LIBCSTRING_SYSTEM_STRING( "B:o:t:" ) ) ) != (libcstring_system_integer_t) -1 ) { switch( option ) { case (libcstring_system_integer_t) '?': default: fprintf( stderr, "Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n", argv[ optind - 1 ] ); return( EXIT_FAILURE ); case (libcstring_system_integer_t) 'B': option_size = optarg; break; case (libcstring_system_integer_t) 'o': option_offset = optarg; break; case (libcstring_system_integer_t) 't': target_filename = optarg; break; } } if( optind == argc ) { fprintf( stderr, "Missing EWF image filename(s).\n" ); return( EXIT_FAILURE ); } if( option_offset != NULL ) { string_length = libcstring_system_string_length( option_offset ); if( libcsystem_string_decimal_copy_to_64_bit( option_offset, string_length + 1, (uint64_t *) &write_offset, &error ) != 1 ) { fprintf( stderr, "Unsupported write offset.\n" ); goto on_error; } } if( option_size != NULL ) { string_length = libcstring_system_string_length( option_size ); if( libcsystem_string_decimal_copy_to_64_bit( option_size, string_length + 1, &write_size, &error ) != 1 ) { fprintf( stderr, "Unsupported write size.\n" ); goto on_error; } } if( ewf_test_read_write_delta( &( argv[ optind ] ), argc - optind, target_filename, write_offset, write_size, &error ) != 1 ) { fprintf( stderr, "Unable to test read/write.\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 { export_handle_t *olecfexport_export_handle = NULL; libcerror_error_t *error = NULL; log_handle_t *log_handle = NULL; libcstring_system_character_t *log_filename = NULL; libcstring_system_character_t *option_ascii_codepage = NULL; libcstring_system_character_t *option_target_path = NULL; libcstring_system_character_t *path_separator = NULL; libcstring_system_character_t *source = NULL; char *program = "olecfexport"; size_t source_length = 0; libcstring_system_integer_t option = 0; int result = 0; int verbose = 0; libcnotify_stream_set( stderr, NULL ); libcnotify_verbose_set( 1 ); if( libclocale_initialize( "olecftools", &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; } olecfoutput_version_fprint( stdout, program ); while( ( option = libcsystem_getopt( argc, argv, _LIBCSTRING_SYSTEM_STRING( "c:hl:t:vV" ) ) ) != (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) 'c': option_ascii_codepage = optarg; break; case (libcstring_system_integer_t) 'h': usage_fprint( stdout ); return( EXIT_SUCCESS ); case (libcstring_system_integer_t) 'l': log_filename = optarg; break; case (libcstring_system_integer_t) 't': option_target_path = optarg; break; case (libcstring_system_integer_t) 'v': verbose = 1; break; case (libcstring_system_integer_t) 'V': olecfoutput_copyright_fprint( stdout ); return( EXIT_SUCCESS ); } } if( optind == argc ) { fprintf( stderr, "Missing source file.\n" ); usage_fprint( stdout ); return( EXIT_FAILURE ); } source = argv[ optind ]; if( option_target_path == NULL ) { source_length = libcstring_system_string_length( source ); path_separator = libcstring_system_string_search_character_reverse( source, (libcstring_system_character_t) LIBCPATH_SEPARATOR, source_length ); if( path_separator == NULL ) { path_separator = source; } else { path_separator++; } option_target_path = path_separator; } libcnotify_verbose_set( verbose ); libolecf_notify_set_stream( stderr, NULL ); libolecf_notify_set_verbose( verbose ); if( export_handle_initialize( &olecfexport_export_handle, &error ) != 1 ) { fprintf( stderr, "Unable to initialize export handle.\n" ); goto on_error; } if( export_handle_set_target_path( olecfexport_export_handle, option_target_path, &error ) != 1 ) { fprintf( stderr, "Unable to set target path.\n" ); goto on_error; } result = export_handle_create_items_export_path( olecfexport_export_handle, &error ); if( result == -1 ) { fprintf( stderr, "Unable to create items export path.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stderr, "%" PRIs_LIBCSTRING_SYSTEM " already exists.\n", olecfexport_export_handle->items_export_path ); goto on_error; } if( log_handle_initialize( &log_handle, &error ) != 1 ) { fprintf( stderr, "Unable to initialize log handle.\n" ); goto on_error; } if( log_handle_open( log_handle, log_filename, &error ) != 1 ) { fprintf( stderr, "Unable to open log file: %" PRIs_LIBCSTRING_SYSTEM ".\n", log_filename ); goto on_error; } if( option_ascii_codepage != NULL ) { result = export_handle_set_ascii_codepage( olecfexport_export_handle, option_ascii_codepage, &error ); if( result == -1 ) { fprintf( stderr, "Unable to set ASCII codepage in export handle.\n" ); goto on_error; } else if( result == 0 ) { fprintf( stderr, "Unsupported ASCII codepage defaulting to: windows-1252.\n" ); } } fprintf( stdout, "Opening file.\n" ); if( export_handle_open_input( olecfexport_export_handle, source, &error ) != 1 ) { fprintf( stderr, "Unable to open: %" PRIs_LIBCSTRING_SYSTEM ".\n", source ); goto on_error; } if( export_handle_export_file( olecfexport_export_handle, log_handle, &error ) != 1 ) { fprintf( stderr, "Unable to export file stream and storage items.\n" ); goto on_error; } if( export_handle_close( olecfexport_export_handle, &error ) != 0 ) { fprintf( stderr, "Unable to close export handle.\n" ); goto on_error; } if( export_handle_free( &olecfexport_export_handle, &error ) != 1 ) { fprintf( stderr, "Unable to free export handle.\n" ); goto on_error; } if( log_handle_close( log_handle, &error ) != 0 ) { fprintf( stderr, "Unable to close log file: %" PRIs_LIBCSTRING_SYSTEM ".\n", log_filename ); goto on_error; } if( log_handle_free( &log_handle, &error ) != 1 ) { fprintf( stderr, "Unable to free log handle.\n" ); goto on_error; } fprintf( stdout, "Export completed.\n" ); return( EXIT_SUCCESS ); on_error: if( error != NULL ) { libcnotify_print_error_backtrace( error ); libcerror_error_free( &error ); } if( log_handle != NULL ) { log_handle_close( log_handle, NULL ); log_handle_free( &log_handle, NULL ); } if( olecfexport_export_handle != NULL ) { export_handle_close( olecfexport_export_handle, NULL ); export_handle_free( &olecfexport_export_handle, NULL ); } return( EXIT_FAILURE ); }
int main( int argc, char * const argv[] ) #endif { libcerror_error_t *error = NULL; liblnk_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( liblnk_file_initialize( &file, &error ) != 1 ) { fprintf( stderr, "Unable to create file.\n" ); goto on_error; } if( liblnk_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( liblnk_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 ) { liblnk_file_free( &file, NULL ); } return( -1 ); }
/* Tests reading/writing data of a specific size at a specific offset * Return 1 if successful, 0 if not or -1 on error */ int ewf_test_read_write_delta( libcstring_system_character_t * const filenames[], int number_of_filenames, const libcstring_system_character_t *delta_segment_filename, off64_t write_offset, size64_t write_size, libcerror_error_t **error ) { libewf_handle_t *handle = NULL; uint8_t *buffer = NULL; static char *function = "ewf_test_read_write_delta"; size_t delta_segment_filename_length = 0; size_t read_size = 0; ssize_t read_count = 0; ssize_t write_count = 0; if( libewf_handle_initialize( &handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create handle.", function ); goto on_error; } #if defined( HAVE_DEBUG_OUTPUT ) && defined( EWF_TEST_READ_WRITE_DELTA_VERBOSE ) libewf_notify_set_verbose( 1 ); libewf_notify_set_stream( stderr, NULL ); #endif #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_handle_open_wide( handle, filenames, number_of_filenames, LIBEWF_OPEN_READ_WRITE, error ) != 1 ) #else if( libewf_handle_open( handle, filenames, number_of_filenames, LIBEWF_OPEN_READ_WRITE, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open handle.", function ); goto on_error; } if( delta_segment_filename != NULL ) { delta_segment_filename_length = libcstring_system_string_length( delta_segment_filename ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_handle_set_delta_segment_filename_wide( handle, delta_segment_filename, delta_segment_filename_length, error ) != 1 ) #else if( libewf_handle_set_delta_segment_filename( handle, delta_segment_filename, delta_segment_filename_length, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set delta segment filename.", function ); goto on_error; } } if( libewf_handle_seek_offset( handle, write_offset, SEEK_SET, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to seek offset: %" PRIi64 ".", function, write_offset ); goto on_error; } buffer = (uint8_t *) memory_allocate( EWF_TEST_BUFFER_SIZE ); while( write_size > 0 ) { if( write_size > (size64_t) EWF_TEST_BUFFER_SIZE ) { read_size = EWF_TEST_BUFFER_SIZE; } else { read_size = (size_t) write_size; } read_count = libewf_handle_read_buffer( handle, buffer, read_size, error ); if( read_count < 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_WRITE_FAILED, "%s: unable read buffer of size: %" PRIzd ".", function, read_size ); goto on_error; } if( memory_set( buffer, (int) 'X', (size_t) read_count ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable set value in buffer.", function ); goto on_error; } if( libewf_handle_seek_offset( handle, -1 * (off64_t) read_size, SEEK_CUR, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to seek previous offset.", function ); goto on_error; } write_count = libewf_handle_write_buffer( handle, buffer, (size_t) read_count, error ); if( write_count < 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_WRITE_FAILED, "%s: unable write buffer of size: %" PRIzd ".", function, read_count ); goto on_error; } if( write_count != read_count ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_WRITE_FAILED, "%s: unable write buffer of size: %" PRIzd ".", function, read_count ); goto on_error; } write_offset += write_count; write_size -= write_count; } memory_free( buffer ); buffer = NULL; if( libewf_handle_close( handle, error ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_CLOSE_FAILED, "%s: unable to close handle.", function ); goto on_error; } if( libewf_handle_free( &handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free handle.", function ); goto on_error; } return( 1 ); on_error: if( buffer != NULL ) { memory_free( buffer ); } if( handle != NULL ) { libewf_handle_close( handle, NULL ); libewf_handle_free( &handle, NULL ); } return( -1 ); }
/* Opens the wipekey handle * Returns 1 if successful, 0 if the keys could not be read or -1 on error */ int wipekey_handle_open_input( wipekey_handle_t *wipekey_handle, const libcstring_system_character_t *filename, libcerror_error_t **error ) { static char *function = "wipekey_handle_open_input"; size_t filename_length = 0; int result = 0; if( wipekey_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid wipekey handle.", function ); return( -1 ); } filename_length = libcstring_system_string_length( filename ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbfio_file_set_name_wide( wipekey_handle->input_file_io_handle, filename, filename_length, error ) != 1 ) #else if( libbfio_file_set_name( wipekey_handle->input_file_io_handle, filename, filename_length, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set file name.", function ); goto on_error; } if( libbfio_handle_open( wipekey_handle->input_file_io_handle, LIBBFIO_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input file.", function ); goto on_error; } if( libfvde_encryption_context_plist_initialize( &( wipekey_handle->encrypted_root_plist ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create encrypted root plist.", function ); goto on_error; } if( libfvde_encryption_context_plist_read_file_io_handle( wipekey_handle->encrypted_root_plist, wipekey_handle->input_file_io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_GENERIC, "%s: unable to read encrypted root plist.", function ); goto on_error; } if( libbfio_handle_close( wipekey_handle->input_file_io_handle, error ) != 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_CLOSE_FAILED, "%s: unable to close input file IO handle.", function ); goto on_error; } result = libfvde_encryption_context_plist_decrypt( wipekey_handle->encrypted_root_plist, wipekey_handle->volume_key_data, 128, error ); if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ENCRYPTION, LIBCERROR_ENCRYPTION_ERROR_DECRYPT_FAILED, "%s: unable to decrypt encrypted root plist.", function ); goto on_error; } if( memory_set( wipekey_handle->volume_key_data, 0, 16 ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_SET_FAILED, "%s: unable to clear volume key data.", function ); goto on_error; } return( result ); on_error: if( wipekey_handle->encrypted_root_plist != NULL ) { libfvde_encryption_context_plist_free( &( wipekey_handle->encrypted_root_plist ), NULL ); } return( -1 ); }
/* Opens the input * Returns 1 if successful or -1 on error */ int info_handle_open_input( info_handle_t *info_handle, const libcstring_system_character_t *filename, libcerror_error_t **error ) { libbfio_handle_t *file_io_handle = NULL; static char *function = "info_handle_open_input"; size_t filename_length = 0; int entry_index = 0; if( info_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid info handle.", function ); return( -1 ); } if( libbfio_file_range_initialize( &file_io_handle, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize file IO handle.", function ); goto on_error; } filename_length = libcstring_system_string_length( filename ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbfio_file_range_set_name_wide( file_io_handle, filename, filename_length, error ) != 1 ) #else if( libbfio_file_range_set_name( file_io_handle, filename, filename_length, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set file name.", function ); goto on_error; } if( libbfio_file_range_set( file_io_handle, info_handle->volume_offset, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set volume offset.", function ); goto on_error; } if( libvslvm_handle_open_file_io_handle( info_handle->input_handle, file_io_handle, LIBVSLVM_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input handle.", function ); goto on_error; } if( libbfio_pool_append_handle( info_handle->physical_volume_file_io_pool, &entry_index, file_io_handle, LIBBFIO_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input handle.", function ); goto on_error; } /* The takes over management of the file IO handle */ file_io_handle = NULL; /* TODO determine if the first file is a metadata only file and change filenames accordingly */ if( libvslvm_handle_open_physical_volume_files_file_io_pool( info_handle->input_handle, info_handle->physical_volume_file_io_pool, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open physical volume files.", function ); goto on_error; } return( 1 ); on_error: if( file_io_handle != NULL ) { libbfio_handle_free( &file_io_handle, NULL ); } return( -1 ); }
/* Opens the input of the mount handle * Returns 1 if successful, 0 if the keys could not be read or -1 on error */ int mount_handle_open_input( mount_handle_t *mount_handle, const libcstring_system_character_t *filename, libcerror_error_t **error ) { libcstring_system_character_t *basename_end = NULL; libvhdi_file_t *input_file = NULL; static char *function = "mount_handle_open_input"; size_t basename_length = 0; size_t filename_length = 0; int entry_index = 0; if( mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid mount handle.", function ); return( -1 ); } 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_system_string_length( filename ); basename_end = libcstring_system_string_search_character_reverse( filename, (libcstring_system_character_t) LIBCPATH_SEPARATOR, filename_length + 1 ); if( basename_end != NULL ) { basename_length = (size_t) ( basename_end - filename ) + 1; } if( basename_length > 0 ) { if( mount_handle_set_basename( mount_handle, filename, basename_length, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_SET_FAILED, "%s: unable to set basename.", function ); goto on_error; } } if( libvhdi_file_initialize( &input_file, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to initialize input file.", function ); goto on_error; } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libvhdi_file_open_wide( input_file, filename, LIBVHDI_OPEN_READ, error ) != 1 ) #else if( libvhdi_file_open( input_file, filename, LIBVHDI_OPEN_READ, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input file.", function ); goto on_error; } if( mount_handle_open_input_parent_file( mount_handle, input_file, error ) == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open parent input file.", function ); goto on_error; } if( libcdata_array_append_entry( mount_handle->input_files_array, &entry_index, (intptr_t *) input_file, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_APPEND_FAILED, "%s: unable to append input file to array.", function ); goto on_error; } return( 1 ); on_error: if( input_file != NULL ) { libvhdi_file_free( &input_file, NULL ); } libcdata_array_empty( mount_handle->input_files_array, (int (*)(intptr_t **, libcerror_error_t **)) &libvhdi_file_free, NULL ); return( -1 ); }
/* Determines the event log type from a string * Returns 1 if successful, 0 if unsupported value or -1 on error */ int evtxinput_determine_event_log_type( const libcstring_system_character_t *string, int *event_log_type, libcerror_error_t **error ) { static char *function = "evtxinput_determine_event_log_type"; size_t string_length = 0; int result = 0; if( string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid string.", function ); return( -1 ); } if( event_log_type == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid event log type.", function ); return( -1 ); } string_length = libcstring_system_string_length( string ); if( string_length == 6 ) { if( libcstring_system_string_compare_no_case( string, _LIBCSTRING_SYSTEM_STRING( "system" ), 6 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SYSTEM; result = 1; } } else if( string_length == 8 ) { if( libcstring_system_string_compare_no_case( string, _LIBCSTRING_SYSTEM_STRING( "security" ), 8 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SECURITY; result = 1; } } else if( string_length == 11 ) { if( libcstring_system_string_compare_no_case( string, _LIBCSTRING_SYSTEM_STRING( "application" ), 11 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_APPLICATION; result = 1; } } return( result ); }
/* Determines the UTF-8 string size from the system string * Returns 1 if successful or -1 on error */ int libcsystem_string_size_to_utf8_string( const libcstring_system_character_t *string, size_t string_size, size_t *utf8_string_size, libcerror_error_t **error ) { static char *function = "libcsystem_string_size_to_utf8_string"; if( string == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid string.", function ); return( -1 ); } if( string_size > (size_t) SSIZE_MAX ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM, "%s: invalid string size value exceeds maximum.", function ); return( -1 ); } if( utf8_string_size == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid UTF-8 string size.", function ); return( -1 ); } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) #if SIZEOF_WCHAR_T == 4 if( libuna_utf8_string_size_from_utf32( (libuna_utf32_character_t *) string, string_size, utf8_string_size, error ) != 1 ) #elif SIZEOF_WCHAR_T == 2 if( libuna_utf8_string_size_from_utf16( (libuna_utf16_character_t *) string, string_size, utf8_string_size, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_CONVERSION, LIBCERROR_CONVERSION_ERROR_GENERIC, "%s: unable to determine UTF-8 string size.", function ); return( -1 ); } #else if( libclocale_codepage == 0 ) { *utf8_string_size = 1 + libcstring_system_string_length( string ); } else if( libuna_utf8_string_size_from_byte_stream( (uint8_t *) string, string_size, libclocale_codepage, utf8_string_size, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_CONVERSION, LIBCERROR_CONVERSION_ERROR_GENERIC, "%s: unable to determine UTF-8 string size.", function ); return( -1 ); } #endif return( 1 ); }
int main( int argc, char * const argv[] ) #endif { libbde_volume_t *volume = NULL; libcstring_system_character_t *option_password = NULL; libcstring_system_character_t *option_recovery_password = NULL; libcstring_system_character_t *source = NULL; libcerror_error_t *error = NULL; libcstring_system_integer_t option = 0; size64_t volume_size = 0; size_t string_length = 0; while( ( option = libcsystem_getopt( argc, argv, _LIBCSTRING_SYSTEM_STRING( "p:r:" ) ) ) != (libcstring_system_integer_t) -1 ) { switch( option ) { case (libcstring_system_integer_t) '?': default: fprintf( stderr, "Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n", argv[ optind - 1 ] ); return( EXIT_FAILURE ); case (libcstring_system_integer_t) 'p': option_password = optarg; break; case (libcstring_system_integer_t) 'r': option_recovery_password = optarg; break; } } if( optind == argc ) { fprintf( stderr, "Missing source file or device.\n" ); return( EXIT_FAILURE ); } source = argv[ optind ]; #if defined( HAVE_DEBUG_OUTPUT ) && defined( BDE_TEST_OPEN_CLOSE_VERBOSE ) libbde_notify_set_verbose( 1 ); libbde_notify_set_stream( stderr, NULL ); #endif /* Initialization */ if( libbde_volume_initialize( &volume, &error ) != 1 ) { fprintf( stderr, "Unable to create volume.\n" ); goto on_error; } if( option_password != NULL ) { string_length = libcstring_system_string_length( option_password ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbde_volume_set_utf16_password( volume, (uint16_t *) option_password, string_length, &error ) != 1 ) #else if( libbde_volume_set_utf8_password( volume, (uint8_t *) option_password, string_length, &error ) != 1 ) #endif { fprintf( stderr, "Unable to set password." ); goto on_error; } } if( option_recovery_password != NULL ) { string_length = libcstring_system_string_length( option_recovery_password ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbde_volume_set_utf16_recovery_password( volume, (uint16_t *) option_recovery_password, string_length, &error ) != 1 ) #else if( libbde_volume_set_utf8_recovery_password( volume, (uint8_t *) option_recovery_password, string_length, &error ) != 1 ) #endif { fprintf( stderr, "Unable to set recovery password." ); goto on_error; } } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbde_volume_open_wide( volume, source, LIBBDE_OPEN_READ, &error ) != 1 ) #else if( libbde_volume_open( volume, source, LIBBDE_OPEN_READ, &error ) != 1 ) #endif { fprintf( stderr, "Unable to open file.\n" ); goto on_error; } if( libbde_volume_get_size( volume, &volume_size, &error ) != 1 ) { fprintf( stderr, "Unable to retrieve volume size.\n" ); goto on_error; } fprintf( stdout, "Volume size: %" PRIu64 " bytes\n", volume_size ); if( bde_volume_test_seek( volume, volume_size ) != 1 ) { fprintf( stderr, "Unable to seek in volume.\n" ); goto on_error; } /* Clean up */ if( libbde_volume_close( volume, &error ) != 0 ) { fprintf( stderr, "Unable to close volume.\n" ); goto on_error; } if( libbde_volume_free( &volume, &error ) != 1 ) { fprintf( stderr, "Unable to free volume.\n" ); goto on_error; } return( EXIT_SUCCESS ); on_error: if( error != NULL ) { libbde_error_backtrace_fprint( error, stderr ); libbde_error_free( &error ); } if( volume != NULL ) { libbde_volume_close( volume, NULL ); libbde_volume_free( &volume, NULL ); } return( EXIT_FAILURE ); }
int main( int argc, char * const argv[] ) #endif { libcstring_system_character_t *target_filename = NULL; liberror_error_t *error = NULL; libewf_handle_t *handle = NULL; libcstring_system_integer_t option = 0; off64_t read_offset = 0; size64_t media_size = 0; size64_t read_size = 0; size32_t chunk_size = 0; size_t delta_segment_filename_length = 0; while( ( option = libsystem_getopt( argc, argv, _LIBCSTRING_SYSTEM_STRING( "t:" ) ) ) != (libcstring_system_integer_t) -1 ) { switch( option ) { case (libcstring_system_integer_t) '?': default: fprintf( stderr, "Invalid argument: %" PRIs_LIBCSTRING_SYSTEM ".\n", argv[ optind - 1 ] ); return( EXIT_FAILURE ); case (libcstring_system_integer_t) 't': target_filename = optarg; break; } } if( optind == argc ) { fprintf( stderr, "Missing EWF image filename(s).\n" ); return( EXIT_FAILURE ); } /* Initialization */ if( libewf_handle_initialize( &handle, &error ) != 1 ) { fprintf( stderr, "Unable to create handle.\n" ); goto on_error; } /* #if defined( HAVE_DEBUG_OUTPUT ) libewf_notify_set_verbose( 1 ); libewf_notify_set_stream( stderr, NULL ); #endif */ #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_handle_open_wide( handle, &( argv[ optind ] ), argc - optind, LIBEWF_OPEN_READ_WRITE, &error ) != 1 ) #else if( libewf_handle_open( handle, &( argv[ optind ] ), argc - optind, LIBEWF_OPEN_READ_WRITE, &error ) != 1 ) #endif { fprintf( stderr, "Unable to open file(s).\n" ); goto on_error; } if( target_filename != NULL ) { delta_segment_filename_length = libcstring_system_string_length( target_filename ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_handle_set_delta_segment_filename_wide( handle, target_filename, delta_segment_filename_length, &error ) != 1 ) #else if( libewf_handle_set_delta_segment_filename( handle, target_filename, delta_segment_filename_length, &error ) != 1 ) #endif { fprintf( stderr, "Unable to set delta segment filename.\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( media_size > (size64_t) INT64_MAX ) { fprintf( stderr, "Media size exceeds maximum.\n" ); goto on_error; } if( libewf_handle_get_chunk_size( handle, &chunk_size, &error ) != 1 ) { fprintf( stderr, "Unable to retrieve chunk size.\n" ); goto on_error; } if( chunk_size == 0 ) { fprintf( stderr, "Invalid chunk size.\n" ); goto on_error; } fprintf( stdout, "Media size: %" PRIu64 " bytes\n", media_size ); /* Case 0: test full read */ /* Test: offset: 0 size: <media_size> * Expected result: offset: 0 size: <media_size> */ read_offset = 0; read_size = media_size; if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } /* Case 1: test random read */ /* Test: offset: <media_size / 7> size: <media_size / 2> * Expected result: offset: <media_size / 7> size: <media_size / 2> */ read_offset = (off64_t) ( media_size / 7 ); read_size = media_size / 2; if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } /* Case 2: test read buffer beyond media size */ if( media_size < 1024 ) { /* Test: offset: <media_size - 1024> size: 4096 * Expected result: offset: -1 size: <undetermined> */ read_offset = (off64_t) ( media_size - 1024 ); read_size = 4096; if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, -1, (size64_t) -1 ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, -1, (size64_t) -1 ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } } else { /* Test: offset: <media_size - 1024> size: 4096 * Expected result: offset: <media_size - 1024> size: 1024 */ read_offset = (off64_t) ( media_size - 1024 ); read_size = 4096; if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, read_offset, 1024 ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } if( ewf_test_read_write_buffer_at_offset( handle, read_offset, SEEK_SET, read_size, read_offset, 1024 ) != 1 ) { fprintf( stderr, "Unable to test read/write buffer.\n" ); goto on_error; } } fprintf( stdout, "\nChunk size: %" PRIu32 " bytes\n", chunk_size ); /* Case 0: test full read */ /* Test: offset: 0 size: <media_size> * Expected result: offset: 0 size: <media_size> */ read_offset = 0; read_size = media_size; if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } /* Case 1: test random read */ /* Test: offset: <( ( media_size / 7 ) / chunk_size ) * chunk_size> size: <( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size> * Expected result: offset: <( ( media_size / 7 ) / chunk_size ) * chunk_size> size: <( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size> */ read_offset = (off64_t) ( ( media_size / 7 ) / chunk_size ) * chunk_size; read_size = ( ( ( media_size / 2 ) / chunk_size ) + 1 ) * chunk_size; if( media_size == 0 ) { if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, read_offset, 0 ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, read_offset, 0 ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } } else { if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, read_offset, read_size ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } } /* Case 2: test read chunk beyond media size */ if( media_size < 1024 ) { /* Test: offset: <media_size - 1024> size: chunk_size * Expected result: offset: -1 size: <undetermined> */ read_offset = (off64_t) ( media_size - 1024 ); read_size = chunk_size; if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, -1, (size64_t) -1 ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, -1, (size64_t) -1 ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } } else { /* Test: offset: <media_size - 1024> size: chunk_size * Expected result: offset: <media_size - 1024> size: chunk size or media_size % chunk_size */ read_offset = (off64_t) ( media_size - 1024 ); read_size = chunk_size; if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, (off64_t) ( media_size - 1024 ), ( ( media_size % chunk_size ) == 0 ) ? chunk_size : media_size % chunk_size ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } if( ewf_test_read_write_chunk_at_offset( handle, chunk_size, read_offset, SEEK_SET, read_size, (off64_t) ( media_size - 1024 ), ( ( media_size % chunk_size ) == 0 ) ? chunk_size : media_size % chunk_size ) != 1 ) { fprintf( stderr, "Unable to test read/write chunk.\n" ); goto on_error; } } /* Clean up */ if( libewf_handle_close( handle, &error ) != 0 ) { fprintf( stderr, "Unable to close file(s).\n" ); goto on_error; } if( libewf_handle_free( &handle, &error ) != 1 ) { fprintf( stderr, "Unable to free handle.\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 ); } return( EXIT_FAILURE ); }
/* Opens the input of the mount handle * Returns 1 if successful or -1 on error */ int mount_handle_open_input( mount_handle_t *mount_handle, libcstring_system_character_t * const * filenames, int number_of_filenames, libcerror_error_t **error ) { libcstring_system_character_t **libewf_filenames = NULL; static char *function = "mount_handle_open_input"; size_t first_filename_length = 0; if( mount_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid mount handle.", function ); return( -1 ); } if( filenames == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid filenames.", function ); return( -1 ); } if( number_of_filenames <= 0 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS, "%s: invalid number of filenames.", function ); return( -1 ); } if( number_of_filenames == 1 ) { first_filename_length = libcstring_system_string_length( filenames[ 0 ] ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_glob_wide( filenames[ 0 ], first_filename_length, LIBEWF_FORMAT_UNKNOWN, &libewf_filenames, &number_of_filenames, error ) != 1 ) #else if( libewf_glob( filenames[ 0 ], first_filename_length, LIBEWF_FORMAT_UNKNOWN, &libewf_filenames, &number_of_filenames, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to resolve filename(s).", function ); return( -1 ); } filenames = (libcstring_system_character_t * const *) libewf_filenames; } #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_handle_open_wide( mount_handle->input_handle, filenames, number_of_filenames, LIBEWF_OPEN_READ, error ) != 1 ) #else if( libewf_handle_open( mount_handle->input_handle, filenames, number_of_filenames, LIBEWF_OPEN_READ, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open file(s).", function ); if( libewf_filenames != NULL ) { #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) libewf_glob_wide_free( libewf_filenames, number_of_filenames, NULL ); #else libewf_glob_free( libewf_filenames, number_of_filenames, NULL ); #endif } return( -1 ); } if( libewf_filenames != NULL ) { #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libewf_glob_wide_free( libewf_filenames, number_of_filenames, error ) != 1 ) #else if( libewf_glob_free( libewf_filenames, number_of_filenames, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED, "%s: unable to free globbed filenames.", function ); return( -1 ); } } if( mount_handle->input_format == MOUNT_HANDLE_INPUT_FORMAT_FILES ) { if( libewf_handle_get_root_file_entry( mount_handle->input_handle, &( mount_handle->root_file_entry ), error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to retrieve root file entry.", function ); return( -1 ); } } return( 1 ); }
/* Determines the event log type from the filename * Returns 1 if successful, 0 if unsupported value or -1 on error */ int evtxinput_determine_event_log_type_from_filename( const libcstring_system_character_t *filename, int *event_log_type, libcerror_error_t **error ) { const libcstring_system_character_t *path_separator = NULL; static char *function = "evtxinput_determine_event_log_type_from_filename"; 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 ); } if( event_log_type == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid event log type.", function ); return( -1 ); } filename_length = libcstring_system_string_length( filename ); path_separator = libcstring_system_string_search_character_reverse( filename, (libcstring_system_character_t) LIBCPATH_SEPARATOR, filename_length ); if( path_separator == NULL ) { path_separator = filename; } else { path_separator++; filename_length = libcstring_system_string_length( path_separator ); } if( filename_length == 11 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "System.evtx" ), 11 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SYSTEM; result = 1; } } else if( filename_length == 13 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "Security.evtx" ), 13 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_SECURITY; result = 1; } } else if( filename_length == 16 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "Application.evtx" ), 16 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_APPLICATION; result = 1; } } else if( filename_length == 17 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "Media Center.evtx" ), 17 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_MEDIA_CENTER; result = 1; } } else if( filename_length == 19 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "HardwareEvents.evtx" ), 19 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_HARDWARE_EVENTS; result = 1; } } else if( filename_length == 20 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "DFS Replication.evtx" ), 20 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_DFS_REPLICATION; result = 1; } } else if( filename_length == 22 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "Internet Explorer.evtx" ), 22 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_INTERNET_EXPLORER; result = 1; } } else if( filename_length == 27 ) { if( libcstring_system_string_compare_no_case( path_separator, _LIBCSTRING_SYSTEM_STRING( "Key Management Service.evtx" ), 27 ) == 0 ) { *event_log_type = EVTXTOOLS_EVENT_LOG_TYPE_KEY_MANAGEMENT_SERVICE; result = 1; } } return( result ); }
/* Opens the info handle * Returns 1 if successful, 0 if no VSS enabled volume was found or -1 on error */ int info_handle_open_input( info_handle_t *info_handle, const libcstring_system_character_t *filename, libcerror_error_t **error ) { static char *function = "info_handle_open_input"; size_t filename_length = 0; int result = 0; if( info_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid info handle.", function ); return( -1 ); } filename_length = libcstring_system_string_length( filename ); #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) if( libbfio_file_range_set_name_wide( info_handle->input_file_io_handle, filename, filename_length, error ) != 1 ) #else if( libbfio_file_range_set_name( info_handle->input_file_io_handle, filename, filename_length, error ) != 1 ) #endif { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set file name.", function ); return( -1 ); } if( libbfio_file_range_set( info_handle->input_file_io_handle, info_handle->volume_offset, 0, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open set volume offset.", function ); return( -1 ); } result = libvshadow_check_volume_signature_file_io_handle( info_handle->input_file_io_handle, error ); if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_GET_FAILED, "%s: unable to determine if volume has a VSS signature.", function ); return( -1 ); } else if( result != 0 ) { if( libvshadow_volume_open_file_io_handle( info_handle->input_volume, info_handle->input_file_io_handle, LIBVSHADOW_OPEN_READ, error ) != 1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_IO, LIBCERROR_IO_ERROR_OPEN_FAILED, "%s: unable to open input volume.", function ); return( -1 ); } } return( result ); }
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; } if( libcsystem_glob_get_results( glob, &number_of_filenames, (libcstring_system_character_t ***) &source_filenames, &error ) != 1 ) { fprintf( stderr, "Unable to retrieve glob results.\n" ); goto on_error; } #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 ); }
/* Sets the target path * Returns 1 if successful or -1 on error */ int export_handle_set_target_path( export_handle_t *export_handle, const libcstring_system_character_t *target_path, libcerror_error_t **error ) { static char *function = "export_handle_set_target_path"; size_t target_path_length = 0; #if defined( WINAPI ) libcstring_system_character_t *full_target_path = NULL; size_t full_target_path_size = 0; int result = 0; #endif if( export_handle == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid export handle.", function ); return( -1 ); } if( target_path == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_ARGUMENTS, LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE, "%s: invalid target path.", function ); return( -1 ); } if( export_handle->target_path != NULL ) { memory_free( export_handle->target_path ); export_handle->target_path = NULL; export_handle->target_path_size = 0; } target_path_length = libcstring_system_string_length( target_path ); #if defined( WINAPI ) #if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) result = libcpath_path_get_full_path_wide( target_path, target_path_length, &full_target_path, &full_target_path_size, error ); #else result = libcpath_path_get_full_path( target_path, target_path_length, &full_target_path, &full_target_path_size, error ); #endif if( result == -1 ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED, "%s: unable to create full target path.", function ); goto on_error; } else if( result != 0 ) { target_path = full_target_path; target_path_length = full_target_path_size - 1; } #endif if( target_path_length > 0 ) { export_handle->target_path = libcstring_system_string_allocate( target_path_length + 1 ); if( export_handle->target_path == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_MEMORY, LIBCERROR_MEMORY_ERROR_INSUFFICIENT, "%s: unable to create target path.", function ); goto on_error; } if( libcstring_system_string_copy( export_handle->target_path, target_path, target_path_length ) == NULL ) { libcerror_error_set( error, LIBCERROR_ERROR_DOMAIN_RUNTIME, LIBCERROR_RUNTIME_ERROR_COPY_FAILED, "%s: unable to copy target path.", function ); goto on_error; } ( export_handle->target_path )[ target_path_length ] = 0; export_handle->target_path_size = target_path_length + 1; } #if defined( WINAPI ) memory_free( full_target_path ); full_target_path = NULL; #endif return( 1 ); on_error: #if defined( WINAPI ) if( full_target_path != NULL ) { memory_free( full_target_path ); } #endif if( export_handle->target_path != NULL ) { memory_free( export_handle->target_path ); export_handle->target_path = NULL; } export_handle->target_path_size = 0; return( -1 ); }