/*

 * The metadata functions

 *

 * Copyright (C) 2014-2023, 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 <byte_stream.h>

#include <memory.h>

#include <narrow_string.h>

#include <types.h>

#include "libvslvm_checksum.h"

#include "libvslvm_definitions.h"

#include "libvslvm_libbfio.h"

#include "libvslvm_libcdata.h"

#include "libvslvm_libcerror.h"

#include "libvslvm_libcnotify.h"

#include "libvslvm_libcsplit.h"

#include "libvslvm_libfvalue.h"

#include "libvslvm_logical_volume_values.h"

#include "libvslvm_metadata.h"

#include "libvslvm_physical_volume.h"

#include "libvslvm_raw_location_descriptor.h"

#include "libvslvm_segment.h"

#include "libvslvm_stripe.h"

#include "libvslvm_volume_group.h"

/* Creates a metadata

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

 * Returns 1 if successful or -1 on error

 */

int libvslvm_metadata_initialize(

     libvslvm_metadata_t **metadata,

     libcerror_error_t **error )

{

  static char *function = "libvslvm_metadata_initialize";

  if( metadata == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid metadata.",

     function );

    return( -1 );

  }

  if( *metadata != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid metadata value already set.",

     function );

    return( -1 );

  }

  *metadata = memory_allocate_structure(

               libvslvm_metadata_t );

  if( *metadata == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create metadata.",

     function );

    goto on_error;

  }

  if( memory_set(

       *metadata,

       0,

       sizeof( libvslvm_metadata_t ) ) == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_SET_FAILED,

     "%s: unable to clear metadata.",

     function );

    memory_free(

     *metadata );

    *metadata = NULL;

    return( -1 );

  }

  return( 1 );

on_error:

  if( *metadata != NULL )

  {

    memory_free(

     *metadata );

    *metadata = NULL;

  }

  return( -1 );

}

/* Frees a metadata

 * Returns 1 if successful or -1 on error

 */

int libvslvm_metadata_free(

     libvslvm_metadata_t **metadata,

     libcerror_error_t **error )

{

  static char *function = "libvslvm_metadata_free";

  int result            = 1;

  if( metadata == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid metadata.",

     function );

    return( -1 );

  }

  if( *metadata != NULL )

  {

    if( ( *metadata )->volume_group != NULL )

    {

      if( libvslvm_internal_volume_group_free(

           (libvslvm_internal_volume_group_t **) &( ( *metadata )->volume_group ),

           error ) != 1 )

      {

        libcerror_error_set(

         error,

         LIBCERROR_ERROR_DOMAIN_RUNTIME,

         LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

         "%s: unable to free volume group.",

         function );

        result = -1;

      }

    }

    memory_free(

     *metadata );

    *metadata = NULL;

  }

  return( result );

}

/* Reads the metadata

 * Returns 1 if successful or -1 on error

 */

int libvslvm_metadata_read_data(

     libvslvm_metadata_t *metadata,

     const uint8_t *data,

     size_t data_size,

     uint32_t stored_checksum,

     libcerror_error_t **error )

{

  libcsplit_narrow_split_string_t *lines = NULL;

  static char *function                  = "libvslvm_metadata_read_data";

  uint32_t calculated_checksum           = 0;

  int line_index                         = 0;

  int number_of_lines                    = 0;

  if( metadata == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid metadata.",

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

   || ( data_size > (size_t) SSIZE_MAX ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

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

     function );

    return( -1 );

  }

  if( libvslvm_checksum_calculate_weak_crc32(

       &calculated_checksum,

       data,

       data_size,

       0xf597a6cfUL,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_SET_FAILED,

     "%s: unable to calculate CRC-32.",

     function );

    goto on_error;

  }

  if( ( stored_checksum != 0 )

   && ( stored_checksum != calculated_checksum ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_INPUT,

     LIBCERROR_INPUT_ERROR_CHECKSUM_MISMATCH,

     "%s: mismatch in checksum ( 0x%08" PRIx32 " != 0x%08" PRIx32 " ).",

     function,

     stored_checksum,

     calculated_checksum );

    goto on_error;

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: metadata:\n%s",

     function,

     data );

  }

