/*

 * Input/Output (IO) handle functions

 *

 * Copyright (C) 2010-2024, Joachim Metz <joachim.metz@gmail.com>

 *

 * Refer to AUTHORS for acknowledgements.

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 */

#include <common.h>

#include <memory.h>

#include <narrow_string.h>

#include <system_string.h>

#include <types.h>

#include <wide_string.h>

#include "libsmraw_definitions.h"

#include "libsmraw_filename.h"

#include "libsmraw_io_handle.h"

#include "libsmraw_libbfio.h"

#include "libsmraw_libcerror.h"

#include "libsmraw_libclocale.h"

#include "libsmraw_libuna.h"

#include "libsmraw_unused.h"

/* Creates an IO handle

 * Make sure the value io_handle is referencing, is set to NULL

 * Returns 1 if successful or -1 on error

 */

int libsmraw_io_handle_initialize(

     libsmraw_io_handle_t **io_handle,

     libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_initialize";

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( *io_handle != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid IO handle value already set.",

     function );

    return( -1 );

  }

  *io_handle = memory_allocate_structure(

                libsmraw_io_handle_t );

  if( *io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create IO handle.",

     function );

    goto on_error;

  }

  if( memory_set(

       *io_handle,

       0,

       sizeof( libsmraw_io_handle_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear IO handle.",

     function );

    goto on_error;

  }

  ( *io_handle )->maximum_segment_size = LIBSMRAW_DEFAULT_MAXIMUM_SEGMENT_SIZE;

  return( 1 );

on_error:

  if( *io_handle != NULL )

  {

    memory_free(

     *io_handle );

    *io_handle = NULL;

  }

  return( -1 );

}

/* Frees an IO handle

 * Returns 1 if successful or -1 on error

 */

int libsmraw_io_handle_free(

     libsmraw_io_handle_t **io_handle,

     libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_free";

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( *io_handle != NULL )

  {

    if( ( *io_handle )->basename != NULL )

    {

      memory_free(

       ( *io_handle )->basename );

    }

    memory_free(

     *io_handle );

    *io_handle = NULL;

  }

  return( 1 );

}

/* Clears the IO handle

 * Returns 1 if successful or -1 on error

 */

int libsmraw_io_handle_clear(

     libsmraw_io_handle_t *io_handle,

     libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_clear";

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( io_handle->basename != NULL )

  {

    memory_free(

     io_handle->basename );

  }

  if( memory_set(

       io_handle,

       0,

       sizeof( libsmraw_io_handle_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear IO handle.",

     function );

    return( -1 );

  }

  io_handle->maximum_segment_size = LIBSMRAW_DEFAULT_MAXIMUM_SEGMENT_SIZE;

  return( 1 );

}

/* Creates a new segment file

 * Callback function for the segments stream

 * Returns the number of bytes read or -1 on error

 */

int libsmraw_io_handle_create_segment(

     libsmraw_io_handle_t *io_handle,

     libbfio_pool_t *file_io_pool,

     int segment_index,

     int *segment_file_index,

     off64_t *segment_offset,

     size64_t *segment_size,

     uint32_t *segment_flags,

     libcerror_error_t **error )

{

  libbfio_handle_t *file_io_handle = NULL;

  system_character_t *filename     = NULL;

  static char *function            = "libsmraw_io_handle_create_segment";

  size_t filename_size             = 0;

  int file_io_pool_entry           = 0;

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( segment_file_index == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid segment file index.",

     function );

    return( -1 );

  }

  if( segment_offset == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid segment offset.",

     function );

    return( -1 );

  }

  if( segment_size == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid segment size.",

     function );

    return( -1 );

  }

  if( segment_flags == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid segment flags.",

     function );

    return( -1 );

  }

  if( libsmraw_filename_create(

       &filename,

       &filename_size,

       io_handle->basename,

       io_handle->basename_size,

       io_handle->number_of_segments,

       segment_index,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create segment filename: %d.",

     function,

     segment_index );

    goto on_error;

  }

  if( libbfio_file_initialize(

       &file_io_handle,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create file IO handle.",

     function );

    goto on_error;

  }

#if defined( HAVE_WIDE_SYSTEM_CHARACTER )

  if( libbfio_file_set_name_wide(

       file_io_handle,

       filename,

       filename_size,

       error ) != 1 )

#else

  if( libbfio_file_set_name(

       file_io_handle,

       filename,

       filename_size,

       error ) != 1 )

