/*

 * Data definition functions

 *

 * Copyright (C) 2009-2025, 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 <system_string.h>

#include <types.h>

#include "libesedb_catalog_definition.h"

#include "libesedb_column_type.h"

#include "libesedb_data_definition.h"

#include "libesedb_debug.h"

#include "libesedb_definitions.h"

#include "libesedb_io_handle.h"

#include "libesedb_libbfio.h"

#include "libesedb_libcdata.h"

#include "libesedb_libcerror.h"

#include "libesedb_libcnotify.h"

#include "libesedb_libfcache.h"

#include "libesedb_libfdata.h"

#include "libesedb_libfvalue.h"

#include "libesedb_page.h"

#include "libesedb_table_definition.h"

#include "libesedb_value_data_handle.h"

#include "esedb_page_values.h"

/* Creates a data definition

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

 * Returns 1 if successful or -1 on error

 */

int libesedb_data_definition_initialize(

     libesedb_data_definition_t **data_definition,

     libcerror_error_t **error )

{

  static char *function = "libesedb_data_definition_initialize";

  if( data_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid data definition.",

     function );

    return( -1 );

  }

  if( *data_definition != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid data definition value already set.",

     function );

    return( -1 );

  }

  *data_definition = memory_allocate_structure(

                      libesedb_data_definition_t );

  if( *data_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create data definition.",

     function );

    goto on_error;

  }

  if( memory_set(

       *data_definition,

       0,

       sizeof( libesedb_data_definition_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear data definition.",

     function );

    goto on_error;

  }

  return( 1 );

on_error:

  if( *data_definition != NULL )

  {

    memory_free(

     *data_definition );

    *data_definition = NULL;

  }

  return( -1 );

}

/* Frees a data definition

 * Returns 1 if successful or -1 on error

 */

int libesedb_data_definition_free(

     libesedb_data_definition_t **data_definition,

     libcerror_error_t **error )

{

  static char *function = "libesedb_data_definition_free";

  if( data_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid data definition.",

     function );

    return( -1 );

  }

  if( *data_definition != NULL )

  {

    memory_free(

     *data_definition );

    *data_definition = NULL;

  }

  return( 1 );

}

/* Reads the data

 * Returns 1 if successful or -1 on error

 */

int libesedb_data_definition_read_data(

     libesedb_data_definition_t *data_definition,

     libbfio_handle_t *file_io_handle,

     libesedb_io_handle_t *io_handle,

     libfdata_vector_t *pages_vector,

     libfcache_cache_t *pages_cache,

     uint8_t **data,

     size_t *data_size,

     libcerror_error_t **error )

{

  libesedb_page_t *page             = NULL;

  libesedb_page_value_t *page_value = NULL;

  static char *function             = "libesedb_data_definition_read_data";

  off64_t element_data_offset       = 0;

  uint16_t data_offset              = 0;

  if( data_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid data definition.",

     function );

    return( -1 );

  }

  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( data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid data.",

     function );

    return( -1 );

  }

  if( data_size == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid data size.",

     function );

    return( -1 );

  }

  if( libfdata_vector_get_element_value_at_offset(

       pages_vector,

       (intptr_t *) file_io_handle,

       (libfdata_cache_t *) pages_cache,

       data_definition->page_offset,

       &element_data_offset,

       (intptr_t **) &page,

       0,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve page: %" PRIu32 " at offset: 0x%08" PRIx64 ".",

     function,

     data_definition->page_number,

     data_definition->page_offset );

    return( -1 );

  }

  if( page == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing page.",

     function );

    return( -1 );

  }

  if( libesedb_page_get_value_by_index(

       page,

       data_definition->page_value_index,

       &page_value,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve page value: %" PRIu16 ".",

     function,

     data_definition->page_value_index );

    return( -1 );

  }

  if( page_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing page value: %" PRIu16 ".",

     function,

     data_definition->page_value_index );

    return( -1 );

  }

  if( page_value->data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing page value data.",

     function );

    return( -1 );

  }

  data_offset = data_definition->data_offset - page_value->offset;

  if( ( data_definition->data_offset < page_value->offset )

   || ( data_offset > page_value->size ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid data definition - data offset value out of bounds.",

     function );

    return( -1 );

  }

  *data      = &( page_value->data[ data_offset ] );

  *data_size = (size_t) ( page_value->size - data_offset );

  return( 1 );

}

/* Reads the record

 * Uses the definition data in the catalog definitions

 * Returns 1 if successful or -1 on error

 */