#endif

  if( libcsplit_narrow_string_split(

       (char *) data,

       data_size,

       '\n',

       &lines,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to split data into lines.",

     function );

    goto on_error;

  }

  if( libcsplit_narrow_split_string_get_number_of_segments(

       lines,

       &number_of_lines,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

     "%s: unable to retrieve number of lines.",

     function );

    goto on_error;

  }

  if( libvslvm_metadata_read_volume_group(

       metadata,

       lines,

       number_of_lines,

       &line_index,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_READ_FAILED,

     "%s: unable to read volume group.",

     function );

    goto on_error;

  }

  if( libcsplit_narrow_split_string_free(

       &lines,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,

     "%s: unable to free lines.",

     function );

    goto on_error;

  }

  return( 1 );

on_error:

  if( lines != NULL )

  {

    libcsplit_narrow_split_string_free(

     &lines,

     NULL );

  }

  return( -1 );

}

/* Reads the metadata

 * Returns 1 if successful or -1 on error

 */

int libvslvm_metadata_read_file_io_handle(

     libvslvm_metadata_t *metadata,

     libbfio_handle_t *file_io_handle,

     off64_t file_offset,

     size64_t metadata_size,

     uint32_t stored_checksum,

     libcerror_error_t **error )

{

  uint8_t *data         = NULL;

  static char *function = "libvslvm_metadata_read_file_io_handle";

  ssize_t read_count    = 0;

  if( metadata == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid metadata.",

     function );

    return( -1 );

  }

  if( ( metadata_size == 0 )

   || ( metadata_size > (size64_t) MEMORY_MAXIMUM_ALLOCATION_SIZE ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

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

     function );

    goto on_error;

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: reading metadata at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",

     function,

     file_offset,

     file_offset );

  }

#endif

  data = (uint8_t *) memory_allocate(

                      (size_t) metadata_size );

  if( data == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_MEMORY,

     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,

     "%s: unable to create data.",

     function );

    goto on_error;

  }

  read_count = libbfio_handle_read_buffer_at_offset(

                file_io_handle,

                data,

                (size_t) metadata_size,

                file_offset,

                error );

  if( read_count != (ssize_t) metadata_size )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_READ_FAILED,

     "%s: unable to read metadata at offset: %" PRIi64 " (0x%08" PRIx64 ").",

     function,

     file_offset,

     file_offset );

    goto on_error;

  }

  if( libvslvm_metadata_read_data(

       metadata,

       data,

       (size_t) metadata_size,

       stored_checksum,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_IO,

     LIBCERROR_IO_ERROR_READ_FAILED,

     "%s: unable to read metadata.",

     function );

    goto on_error;

  }

  memory_free(

   data );

  return( 1 );

on_error:

  if( data != NULL )

  {

    memory_free(

     data );

  }

  return( -1 );

}

/* Reads the volume group

 * Returns the 1 if succesful or -1 on error

 */

int libvslvm_metadata_read_volume_group(

     libvslvm_metadata_t *metadata,

     libcsplit_narrow_split_string_t *lines,

     int number_of_lines,

     int *line_index,

     libcerror_error_t **error )

