/* Prints the physcial volume information
* Returns 1 if successful or -1 on error
*/
int info_handle_physical_volume_fprint(
info_handle_t *info_handle,
int physical_volume_index,
libvslvm_physical_volume_t *physical_volume,
libcerror_error_t **error )
{
static char *function = "info_handle_physical_volume_fprint";
char *value_string = NULL;
size64_t volume_size = 0;
size_t value_string_size = 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 );
}
fprintf(
info_handle->notify_stream,
"Physical Volume (PV): %d\n",
physical_volume_index + 1 );
if( libvslvm_physical_volume_get_name_size(
physical_volume,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve name size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
if( libvslvm_physical_volume_get_name(
physical_volume,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve name.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tName:\t\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_physical_volume_get_identifier_size(
physical_volume,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create identifier string.",
function );
goto on_error;
}
if( libvslvm_physical_volume_get_identifier(
physical_volume,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tIdentifier:\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_physical_volume_get_device_path_size(
physical_volume,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve device path size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create device path string.",
function );
goto on_error;
}
if( libvslvm_physical_volume_get_device_path(
physical_volume,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve device path.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tDevice path:\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_physical_volume_get_size(
physical_volume,
&volume_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve size.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tVolume size:\t\t\t\t%" PRIu64 " bytes\n",
volume_size );
fprintf(
info_handle->notify_stream,
"\n" );
return( 1 );
on_error:
if( value_string != NULL )
{
memory_free(
value_string );
}
return( -1 );
}
/* Prints the volume group information
* Returns 1 if successful or -1 on error
*/
int info_handle_volume_group_fprint(
info_handle_t *info_handle,
libvslvm_volume_group_t *volume_group,
libcerror_error_t **error )
{
libvslvm_logical_volume_t *logical_volume = NULL;
libvslvm_physical_volume_t *physical_volume = NULL;
static char *function = "info_handle_volume_group_fprint";
char *value_string = NULL;
size64_t extent_size = 0;
size_t value_string_size = 0;
uint32_t value_32bit = 0;
int number_of_logical_volumes = 0;
int number_of_physical_volumes = 0;
int volume_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 );
}
fprintf(
info_handle->notify_stream,
"Volume Group (VG):\n" );
if( libvslvm_volume_group_get_name_size(
volume_group,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve name size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
if( libvslvm_volume_group_get_name(
volume_group,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve name.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tName:\t\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_volume_group_get_identifier_size(
volume_group,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create identifier string.",
function );
goto on_error;
}
if( libvslvm_volume_group_get_identifier(
volume_group,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tIdentifier:\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_volume_group_get_sequence_number(
volume_group,
&value_32bit,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrive sequence number.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tSequence number:\t\t\t%" PRIu32 "\n",
value_32bit );
if( libvslvm_volume_group_get_extent_size(
volume_group,
&extent_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve extent size.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tExtent size:\t\t\t\t%" PRIu64 " bytes\n",
extent_size );
if( libvslvm_volume_group_get_number_of_physical_volumes(
volume_group,
&number_of_physical_volumes,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of physical volumes.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tNumber of physical volumes:\t\t%d\n",
number_of_physical_volumes );
if( libvslvm_volume_group_get_number_of_logical_volumes(
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;
}
fprintf(
info_handle->notify_stream,
"\tNumber of logical volumes:\t\t%d\n",
number_of_logical_volumes );
fprintf(
info_handle->notify_stream,
"\n" );
for( volume_index = 0;
volume_index < number_of_physical_volumes;
volume_index++ )
{
if( libvslvm_volume_group_get_physical_volume(
volume_group,
volume_index,
&physical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve physical volume: %d.",
function,
volume_index );
goto on_error;
}
if( info_handle_physical_volume_fprint(
info_handle,
volume_index,
physical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print physical volume: %d information.",
function,
volume_index );
goto on_error;
}
if( libvslvm_physical_volume_free(
&physical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free physical volume: %d.",
function,
volume_index );
goto on_error;
}
}
for( volume_index = 0;
volume_index < number_of_logical_volumes;
volume_index++ )
{
if( libvslvm_volume_group_get_logical_volume(
volume_group,
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,
volume_index );
goto on_error;
}
if( info_handle_logical_volume_fprint(
info_handle,
volume_index,
logical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print logical volume: %d information.",
function,
volume_index );
goto on_error;
}
if( libvslvm_logical_volume_free(
&logical_volume,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free logical volume: %d.",
function,
volume_index );
goto on_error;
}
}
return( 1 );
on_error:
if( logical_volume != NULL )
{
libvslvm_logical_volume_free(
&logical_volume,
NULL );
}
if( physical_volume != NULL )
{
libvslvm_physical_volume_free(
&physical_volume,
NULL );
}
if( value_string != NULL )
{
memory_free(
value_string );
}
return( -1 );
}
/* Prints the logical volume information
* Returns 1 if successful or -1 on error
*/
int info_handle_logical_volume_fprint(
info_handle_t *info_handle,
int logical_volume_index,
libvslvm_logical_volume_t *logical_volume,
libcerror_error_t **error )
{
libvslvm_segment_t *segment = NULL;
static char *function = "info_handle_logical_volume_fprint";
char *value_string = NULL;
size_t value_string_size = 0;
int number_of_segments = 0;
int segment_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 );
}
fprintf(
info_handle->notify_stream,
"Logical Volume (LV): %d\n",
logical_volume_index + 1 );
if( libvslvm_logical_volume_get_name_size(
logical_volume,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve name size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create name string.",
function );
goto on_error;
}
if( libvslvm_logical_volume_get_name(
logical_volume,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve name.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tName:\t\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_logical_volume_get_identifier_size(
logical_volume,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create identifier string.",
function );
goto on_error;
}
if( libvslvm_logical_volume_get_identifier(
logical_volume,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve identifier.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tIdentifier:\t\t\t\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_logical_volume_get_number_of_segments(
logical_volume,
&number_of_segments,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve number of segments.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\tNumber of segments:\t\t\t%d\n",
number_of_segments );
for( segment_index = 0;
segment_index < number_of_segments;
segment_index++ )
{
if( libvslvm_logical_volume_get_segment(
logical_volume,
segment_index,
&segment,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve segment: %d.",
function,
segment_index );
goto on_error;
}
if( info_handle_segment_fprint(
info_handle,
segment_index,
segment,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_PRINT_FAILED,
"%s: unable to print segment: %d information.",
function,
segment_index );
goto on_error;
}
if( libvslvm_segment_free(
&segment,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
"%s: unable to free segment: %d.",
function,
segment_index );
goto on_error;
}
}
return( 1 );
on_error:
if( segment != NULL )
{
libvslvm_segment_free(
&segment,
NULL );
}
if( value_string != NULL )
{
memory_free(
value_string );
}
if( value_string != NULL )
{
memory_free(
value_string );
}
return( -1 );
}
/* Prints the stripe information
* Returns 1 if successful or -1 on error
*/
int info_handle_stripe_fprint(
info_handle_t *info_handle,
int stripe_index,
libvslvm_stripe_t *stripe,
libcerror_error_t **error )
{
static char *function = "info_handle_stripe_fprint";
char *value_string = NULL;
size_t value_string_size = 0;
off64_t data_area_offset = 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 );
}
fprintf(
info_handle->notify_stream,
"\t\tStripe: %d\n",
stripe_index + 1 );
if( libvslvm_stripe_get_physical_volume_name_size(
stripe,
&value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve physical volume name size.",
function );
goto on_error;
}
else if( value_string_size > 0 )
{
if( value_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid parent value string size value exceeds maximum.",
function );
goto on_error;
}
value_string = libcstring_narrow_string_allocate(
value_string_size );
if( value_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create physical volume name string.",
function );
goto on_error;
}
if( libvslvm_stripe_get_physical_volume_name(
stripe,
value_string,
value_string_size,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve physical volume name.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\t\t\tPhysical volume:\t%" PRIs_LIBCSTRING_SYSTEM "\n",
value_string );
memory_free(
value_string );
value_string = NULL;
}
if( libvslvm_stripe_get_data_area_offset(
stripe,
&data_area_offset,
error ) != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_GET_FAILED,
"%s: unable to retrieve data area offset.",
function );
goto on_error;
}
fprintf(
info_handle->notify_stream,
"\t\t\tData area offset:\t0x%08" PRIx64 " (%" PRIi64 ")\n",
data_area_offset,
data_area_offset );
fprintf(
info_handle->notify_stream,
"\n" );
return( 1 );
on_error:
if( value_string != NULL )
{
memory_free(
value_string );
}
return( -1 );
}
/* Determines if a file exists
* This function uses the POSIX stat function or equivalent
* Returns 1 if the file exists, 0 if not or -1 on error
*/
int libcfile_file_exists_wide(
const wchar_t *filename,
libcerror_error_t **error )
{
struct stat file_statistics;
char *narrow_filename = NULL;
static char *function = "libcfile_file_exists_wide";
size_t narrow_filename_size = 0;
size_t filename_size = 0;
int result = 0;
if( filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid filename.",
function );
return( -1 );
}
filename_size = 1 + libcstring_wide_string_length(
filename );
/* Convert the filename to a narrow string
* if the platform has no wide character open function
*/
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) filename,
filename_size,
&narrow_filename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) filename,
filename_size,
&narrow_filename_size,
error );
#else
#error Unsupported size of wchar_t
#endif /* SIZEOF_WCHAR_T */
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_byte_stream_size_from_utf32(
(libuna_utf32_character_t *) filename,
filename_size,
libclocale_codepage,
&narrow_filename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_size_from_utf16(
(libuna_utf16_character_t *) filename,
filename_size,
libclocale_codepage,
&narrow_filename_size,
error );
#else
#error Unsupported size of wchar_t
#endif /* SIZEOF_WCHAR_T */
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine narrow character filename size.",
function );
return( -1 );
}
narrow_filename = libcstring_narrow_string_allocate(
narrow_filename_size );
if( narrow_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create narrow character filename.",
function );
return( -1 );
}
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_copy_from_utf32(
(libuna_utf8_character_t *) narrow_filename,
narrow_filename_size,
(libuna_utf32_character_t *) filename,
filename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_copy_from_utf16(
(libuna_utf8_character_t *) narrow_filename,
narrow_filename_size,
(libuna_utf16_character_t *) filename,
filename_size,
error );
#else
#error Unsupported size of wchar_t
#endif /* SIZEOF_WCHAR_T */
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_byte_stream_copy_from_utf32(
(uint8_t *) narrow_filename,
narrow_filename_size,
libclocale_codepage,
(libuna_utf32_character_t *) filename,
filename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_copy_from_utf16(
(uint8_t *) narrow_filename,
narrow_filename_size,
libclocale_codepage,
(libuna_utf16_character_t *) filename,
filename_size,
error );
#else
#error Unsupported size of wchar_t
#endif /* SIZEOF_WCHAR_T */
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to set narrow character filename.",
function );
memory_free(
narrow_filename );
return( -1 );
}
result = stat(
narrow_filename,
&file_statistics );
memory_free(
narrow_filename );
if( result != 0 )
{
switch( errno )
{
case EACCES:
result = 1;
break;
case ENOENT:
result = 0;
break;
default:
libcerror_system_set_error(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_GENERIC,
errno,
"%s: unable to stat file: %" PRIs_LIBCSTRING_SYSTEM ".",
function,
filename );
return( -1 );
}
}
else
{
result = 1;
}
return( result );
}