int libesedb_data_definition_read_record(

     libesedb_data_definition_t *data_definition,

     libbfio_handle_t *file_io_handle,

     libesedb_io_handle_t *io_handle,

     libfdata_vector_t *pages_vector,

     libfcache_cache_t *pages_cache,

     libesedb_table_definition_t *table_definition,

     libesedb_table_definition_t *template_table_definition,

     libcdata_array_t *values_array,

     uint8_t *record_flags,

     libcerror_error_t **error )

{

  libesedb_catalog_definition_t *column_catalog_definition = NULL;

  libesedb_page_t *page                                    = NULL;

  libesedb_page_value_t *page_value                        = NULL;

  libfvalue_data_handle_t *value_data_handle               = NULL;

  libfvalue_value_t *record_value                          = NULL;

  uint8_t *record_data                                     = NULL;

  uint8_t *tagged_data_type_offset_data                    = NULL;

  static char *function                                    = "libesedb_data_definition_read_record";

  size_t record_data_size                                  = 0;

  size_t remaining_definition_data_size                    = 0;

  off64_t element_data_offset                              = 0;

  uint16_t data_offset                                     = 0;

  uint16_t fixed_size_data_type_value_offset               = 0;

  uint16_t masked_previous_tagged_data_type_offset         = 0;

  uint16_t masked_tagged_data_type_offset                  = 0;

  uint16_t previous_tagged_data_type_offset                = 0;

  uint16_t previous_variable_size_data_type_size           = 0;

  uint16_t tagged_data_type_identifier                     = 0;

  uint16_t tagged_data_type_offset                         = 0;

  uint16_t tagged_data_type_offset_bitmask                 = 0x3fff;

  uint16_t tagged_data_type_offset_data_size               = 0;

  uint16_t tagged_data_type_size                           = 0;

  uint16_t tagged_data_type_value_offset                   = 0;

  uint16_t tagged_data_types_offset                        = 0;

  uint16_t variable_size_data_type_offset                  = 0;

  uint16_t variable_size_data_type_size                    = 0;

  uint16_t variable_size_data_type_value_offset            = 0;

  uint16_t variable_size_data_type_value_size              = 0;

  uint16_t variable_size_data_types_offset                 = 0;

  uint8_t current_variable_size_data_type                  = 0;

  uint8_t last_fixed_size_data_type                        = 0;

  uint8_t last_variable_size_data_type                     = 0;

  uint8_t number_of_variable_size_data_types               = 0;

  uint8_t record_value_type                                = 0;

  uint8_t tagged_data_types_format                         = LIBESEDB_TAGGED_DATA_TYPES_FORMAT_INDEX;

  int column_catalog_definition_index                      = 0;

  int encoding                                             = 0;

  int number_of_column_catalog_definitions                 = 0;

  int number_of_table_column_catalog_definitions           = 0;

  int number_of_template_table_column_catalog_definitions  = 0;

  int record_value_codepage                                = 0;

  if( data_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid data definition.",

     function );

    return( -1 );

  }

  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( table_definition == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid table definition.",

     function );

    return( -1 );

  }

  if( values_array == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid values array.",

     function );

    return( -1 );

  }

  if( record_flags == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid record flags.",

     function );

    return( -1 );

  }

  if( libfdata_vector_get_element_value_at_offset(

       pages_vector,

       (intptr_t *) file_io_handle,

       (libfdata_cache_t *) pages_cache,

       data_definition->page_offset,

       &element_data_offset,

       (intptr_t **) &page,

       0,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve page: %" PRIu32 " at offset: 0x%08" PRIx64 ".",

     function,

     data_definition->page_number,

     data_definition->page_offset );

    goto on_error;

  }

  if( page == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing page.",

     function );

    goto on_error;

  }

  if( libesedb_page_get_value_by_index(

       page,

       data_definition->page_value_index,

       &page_value,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve page value: %" PRIu16 ".",

     function,

     data_definition->page_value_index );

    goto on_error;

  }

  if( page_value == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing page value: %" PRIu16 ".",

     function,

     data_definition->page_value_index );

    goto on_error;

  }

  if( page_value->data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing page value data.",

     function );

    goto on_error;

  }

  data_offset = data_definition->data_offset - page_value->offset;

  if( ( data_definition->data_offset < page_value->offset )

   || ( data_offset > page_value->size ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid data definition - data offset value out of bounds.",

     function );

    goto on_error;

  }

  record_data      = &( page_value->data[ data_offset ] );

  record_data_size = page_value->size - data_offset;

  if( record_data_size < sizeof( esedb_data_definition_header_t ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid record data size value out of bounds.",

     function );

    goto on_error;

  }

  if( ( io_handle->format_version == 0x620 )

   && ( io_handle->format_revision <= 2 ) )

  {

    tagged_data_types_format = LIBESEDB_TAGGED_DATA_TYPES_FORMAT_LINEAR;

  }

  if( ( io_handle->format_revision >= LIBESEDB_FORMAT_REVISION_EXTENDED_PAGE_HEADER )

   && ( io_handle->page_size >= 16384 ) )

  {

    tagged_data_type_offset_bitmask = 0x7fff;

  }

  last_fixed_size_data_type    = ( (esedb_data_definition_header_t *) record_data )->last_fixed_size_data_type;

  last_variable_size_data_type = ( (esedb_data_definition_header_t *) record_data )->last_variable_size_data_type;

  byte_stream_copy_to_uint16_little_endian(

   ( (esedb_data_definition_header_t *) record_data )->variable_size_data_types_offset,

   variable_size_data_types_offset );

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: last fixed size data type\t\t\t: %" PRIu8 "\n",

     function,

     last_fixed_size_data_type );

    libcnotify_printf(

     "%s: last variable size data type\t\t: %" PRIu8 "\n",

     function,

     last_variable_size_data_type );

    libcnotify_printf(

     "%s: variable size data types offset\t\t: %" PRIu16 "\n",

     function,

     variable_size_data_types_offset );

  }