{

  libvslvm_internal_volume_group_t *internal_volume_group = NULL;

  char *line_string_segment                               = NULL;

  char *value                                             = NULL;

  char *value_identifier                                  = NULL;

  static char *function                                   = "libvslvm_metadata_read_volume_group";

  size_t line_string_segment_index                        = 0;

  size_t line_string_segment_size                         = 0;

  size_t value_identifier_length                          = 0;

  size_t value_length                                     = 0;

  uint64_t value_64bit                                    = 0;

  if( metadata == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid metadata.",

     function );

    return( -1 );

  }

  if( metadata->volume_group != NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,

     "%s: invalid metadata - volume group value already set.",

     function );

    return( -1 );

  }

  if( line_index == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,

     "%s: invalid line index.",

     function );

    return( -1 );

  }

  if( number_of_lines <= 0 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid number of lines value out of bounds.",

     function );

    return( -1 );

  }

  if( ( *line_index < 0 )

   || ( *line_index >= number_of_lines ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid line index value out of bounds.",

     function );

    return( -1 );

  }

  if( libcsplit_narrow_split_string_get_segment_by_index(

       lines,

       *line_index,

       &line_string_segment,

       &line_string_segment_size,

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_GET_FAILED,

     "%s: unable to retrieve line: %d.",

     function,

     *line_index );

    goto on_error;

  }

  if( line_string_segment == NULL )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

     "%s: missing line string segment: %d.",

     function,

     *line_index );

    goto on_error;

  }

  /* Ignore trailing white space

   */

  if( line_string_segment_size >= 2 )

  {

    line_string_segment_index = line_string_segment_size - 2;

    while( line_string_segment_index > 0 )

    {

      if( ( line_string_segment[ line_string_segment_index ] != '\t' )

       && ( line_string_segment[ line_string_segment_index ] != '\n' )

       && ( line_string_segment[ line_string_segment_index ] != '\f' )

       && ( line_string_segment[ line_string_segment_index ] != '\v' )

       && ( line_string_segment[ line_string_segment_index ] != '\r' )

       && ( line_string_segment[ line_string_segment_index ] != ' ' ) )

      {

        break;

      }

      line_string_segment_index--;

      line_string_segment_size--;

    }

  }

  /* Ignore leading white space

   */

  line_string_segment_index = 0;

  while( line_string_segment_index < line_string_segment_size )

  {

    if( ( line_string_segment[ line_string_segment_index ] != '\t' )

     && ( line_string_segment[ line_string_segment_index ] != '\n' )

     && ( line_string_segment[ line_string_segment_index ] != '\f' )

     && ( line_string_segment[ line_string_segment_index ] != '\v' )

     && ( line_string_segment[ line_string_segment_index ] != '\r' )

     && ( line_string_segment[ line_string_segment_index ] != ' ' ) )

    {

      break;

    }

    line_string_segment_index++;

  }

  if( ( line_string_segment_size < 3 )

   || ( line_string_segment[ line_string_segment_size - 3 ] != ' ' )

   || ( line_string_segment[ line_string_segment_size - 2 ] != '{' ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,

     "%s: unsupported volume group signature.",

     function );

    goto on_error;

  }

  if( libvslvm_volume_group_initialize(

       &( metadata->volume_group ),

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED,

     "%s: unable to create volume group.",

     function );

    goto on_error;

  }

  internal_volume_group = (libvslvm_internal_volume_group_t *) metadata->volume_group;

  if( ( line_string_segment_size < 2 )

   || ( line_string_segment_index >= ( line_string_segment_size - 2 ) ) )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,

     LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,

     "%s: invalid line string segment size value out of bounds.",

     function );

    goto on_error;

  }

  if( libvslvm_internal_volume_group_set_name(

       (libvslvm_internal_volume_group_t *) metadata->volume_group,

       &( line_string_segment[ line_string_segment_index ] ),

       line_string_segment_size - ( line_string_segment_index + 2 ),

       error ) != 1 )

  {

    libcerror_error_set(

     error,

     LIBCERROR_ERROR_DOMAIN_RUNTIME,

     LIBCERROR_RUNTIME_ERROR_SET_FAILED,

     "%s: unable to set volume group name.",

     function );

    goto on_error;

  }

#if defined( HAVE_DEBUG_OUTPUT )

  if( libcnotify_verbose != 0 )

  {

    libcnotify_printf(

     "%s: name\t\t\t\t: %s\n",

     function,

     internal_volume_group->name );

  }

