/* Retrieves source as a narrow string
* Returns 1 if successful or -1 on error
*/
int smdev_test_get_narrow_source(
const system_character_t *source,
char *narrow_string,
size_t narrow_string_size,
libcerror_error_t **error )
{
static char *function = "smdev_test_get_narrow_source";
size_t narrow_source_size = 0;
size_t source_length = 0;
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
int result = 0;
#endif
if( source == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid source.",
function );
return( -1 );
}
if( narrow_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid narrow string.",
function );
return( -1 );
}
if( narrow_string_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid narrow string size value exceeds maximum.",
function );
return( -1 );
}
source_length = system_string_length(
source );
if( source_length > (size_t) ( SSIZE_MAX - 1 ) )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
"%s: invalid source length value out of bounds.",
function );
return( -1 );
}
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) source,
source_length + 1,
&narrow_source_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) source,
source_length + 1,
&narrow_source_size,
error );
#endif
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_byte_stream_size_from_utf32(
(libuna_utf32_character_t *) source,
source_length + 1,
libclocale_codepage,
&narrow_source_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_size_from_utf16(
(libuna_utf16_character_t *) source,
source_length + 1,
libclocale_codepage,
&narrow_source_size,
error );
#endif
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine narrow string size.",
function );
return( -1 );
}
#else
narrow_source_size = source_length + 1;
#endif /* defined( HAVE_WIDE_SYSTEM_CHARACTER ) */
if( narrow_string_size < narrow_source_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: narrow string too small.",
function );
return( -1 );
}
#if defined( HAVE_WIDE_SYSTEM_CHARACTER )
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_copy_from_utf32(
(libuna_utf8_character_t *) narrow_string,
narrow_string_size,
(libuna_utf32_character_t *) source,
source_length + 1,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_copy_from_utf16(
(libuna_utf8_character_t *) narrow_string,
narrow_string_size,
(libuna_utf16_character_t *) source,
source_length + 1,
error );
#endif
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_byte_stream_copy_from_utf32(
(uint8_t *) narrow_string,
narrow_string_size,
libclocale_codepage,
(libuna_utf32_character_t *) source,
source_length + 1,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_copy_from_utf16(
(uint8_t *) narrow_string,
narrow_string_size,
libclocale_codepage,
(libuna_utf16_character_t *) source,
source_length + 1,
error );
#endif
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to set narrow string.",
function );
return( -1 );
}
#else
if( system_string_copy(
narrow_string,
source,
source_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set narrow string.",
function );
return( -1 );
}
narrow_string[ source_length ] = 0;
#endif /* defined( HAVE_WIDE_SYSTEM_CHARACTER ) */
return( 1 );
}
/* Retrieves the basename
* Returns 1 if successful, 0 if value not present or -1 on error
*/
int libewf_segment_table_get_basename(
libewf_segment_table_t *segment_table,
char *basename,
size_t basename_size,
libcerror_error_t **error )
{
static char *function = "libewf_segment_table_get_basename";
size_t narrow_basename_size = 0;
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
int result = 0;
#endif
if( segment_table == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment table.",
function );
return( -1 );
}
if( basename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid basename.",
function );
return( -1 );
}
if( segment_table->basename == NULL )
{
return( 0 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) segment_table->basename,
segment_table->basename_size,
&narrow_basename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) segment_table->basename,
segment_table->basename_size,
&narrow_basename_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 *) segment_table->basename,
segment_table->basename_size,
libclocale_codepage,
&narrow_basename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_size_from_utf16(
(libuna_utf16_character_t *) segment_table->basename,
segment_table->basename_size,
libclocale_codepage,
&narrow_basename_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 basename size.",
function );
return( -1 );
}
#else
narrow_basename_size = segment_table->basename_size;
#endif /* defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) */
if( basename_size < narrow_basename_size )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL,
"%s: basename too small.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_copy_from_utf32(
(libuna_utf8_character_t *) basename,
basename_size,
(libuna_utf32_character_t *) segment_table->basename,
segment_table->basename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_copy_from_utf16(
(libuna_utf8_character_t *) basename,
basename_size,
(libuna_utf16_character_t *) segment_table->basename,
segment_table->basename_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 *) basename,
basename_size,
libclocale_codepage,
(libuna_utf32_character_t *) segment_table->basename,
segment_table->basename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_copy_from_utf16(
(uint8_t *) basename,
basename_size,
libclocale_codepage,
(libuna_utf16_character_t *) segment_table->basename,
segment_table->basename_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 basename.",
function );
return( -1 );
}
#else
if( libcstring_system_string_copy(
basename,
segment_table->basename,
segment_table->basename_size ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set basename.",
function );
return( -1 );
}
basename[ segment_table->basename_size - 1 ] = 0;
#endif /* defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) */
return( 1 );
}
/* Retrieves the size of the basename
* Returns 1 if successful, 0 if value not present or -1 on error
*/
int libewf_segment_table_get_basename_size(
libewf_segment_table_t *segment_table,
size_t *basename_size,
libcerror_error_t **error )
{
static char *function = "libewf_segment_table_get_basename_size";
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
int result = 0;
#endif
if( segment_table == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment table.",
function );
return( -1 );
}
if( basename_size == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid basename size.",
function );
return( -1 );
}
if( segment_table->basename == NULL )
{
return( 0 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) segment_table->basename,
segment_table->basename_size,
basename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) segment_table->basename,
segment_table->basename_size,
basename_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 *) segment_table->basename,
segment_table->basename_size,
libclocale_codepage,
basename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_size_from_utf16(
(libuna_utf16_character_t *) segment_table->basename,
segment_table->basename_size,
libclocale_codepage,
basename_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 basename size.",
function );
return( -1 );
}
#else
*basename_size = segment_table->basename_size;
#endif /* defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) */
return( 1 );
}
/* Sets the basename
* Returns 1 if successful or -1 on error
*/
int libewf_segment_table_set_basename_wide(
libewf_segment_table_t *segment_table,
const wchar_t *basename,
size_t basename_length,
libcerror_error_t **error )
{
static char *function = "libewf_segment_table_set_basename_wide";
#if !defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
int result = 0;
#endif
if( segment_table == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid segment table.",
function );
return( -1 );
}
if( basename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid basename.",
function );
return( -1 );
}
if( segment_table->basename != NULL )
{
memory_free(
segment_table->basename );
segment_table->basename = NULL;
segment_table->basename_size = 0;
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
segment_table->basename_size = basename_length + 1;
#else
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) basename,
basename_length + 1,
&( segment_table->basename_size ),
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) basename,
basename_length + 1,
&( segment_table->basename_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 *) basename,
basename_length + 1,
libclocale_codepage,
&( segment_table->basename_size ),
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_size_from_utf16(
(libuna_utf16_character_t *) basename,
basename_length + 1,
libclocale_codepage,
&( segment_table->basename_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 basename size.",
function );
return( -1 );
}
#endif /* defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) */
segment_table->basename = libcstring_system_string_allocate(
segment_table->basename_size );
if( segment_table->basename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create basename.",
function );
return( -1 );
}
#if defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER )
if( libcstring_system_string_copy(
segment_table->basename,
basename,
basename_length ) == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_COPY_FAILED,
"%s: unable to set basename.",
function );
memory_free(
segment_table->basename );
segment_table->basename = NULL;
segment_table->basename_size = 0;
return( -1 );
}
segment_table->basename[ basename_length ] = 0;
#else
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_copy_from_utf32(
(libuna_utf8_character_t *) segment_table->basename,
segment_table->basename_size,
(libuna_utf32_character_t *) basename,
basename_length + 1,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_copy_from_utf16(
(libuna_utf8_character_t *) segment_table->basename,
segment_table->basename_size,
(libuna_utf16_character_t *) basename,
basename_length + 1,
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 *) segment_table->basename,
segment_table->basename_size,
libclocale_codepage,
(libuna_utf32_character_t *) basename,
basename_length + 1,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_copy_from_utf16(
(uint8_t *) segment_table->basename,
segment_table->basename_size,
libclocale_codepage,
(libuna_utf16_character_t *) basename,
basename_length + 1,
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 basename.",
function );
memory_free(
segment_table->basename );
segment_table->basename = NULL;
segment_table->basename_size = 0;
return( -1 );
}
#endif /* defined( LIBCSTRING_HAVE_WIDE_SYSTEM_CHARACTER ) */
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 );
}
/* Retrieves a temporary filename
*
* On entry temporary_filename should contain a template filename.
*
* Returns 1 if successful, 0 if not available or -1 on error
*/
int cfile_test_get_temporary_filename_wide(
wchar_t *temporary_filename,
size_t temporary_filename_size,
libcerror_error_t **error )
{
static char *function = "cfile_test_get_temporary_filename_wide";
#if defined( HAVE_MKSTEMP ) && defined( HAVE_CLOSE )
char *narrow_string = NULL;
size_t narrow_string_size = 0;
int file_descriptor = -1;
int result = 0;
#endif
if( temporary_filename == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid temporary filename.",
function );
return( -1 );
}
if( temporary_filename_size > (size_t) SSIZE_MAX )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,
"%s: invalid temporary filename size value exceeds maximum.",
function );
return( -1 );
}
#if defined( HAVE_MKSTEMP ) && defined( HAVE_CLOSE )
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_size_from_utf32(
(libuna_utf32_character_t *) temporary_filename,
temporary_filename_size,
&narrow_string_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_size_from_utf16(
(libuna_utf16_character_t *) temporary_filename,
temporary_filename_size,
&narrow_string_size,
error );
#endif
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_byte_stream_size_from_utf32(
(libuna_utf32_character_t *) temporary_filename,
temporary_filename_size,
libclocale_codepage,
&narrow_string_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_size_from_utf16(
(libuna_utf16_character_t *) temporary_filename,
temporary_filename_size,
libclocale_codepage,
&narrow_string_size,
error );
#endif
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to determine narrow string size.",
function );
return( -1 );
}
narrow_string = narrow_string_allocate(
narrow_string_size );
if( narrow_string == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_MEMORY,
LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
"%s: unable to create narrow string.",
function );
goto on_error;
}
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf8_string_copy_from_utf32(
(libuna_utf8_character_t *) narrow_string,
narrow_string_size,
(libuna_utf32_character_t *) temporary_filename,
temporary_filename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf8_string_copy_from_utf16(
(libuna_utf8_character_t *) narrow_string,
narrow_string_size,
(libuna_utf16_character_t *) temporary_filename,
temporary_filename_size,
error );
#endif
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_byte_stream_copy_from_utf32(
(uint8_t *) narrow_string,
narrow_string_size,
libclocale_codepage,
(libuna_utf32_character_t *) temporary_filename,
temporary_filename_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_byte_stream_copy_from_utf16(
(uint8_t *) narrow_string,
narrow_string_size,
libclocale_codepage,
(libuna_utf16_character_t *) temporary_filename,
temporary_filename_size,
error );
#endif
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to set narrow string.",
function );
return( -1 );
}
file_descriptor = mkstemp(
narrow_string );
if( file_descriptor == -1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_OPEN_FAILED,
"%s: unable to open temporary file.",
function );
goto on_error;
}
if( close(
file_descriptor ) != 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_IO,
LIBCERROR_IO_ERROR_CLOSE_FAILED,
"%s: unable to close temporary file.",
function );
goto on_error;
}
if( libclocale_codepage == 0 )
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf32_string_copy_from_utf8(
(libuna_utf32_character_t *) temporary_filename,
temporary_filename_size,
(uint8_t *) narrow_string,
narrow_string_size,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf16_string_copy_from_utf8(
(libuna_utf16_character_t *) temporary_filename,
temporary_filename_size,
(uint8_t *) narrow_string,
narrow_string_size,
error );
#endif
}
else
{
#if SIZEOF_WCHAR_T == 4
result = libuna_utf32_string_copy_from_byte_stream(
(libuna_utf32_character_t *) temporary_filename,
temporary_filename_size,
(uint8_t *) narrow_string,
narrow_string_size,
libclocale_codepage,
error );
#elif SIZEOF_WCHAR_T == 2
result = libuna_utf16_string_copy_from_byte_stream(
(libuna_utf16_character_t *) temporary_filename,
temporary_filename_size,
(uint8_t *) narrow_string,
narrow_string_size,
libclocale_codepage,
error );
#endif
}
if( result != 1 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_CONVERSION,
LIBCERROR_CONVERSION_ERROR_GENERIC,
"%s: unable to set temporary filename.",
function );
return( -1 );
}
memory_free(
narrow_string );
narrow_string = NULL;
return( 1 );
on_error:
if( narrow_string != NULL )
{
memory_free(
narrow_string );
}
return( -1 );
#else
return( 0 );
#endif /* defined( HAVE_MKSTEMP ) && defined( HAVE_CLOSE ) */
}