#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  if( template_table_definition != NULL )

  {

    if( libesedb_table_definition_get_number_of_column_catalog_definitions(

         template_table_definition,

         &number_of_template_table_column_catalog_definitions,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_GET_FAILED,

       "%s: unable to retrieve number of template table column catalog definitions.",

       function );

      goto on_error;

    }

  }

  if( libesedb_table_definition_get_number_of_column_catalog_definitions(

       table_definition,

       &number_of_table_column_catalog_definitions,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve number of table column catalog definitions.",

     function );

    goto on_error;

  }

  number_of_column_catalog_definitions = number_of_table_column_catalog_definitions;

  if( template_table_definition != NULL )

  {

    if( number_of_table_column_catalog_definitions > number_of_template_table_column_catalog_definitions )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

       LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

       "%s: invalid number of table column catalog definitions value exceeds number in template table.",

       function );

      goto on_error;

    }

    number_of_column_catalog_definitions += number_of_template_table_column_catalog_definitions;

  }

  if( libcdata_array_resize(

       values_array,

       number_of_column_catalog_definitions,

       (int (*)(intptr_t **, libcerror_error_t **)) &libfvalue_value_free,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED,

     "%s: unable to resize values array.",

     function );

    goto on_error;

  }

  if( last_variable_size_data_type > 127 )

  {

    number_of_variable_size_data_types = last_variable_size_data_type - 127;

  }

  fixed_size_data_type_value_offset    = (uint16_t) sizeof( esedb_data_definition_header_t );

  current_variable_size_data_type      = 127;

  variable_size_data_type_offset       = variable_size_data_types_offset;

  variable_size_data_type_value_offset = variable_size_data_types_offset + ( number_of_variable_size_data_types * 2 );

  for( column_catalog_definition_index = 0;

       column_catalog_definition_index < number_of_column_catalog_definitions;

       column_catalog_definition_index++ )

  {

    if( ( template_table_definition != NULL )

     && ( column_catalog_definition_index < number_of_template_table_column_catalog_definitions ) )

    {

      if( libesedb_table_definition_get_column_catalog_definition_by_index(

           template_table_definition,

           column_catalog_definition_index,

           &column_catalog_definition,

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_GET_FAILED,

         "%s: unable to retrieve column catalog definition: %d from template table.",

         function,

         column_catalog_definition_index );

        goto on_error;

      }

    }

    else

    {

      if( libesedb_table_definition_get_column_catalog_definition_by_index(

           table_definition,

           column_catalog_definition_index,

           &column_catalog_definition,

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_GET_FAILED,

         "%s: unable to retrieve column catalog definition: %d from table.",

         function,

         column_catalog_definition_index );

        goto on_error;

      }

    }

    if( column_catalog_definition == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

       "%s: missing column catalog definition: %d.",

       function,

       column_catalog_definition_index );

      goto on_error;

    }

    if( column_catalog_definition->type != LIBESEDB_CATALOG_DEFINITION_TYPE_COLUMN )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,

       "%s: unsupported column catalog definition type: %" PRIu16 " for list element: %d.",

       function,

       column_catalog_definition->type,

       column_catalog_definition_index );

      goto on_error;

    }

    if( ( template_table_definition != NULL )

     && ( column_catalog_definition_index == number_of_template_table_column_catalog_definitions ) )

    {

      if( column_catalog_definition->identifier != 256 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,

         "%s: only tagged data types supported in tables using a template table.",

         function );

        goto on_error;

      }

    }