#endif

  *line_index += 1;

  while( *line_index < number_of_lines )

  {

    if( libcsplit_narrow_split_string_get_segment_by_index(

         lines,

         *line_index,

         &line_string_segment,

         &line_string_segment_size,

         error ) != 1 )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_GET_FAILED,

       "%s: unable to retrieve line: %d.",

       function,

       *line_index );

      goto on_error;

    }

    if( line_string_segment == NULL )

    {

      libcerror_error_set(

       error,

       LIBCERROR_ERROR_DOMAIN_RUNTIME,

       LIBCERROR_RUNTIME_ERROR_VALUE_MISSING,

       "%s: missing line string segment: %d.",

       function,

       *line_index );

      goto on_error;

    }

    /* Ignore trailing white space

     */

    if( line_string_segment_size >= 2 )

    {

      line_string_segment_index = line_string_segment_size - 2;

      while( line_string_segment_index > 0 )

      {

        if( ( line_string_segment[ line_string_segment_index ] != '\t' )

         && ( line_string_segment[ line_string_segment_index ] != '\n' )

         && ( line_string_segment[ line_string_segment_index ] != '\f' )

         && ( line_string_segment[ line_string_segment_index ] != '\v' )

         && ( line_string_segment[ line_string_segment_index ] != '\r' )

         && ( line_string_segment[ line_string_segment_index ] != ' ' ) )

        {

          break;

        }

        line_string_segment_index--;

        line_string_segment_size--;

      }

    }

    /* Ignore leading white space

     */

    line_string_segment_index = 0;

    while( line_string_segment_index < line_string_segment_size )

    {

      if( ( line_string_segment[ line_string_segment_index ] != '\t' )

       && ( line_string_segment[ line_string_segment_index ] != '\n' )

       && ( line_string_segment[ line_string_segment_index ] != '\f' )

       && ( line_string_segment[ line_string_segment_index ] != '\v' )

       && ( line_string_segment[ line_string_segment_index ] != '\r' )

       && ( line_string_segment[ line_string_segment_index ] != ' ' ) )

      {

        break;

      }

      line_string_segment_index++;

    }

    /* Skip an empty line

     */

    if( ( line_string_segment_index >= line_string_segment_size )

     || ( line_string_segment[ line_string_segment_index ] == 0 ) )

    {

      *line_index += 1;

      continue;

    }

    /* Check for the end of section

     */

    if( ( ( line_string_segment_size - line_string_segment_index ) == 2 )

     && ( line_string_segment[ line_string_segment_index ] == '}' ) )

    {

      *line_index += 1;

      break;

    }

    /* Check for the start of a sub section

     */

    if( ( line_string_segment_size - line_string_segment_index ) == 18 )

    {

      if( narrow_string_compare(

           &( line_string_segment[ line_string_segment_index ] ),

           "logical_volumes {",

           17 ) == 0 )

      {

        if( libvslvm_metadata_read_logical_volumes(

             metadata,

             metadata->volume_group,

             lines,

             number_of_lines,

             line_index,

             error ) != 1 )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_IO,

           LIBCERROR_IO_ERROR_READ_FAILED,

           "%s: unable to read logical volumes.",

           function );

          goto on_error;

        }

        continue;

      }

    }

    else if( ( line_string_segment_size - line_string_segment_index ) == 19 )

    {

      if( narrow_string_compare(

           &( line_string_segment[ line_string_segment_index ] ),

           "physical_volumes {",

           18 ) == 0 )

      {

        if( libvslvm_metadata_read_physical_volumes(

             metadata,

             metadata->volume_group,

             lines,

             number_of_lines,

             line_index,

             error ) != 1 )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_IO,

           LIBCERROR_IO_ERROR_READ_FAILED,

           "%s: unable to read physical volumes.",

           function );

          goto on_error;

        }

        continue;

      }

    }

    /* Determine the value identifier

     */

    value_identifier        = &( line_string_segment[ line_string_segment_index ] );

    value_identifier_length = 0;

    while( line_string_segment_index < line_string_segment_size )

    {

      if( ( line_string_segment[ line_string_segment_index ] == '\t' )

       || ( line_string_segment[ line_string_segment_index ] == '\n' )

       || ( line_string_segment[ line_string_segment_index ] == '\f' )

       || ( line_string_segment[ line_string_segment_index ] == '\v' )

       || ( line_string_segment[ line_string_segment_index ] == '\r' )

       || ( line_string_segment[ line_string_segment_index ] == ' ' )

       || ( line_string_segment[ line_string_segment_index ] == '=' ) )

      {

        break;

      }

      value_identifier_length++;

      line_string_segment_index++;

    }

    /* Skip a line not containing a value

     */

    if( ( line_string_segment_index >= line_string_segment_size )

     || ( line_string_segment[ line_string_segment_index ] == 0 ) )

    {

      *line_index += 1;

      continue;

    }

    /* Make sure the value identifier is terminated by an end of string

     */

    line_string_segment[ line_string_segment_index ] = 0;

    line_string_segment_index++;

    /* Ignore whitespace

     */

    while( line_string_segment_index < line_string_segment_size )

    {

      if( ( line_string_segment[ line_string_segment_index ] != '\t' )

       && ( line_string_segment[ line_string_segment_index ] != '\n' )

       && ( line_string_segment[ line_string_segment_index ] != '\f' )

       && ( line_string_segment[ line_string_segment_index ] != '\v' )

       && ( line_string_segment[ line_string_segment_index ] != '\r' )

       && ( line_string_segment[ line_string_segment_index ] != ' ' ) )

      {

        break;

      }

      line_string_segment_index++;

    }

    if( line_string_segment[ line_string_segment_index ] == '=' )

    {

      line_string_segment_index++;

      while( line_string_segment_index < line_string_segment_size )

      {

        if( ( line_string_segment[ line_string_segment_index ] != '\t' )

         && ( line_string_segment[ line_string_segment_index ] != '\n' )

         && ( line_string_segment[ line_string_segment_index ] != '\f' )

         && ( line_string_segment[ line_string_segment_index ] != '\v' )

         && ( line_string_segment[ line_string_segment_index ] != '\r' )

         && ( line_string_segment[ line_string_segment_index ] != ' ' ) )

        {

          break;

        }

        line_string_segment_index++;

      }

    }

    /* Skip a line not containing a value

     */

    if( ( line_string_segment_index >= line_string_segment_size )

     || ( line_string_segment[ line_string_segment_index ] == 0 ) )

    {

      *line_index += 1;

      continue;

    }

    /* Determine the value

     */

    value        = &( line_string_segment[ line_string_segment_index ] );

    value_length = line_string_segment_size - 1;

    /* Ingore quotes at the beginning of the value data

     */

    if( ( line_string_segment[ line_string_segment_index ] == '"' )

     || ( line_string_segment[ line_string_segment_index ] == '\'' ) )

    {

      line_string_segment_index++;

      value++;

      value_length--;

    }

    /* Ingore quotes at the end of the value data

     */

    if( ( line_string_segment[ value_length - 1 ] == '"' )

     || ( line_string_segment[ value_length - 1 ] == '\'' ) )

    {

      value_length--;

    }

    /* Make sure the value is terminated by an end of string

     */

    line_string_segment[ value_length ] = 0;

    value_length -= line_string_segment_index;

    if( value_identifier_length == 2 )

    {

      if( narrow_string_compare(

           value_identifier,

           "id",

           2 ) == 0 )

      {

        if( libvslvm_volume_group_set_identifier(

             metadata->volume_group,

             value,

             value_length + 1,

             error ) != 1 )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_SET_FAILED,

           "%s: unable to set volume group identifier.",

           function );

          goto on_error;

        }