#endif

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_SET_FAILED,

     "%s: unable to set name in file IO handle.",

     function );

    goto on_error;

  }

  memory_free(

   filename );

  filename = NULL;

  if( libbfio_pool_append_handle(

       file_io_pool,

       &file_io_pool_entry,

       file_io_handle,

       LIBBFIO_OPEN_WRITE_TRUNCATE,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_APPEND_FAILED,

     "%s: unable to append file IO handle to pool.",

     function );

    goto on_error;

  }

  if( libbfio_pool_open(

       file_io_pool,

       file_io_pool_entry,

       LIBBFIO_OPEN_WRITE_TRUNCATE,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_OPEN_FAILED,

     "%s: unable to open file IO pool entry: %d.",

     function,

     file_io_pool_entry );

    file_io_handle = NULL;

    goto on_error;

  }

  if( io_handle->maximum_segment_size == 0 )

  {

    *segment_size = (size64_t) INT64_MAX;

  }

  else

  {

    *segment_size = io_handle->maximum_segment_size;

  }

  *segment_file_index = file_io_pool_entry;

  *segment_offset     = 0;

  *segment_flags      = 0;

  return( 1 );

on_error:

  if( file_io_handle != NULL )

  {

    libbfio_handle_free(

     &file_io_handle,

     NULL );

  }

  if( filename != NULL )

  {

    memory_free(

     filename );

  }

  return( -1 );

}

/* Reads segment data into a buffer

 * Callback function for the segments stream

 * Returns the number of bytes read or -1 on error

 */

ssize_t libsmraw_io_handle_read_segment_data(

         libsmraw_io_handle_t *io_handle,

         libbfio_pool_t *file_io_pool,

         int segment_index LIBSMRAW_ATTRIBUTE_UNUSED,

         int segment_file_index,

         uint8_t *segment_data,

         size_t segment_data_size,

         uint32_t segment_flags LIBSMRAW_ATTRIBUTE_UNUSED,

         uint8_t read_flags LIBSMRAW_ATTRIBUTE_UNUSED,

         libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_read_segment_data";

  ssize_t read_count    = 0;

  LIBSMRAW_UNREFERENCED_PARAMETER( segment_index )

  LIBSMRAW_UNREFERENCED_PARAMETER( segment_flags )

  LIBSMRAW_UNREFERENCED_PARAMETER( read_flags )

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  read_count = libbfio_pool_read_buffer(

                file_io_pool,

                segment_file_index,

                segment_data,

                segment_data_size,

                error );

  if( read_count == -1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_READ_FAILED,

     "%s: unable to read segment data.",

     function );

    return( -1 );

  }

  return( read_count );

}

/* Writes segment data from a buffer

 * Callback function for the segments stream

 * Returns the number of bytes written or -1 on error

 */

ssize_t libsmraw_io_handle_write_segment_data(

         libsmraw_io_handle_t *io_handle,

         libbfio_pool_t *file_io_pool,

         int segment_index LIBSMRAW_ATTRIBUTE_UNUSED,

         int segment_file_index,

         const uint8_t *segment_data,

         size_t segment_data_size,

         uint32_t segment_flags LIBSMRAW_ATTRIBUTE_UNUSED,

         uint8_t write_flags LIBSMRAW_ATTRIBUTE_UNUSED,

         libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_write_segment_data";

  ssize_t write_count    = 0;

  LIBSMRAW_UNREFERENCED_PARAMETER( segment_index )

  LIBSMRAW_UNREFERENCED_PARAMETER( segment_flags )

  LIBSMRAW_UNREFERENCED_PARAMETER( write_flags )

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  write_count = libbfio_pool_write_buffer(

                 file_io_pool,

                 segment_file_index,

                 segment_data,

                 segment_data_size,

                 error );

  if( write_count == -1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_READ_FAILED,

     "%s: unable to write segment data.",

     function );

    return( -1 );

  }

  return( write_count );

}

/* Seeks a certain segment offset

 * Callback function for the segments stream

 * Returns the offset or -1 on error

 */

off64_t libsmraw_io_handle_seek_segment_offset(

         libsmraw_io_handle_t *io_handle,

         libbfio_pool_t *file_io_pool,

         int segment_index LIBSMRAW_ATTRIBUTE_UNUSED,

         int segment_file_index,

         off64_t segment_offset,

         libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_seek_segment_offset";

  LIBSMRAW_UNREFERENCED_PARAMETER( segment_index )

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  segment_offset = libbfio_pool_seek_offset(

                    file_io_pool,

                    segment_file_index,

                    segment_offset,

                    SEEK_SET,

                    error );

  if( segment_offset == -1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_READ_FAILED,

     "%s: unable to seek segment offset.",

     function );

    return( -1 );

  }

  return( segment_offset );

}

/* Retrieves the segment basename size

 * The segment basename size includes the end of string character

 * Returns 1 if succesful or -1 on error

 */

int libsmraw_io_handle_get_basename_size(

     libsmraw_io_handle_t *io_handle,

     size_t *basename_size,

     libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_get_basename_size";

#if defined( HAVE_WIDE_SYSTEM_CHARACTER )

  int result            = 0;

#endif

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( io_handle->basename == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid IO handle - missing basename.",

     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 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 *) io_handle->basename,

              io_handle->basename_size,

              basename_size,

              error );