#if defined( HAVE_DEBUG_OUTPUT )

    if( libcnotify_verbose != 0 )

    {

      libcnotify_printf(

       "%s: column definition identifier\t\t: %03" PRIu32 "\n",

       function,

       column_catalog_definition->identifier );

      libcnotify_printf(

       "%s: column definition name\t\t\t: %" PRIs_SYSTEM "\n",

       function,

       column_catalog_definition->name_string );

      libcnotify_printf(

       "%s: column definition type\t\t\t: %s (%s)\n",

       function,

       libesedb_column_type_get_description(

        column_catalog_definition->column_type ),

       libesedb_column_type_get_identifier(

        column_catalog_definition->column_type ) );

    }

#endif /* defined( HAVE_DEBUG_OUTPUT ) */

/* TODO refactor to value type */

    switch( column_catalog_definition->column_type )

    {

      case LIBESEDB_COLUMN_TYPE_NULL:

        /* JET_coltypNil seems to be able to contain data */

        record_value_type = LIBFVALUE_VALUE_TYPE_BINARY_DATA;

        break;

      case LIBESEDB_COLUMN_TYPE_BOOLEAN:

        record_value_type = LIBFVALUE_VALUE_TYPE_BOOLEAN;

        break;

      case LIBESEDB_COLUMN_TYPE_INTEGER_8BIT_UNSIGNED:

        record_value_type = LIBFVALUE_VALUE_TYPE_UNSIGNED_INTEGER_8BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_INTEGER_16BIT_SIGNED:

        record_value_type = LIBFVALUE_VALUE_TYPE_INTEGER_16BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_INTEGER_16BIT_UNSIGNED:

        record_value_type = LIBFVALUE_VALUE_TYPE_UNSIGNED_INTEGER_16BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_INTEGER_32BIT_SIGNED:

        record_value_type = LIBFVALUE_VALUE_TYPE_INTEGER_32BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_INTEGER_32BIT_UNSIGNED:

        record_value_type = LIBFVALUE_VALUE_TYPE_UNSIGNED_INTEGER_32BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_CURRENCY:

      case LIBESEDB_COLUMN_TYPE_INTEGER_64BIT_SIGNED:

        record_value_type = LIBFVALUE_VALUE_TYPE_INTEGER_64BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_FLOAT_32BIT:

        record_value_type = LIBFVALUE_VALUE_TYPE_FLOATING_POINT_32BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_DOUBLE_64BIT:

        record_value_type = LIBFVALUE_VALUE_TYPE_FLOATING_POINT_64BIT;

        break;

      case LIBESEDB_COLUMN_TYPE_DATE_TIME:

        record_value_type = LIBFVALUE_VALUE_TYPE_FILETIME;

        break;

      case LIBESEDB_COLUMN_TYPE_GUID:

        record_value_type = LIBFVALUE_VALUE_TYPE_GUID;

        break;

      case LIBESEDB_COLUMN_TYPE_BINARY_DATA:

      case LIBESEDB_COLUMN_TYPE_LARGE_BINARY_DATA:

        record_value_type = LIBFVALUE_VALUE_TYPE_BINARY_DATA;

        break;

      case LIBESEDB_COLUMN_TYPE_TEXT:

      case LIBESEDB_COLUMN_TYPE_LARGE_TEXT:

        record_value_type = LIBFVALUE_VALUE_TYPE_STRING_BYTE_STREAM;

        break;

      case LIBESEDB_COLUMN_TYPE_SUPER_LARGE_VALUE:

/* TODO handle this value type */

        record_value_type = LIBFVALUE_VALUE_TYPE_UNDEFINED;

        break;

      default:

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,

         "%s: unsupported column type: %" PRIu32 ".",

         function,

         column_catalog_definition->column_type );

        goto on_error;

    }

    if( libfvalue_data_handle_initialize(

         &value_data_handle,

         (int (*)(libfvalue_data_handle_t *, const uint8_t *, size_t, int, uint32_t, libcerror_error_t **)) &libesedb_value_data_handle_read_value_entries,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

       "%s: unable to create value data handle.",

       function );

      goto on_error;

    }

    if( ( column_catalog_definition->column_type == LIBESEDB_COLUMN_TYPE_TEXT )

     || ( column_catalog_definition->column_type == LIBESEDB_COLUMN_TYPE_LARGE_TEXT ) )

    {

      record_value_codepage = (int) column_catalog_definition->codepage;

      /* If the codepage is not set use the default codepage

       */

      if( record_value_codepage == 0 )

      {

        record_value_codepage = io_handle->ascii_codepage;

      }

      /* Codepage 1200 in the ESE database format is not strict UTF-16 little-endian

       * it can be used for ASCII strings as well.

       */

      if( record_value_codepage == 1200 )

      {

        record_value_codepage = LIBFVALUE_CODEPAGE_1200_MIXED;

      }

      encoding = record_value_codepage;

    }

    else

    {

      encoding = LIBFVALUE_ENDIAN_LITTLE;

    }

    if( column_catalog_definition->identifier <= 127 )

    {

      if( column_catalog_definition->identifier <= last_fixed_size_data_type )

      {

        if( column_catalog_definition->size > ( record_data_size - fixed_size_data_type_value_offset ) )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,

           "%s: invalid data definition - size value out of bounds.",

           function );

          goto on_error;

        }