#if defined( HAVE_DEBUG_OUTPUT )

        if( libcnotify_verbose != 0 )

        {

          libcnotify_printf(

           "%s: identifier\t\t\t\t: %s\n",

           function,

           internal_volume_group->identifier );

        }

#endif

      }

    }

    else if( value_identifier_length == 5 )

    {

      if( narrow_string_compare(

           value_identifier,

           "flags",

           5 ) == 0 )

      {

#if defined( HAVE_DEBUG_OUTPUT )

        if( libcnotify_verbose != 0 )

        {

          libcnotify_printf(

           "%s: flags\t\t\t\t: %s\n",

           function,

           value );

        }

#endif

/* TODO */

      }

      else if( narrow_string_compare(

                value_identifier,

                "seqno",

                5 ) == 0 )

      {

#if defined( HAVE_DEBUG_OUTPUT )

        if( libcnotify_verbose != 0 )

        {

          libcnotify_printf(

           "%s: sequence number\t\t\t: %s\n",

           function,

           value );

        }

#endif

        if( libfvalue_utf8_string_copy_to_integer(

             (uint8_t *) value,

             value_length + 1,

             &value_64bit,

             32,

             LIBFVALUE_INTEGER_FORMAT_TYPE_DECIMAL_UNSIGNED,

             error ) != 1 )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_MEMORY,

           LIBCERROR_MEMORY_ERROR_SET_FAILED,

           "%s: unable to set sequence number.",

           function );

          goto on_error;

        }

        if( value_64bit > (uint64_t) UINT32_MAX )

        {

          libcerror_error_set(

           error,

           LIBCERROR_ERROR_DOMAIN_RUNTIME,

           LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM,

           "%s: invalid sequence number value exceeds maximum.",

           function );

          goto on_error;

        }

        internal_volume_group->sequence_number = (uint32_t) value_64bit;

      }

    }