#elif SIZEOF_WCHAR_T == 2

    result = libuna_utf8_string_size_from_utf16(

              (libuna_utf16_character_t *) io_handle->basename,

              io_handle->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 *) io_handle->basename,

              io_handle->basename_size,

              libclocale_codepage,

              basename_size,

              error );

#elif SIZEOF_WCHAR_T == 2

    result = libuna_byte_stream_size_from_utf16(

              (libuna_utf16_character_t *) io_handle->basename,

              io_handle->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 = io_handle->basename_size;

#endif

  return( 1 );

}

/* Retrieves the segment basename

 * The segment basename size should include the end of string character

 * Returns 1 if succesful or -1 on error

 */

int libsmraw_io_handle_get_basename(

     libsmraw_io_handle_t *io_handle,

     char *basename,

     size_t basename_size,

     libcerror_error_t **error )

{

  static char *function       = "libsmraw_io_handle_get_basename";

  size_t narrow_basename_size = 0;

#if defined( HAVE_WIDE_SYSTEM_CHARACTER )

  int result                  = 0;

#endif

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     function );

    return( -1 );

  }

  if( io_handle->basename == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: invalid IO handle - missing basename.",

     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 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 *) io_handle->basename,

              io_handle->basename_size,

              &narrow_basename_size,

              error );

#elif SIZEOF_WCHAR_T == 2

    result = libuna_utf8_string_size_from_utf16(

              (libuna_utf16_character_t *) io_handle->basename,

              io_handle->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 *) io_handle->basename,

              io_handle->basename_size,

              libclocale_codepage,

              &narrow_basename_size,

              error );

#elif SIZEOF_WCHAR_T == 2

    result = libuna_byte_stream_size_from_utf16(

              (libuna_utf16_character_t *) io_handle->basename,

              io_handle->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 basename size.",

     function );

    return( -1 );

  }

#else

  narrow_basename_size = io_handle->basename_size;

#endif

  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( 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 *) io_handle->basename,

              io_handle->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 *) io_handle->basename,

              io_handle->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 *) io_handle->basename,

              io_handle->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 *) io_handle->basename,

              io_handle->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( system_string_copy(

       basename,

       io_handle->basename,

       io_handle->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[ io_handle->basename_size - 1 ] = 0;

#endif

  return( 1 );

}

/* Sets the segment basename

 * Returns 1 if succesful or -1 on error

 */

int libsmraw_io_handle_set_basename(

     libsmraw_io_handle_t *io_handle,

     const char *basename,

     size_t basename_length,

     libcerror_error_t **error )

{

  static char *function = "libsmraw_io_handle_set_basename";

#if defined( HAVE_WIDE_SYSTEM_CHARACTER )

  int result            = 0;

#endif

  if( io_handle == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid IO handle.",

     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( basename_length == 0 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS,

     "%s: invalid basename length is zero.",

     function );

    return( -1 );

  }

  if( basename_length > (size_t) SSIZE_MAX )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM,

     "%s: invalid basename length value exceeds maximum.",

     function );

    return( -1 );

  }

  if( io_handle->basename != NULL )

  {

    memory_free(

      io_handle->basename );

     io_handle->basename      = NULL;

     io_handle->basename_size = 0;

  }

#if defined( HAVE_WIDE_SYSTEM_CHARACTER )

  if( libclocale_codepage == 0 )

  {

#if SIZEOF_WCHAR_T == 4

    result = libuna_utf32_string_size_from_utf8(

              (libuna_utf8_character_t *) basename,

              basename_length + 1,

              &( io_handle->basename_size ),

              error );

#elif SIZEOF_WCHAR_T == 2

    result = libuna_utf16_string_size_from_utf8(

              (libuna_utf8_character_t *) basename,

              basename_length + 1,

              &( io_handle->basename_size ),

              error );

#else

#error Unsupported size of wchar_t

#endif /* SIZEOF_WCHAR_T */

  }

  else

  {

#if SIZEOF_WCHAR_T == 4

    result = libuna_utf32_string_size_from_byte_stream(

              (uint8_t *) basename,

              basename_length + 1,

              libclocale_codepage,

              &( io_handle->basename_size ),

              error );

#elif SIZEOF_WCHAR_T == 2

    result = libuna_utf16_string_size_from_byte_stream(

              (uint8_t *) basename,

              basename_length + 1,

              libclocale_codepage,

              &( io_handle->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 name size.",

     function );

    return( -1 );

  }

#else

  io_handle->basename_size = basename_length + 1;

#endif

  io_handle->basename = system_string_allocate(

                         io_handle->basename_size );

  if( io_handle->basename == NULL )

  {

    libcerror_error_set(

     error,