#if defined( HAVE_DEBUG_OUTPUT )

        if( libcnotify_verbose != 0 )

        {

          libcnotify_printf(

           "%s: (%03" PRIu32 ") fixed size data type size\t\t: %" PRIu32 "\n",

           function,

           column_catalog_definition->identifier,

           column_catalog_definition->size );

          libcnotify_print_data(

           &( record_data[ fixed_size_data_type_value_offset ] ),

           column_catalog_definition->size,

           0 );

        }

#endif /* defined( HAVE_DEBUG_OUTPUT ) */

        if( libfvalue_data_handle_set_data(

             value_data_handle,

             &( record_data[ fixed_size_data_type_value_offset ] ),

             column_catalog_definition->size,

             encoding,

             LIBFVALUE_VALUE_DATA_FLAG_MANAGED,

             error ) != 1 )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_SET_FAILED,

           "%s: unable to set data in fixed size data type definition.",

           function );

          goto on_error;

        }

        if( column_catalog_definition->size > (uint32_t) UINT16_MAX )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,

           "%s: invalid common catalog definition size value exceeds maximum.",

           function );

          goto on_error;

        }

        fixed_size_data_type_value_offset += (uint16_t) column_catalog_definition->size;

      }

    }

    else if( current_variable_size_data_type < last_variable_size_data_type )

    {

      while( current_variable_size_data_type < column_catalog_definition->identifier )

      {

        if( variable_size_data_type_offset > ( record_data_size - 2 ) )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

           LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

           "%s: invalid variable size data type offset value out of bounds.",

           function );

          goto on_error;

        }

        byte_stream_copy_to_uint16_little_endian(

         &( record_data[ variable_size_data_type_offset ] ),

         variable_size_data_type_size );

        variable_size_data_type_offset += 2;

        current_variable_size_data_type++;

#if defined( HAVE_DEBUG_OUTPUT )

        if( libcnotify_verbose != 0 )

        {

          libcnotify_printf(

           "%s: (%03" PRIu16 ") variable size data type size\t: 0x%04" PRIx16 " (%" PRIu16 ")\n",

           function,

           current_variable_size_data_type,

           variable_size_data_type_size,

           ( ( variable_size_data_type_size & 0x8000 ) != 0 ) ? 0 : ( variable_size_data_type_size & 0x7fff ) - previous_variable_size_data_type_size );

        }

#endif

        if( current_variable_size_data_type == column_catalog_definition->identifier )

        {

          /* The MSB signifies that the variable size data type is empty

           */

          if( ( variable_size_data_type_size & 0x8000 ) == 0 )

          {

            if( variable_size_data_type_size < previous_variable_size_data_type_size )

            {

              libcerror_error_set(

               error,

               LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

               LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

               "%s: invalid variable size data type size value out of bounds.",

               function );

              goto on_error;

            }

            variable_size_data_type_value_size = variable_size_data_type_size - previous_variable_size_data_type_size;

            if( ( variable_size_data_type_value_size > record_data_size )

             || ( variable_size_data_type_value_offset > ( record_data_size - variable_size_data_type_value_size ) ) )

            {